vtereshkov / umka-lang Goto Github PK

Umka: a statically typed embeddable scripting language

License: BSD 2-Clause "Simplified" License

C 95.31% Shell 0.66% Batchfile 0.69% Python 1.27% Lua 0.25% Makefile 0.34% OCaml 0.30% HTML 1.07% Wren 0.13%

programming-language scripting-language compiler interpreter virtual-machine cross-platform concurrency coroutines fibers c

umka-lang's People

Contributors

Stargazers

Watchers

Forkers

przor3n andrdm tsukanov-as mkl256 laeeth jbulow gromgit stensalweb zeta1999 felix-lang mazdaywik adabadadudu sotheycan chitushka vladimirshleyev kgorin8 haifenghuang jkam1211 gitcnsh-dslin yuriv samuelmarks kakadu joaovsq lisprez irwin1985 rnshah9 watch-later marekmaskarinec chai2010 swordow redchew-fork drmidnight patrickt ajunlonglive gg-big-org boraseoksoon forchid zeozeozeo clayne sarvex 0inadochronbi ivoes judah-caruso gmh5225 troceralab thacuber2a03 lino-levan imaginarystargazer michael0500 tazdij devydhanish skejeton angluca astrolemonade

umka-lang's Issues

Dangling pointers by premature releasing local variables

In actual Umka version stack frames are allocated in heap instead system stack. If frame contains pointers, they are freeing on function return. But stack frame may alive after return — it may be saved by pointers to local variables. And the local variables can reference to dangling pointers:

const (
  SIZE = 100
  LOOPS = 10
)

type (
  object = struct {
    x: [SIZE] int
  }
)

fn make_dangling(init: int): ^^object {
  po := new(object)
  for i := 0; i < SIZE; i++ {
    po.x[i] = init
  }

  ppo := &po
  return ppo
}

fn check(po: ^object, init: int) {
  i := 0;
  for i < SIZE && po.x[i] == init {
    i++
  }

  if i == SIZE {
    printf("%d Ok\n", init)
  } else {
    printf("%d Err\n", init)
  }
}

fn test1() {
  var oarr: [LOOPS] ^object

  for i := 0; i < LOOPS; i++ {
    ppo := make_dangling(i)
    oarr[i] = ppo^
    check(oarr[i], i)
  }
}

fn test2() {
  var oarr: [LOOPS] ^object

  for i := 0; i < LOOPS; i++ {
    ppo := make_dangling(i)
    oarr[i] = ppo^
  }

  for i := 0; i < LOOPS; i++ {
    check(oarr[i], i)
  }
}

fn main() {
  test1()
  test2()
}

Output:

D:\…\umka-lang\umka_windows_mingw>umka.exe dangling.um
0 Ok
1 Ok
2 Ok
3 Ok
4 Ok
5 Ok
6 Ok
7 Ok
8 Ok
9 Ok
0 Err
1 Err
2 Err
3 Err
4 Err
5 Err
6 Err
7 Err
8 Err
9 Ok

Download: dangling.um.

Memory leak in C/Umka interop

When a heap-allocated argument is passed to an external C function, its ref count is not decremented upon exit:

f := std.fopen("data" + ".dat", "w")

Benchmark

Hi there!
Is it possible to add compare benchmarks for Umka, Wren.io, Lua?
Two suits:

calling C function from script.
calling sript function from C.
Like this: http://wren.io/performance.html

calling imported functions from C

I'm trying to call a function imported from the compiled file, does Umka support this?

fn foo() {printf("hello from b!")}

import "b.um"

fn main() {}

umkaInit("a.um", 1024 * 1024, 1024 * 1024, 0, NULL);
b = umkaGetFunc("b.foo");

Strange type checker error

This code is correct and normally works in Umka:

fn make_dangling(): ^^int{
  var po: ^int
  return &po
}

fn main() {
  var po: ^int
  ppo := make_dangling()
  po = ppo^
}

But if I remove indirect (variable ppo) I get a syntax error:

fn main() {
  var po: ^int
  po = make_dangling()^
}

Error syntax-error.um (9, 1): Incompatible types ^int and int

Memory leak if a fiber function does not return

The reference count for buf is increased when passed to fiberspawn() and decreased upon returning from f(). If fibercall() is not called, it never gets decreased.

fn f(parent: ^fiber, buf: ^int) {}

fn main() {
    buf := new(int)
    thread := fiberspawn(f, buf)
}

Passing parameters from C to Umka

A procedure is a function that does not return a value, a return of void is used in C.
Do Umka functions always return a value?

If so, what component of UmkaStackSlot will be filled, and by what value?

If a function has no return value can a NULL be passed as the address of the slot to hold the return value (implying no value is stored).

I guess also when calling a function with no arguments, a NULL can be given as the address of the parameter array, since the count of boxes is specified as 0, is this correct?

Just clarifying boundary cases (since Felix has a very strict type system and I want the types to match the API semantics accurately if possible)

Type assertion with interfaces

Is there a way to do that, or is it not implemented yet?

What does 'Umka' mean/stand-for?

This might not be the most important question in the world :^) Google tells me it's an anglicization of Умка a suburb of Belgrade, but I'm not getting anything else. I'm curious.

Memory leak when a heap-allocated structure with a heap-allocated field is converted to an interface

The following code causes a memory leak:

type (
    st = struct {p: ^[] int}
    fooable = interface {foo()}
)

fn (s: ^st) foo() {}

fn main() {
    s := new(st)
    s.p = new([100] int)
    f := fooable(s^)
    f.foo()
}

Struct values corruption

I'm passing 2 vector structs defined like this:

type (
    vec3* = struct {x, y, z: real32}
)

In a function defined like this:

fn CreateSphere *(pos, clr: vec3, rv, rd: real): int32

The call looks like this:

head := r8.CreateSphere(r8.vec3{0.1, 0.2, 0.3}, r8.vec3{0.4, 0.5, 0.6}, 0.7, 0.8)

The func bind in C:

void umCreateSphere(UmkaStackSlot* p, UmkaStackSlot* r) {
        vec3* pos = (vec3*)&p[3];
        vec3* clr = (vec3*)&p[2];
        float rv  = (float) p[1].realVal;
        float rd  = (float) p[0].realVal;

        printf("%.1f, %.1f, %.1f, %.1f, %.1f, %.1f, %.1f, %.1f\n", pos->x, pos->y, pos->z, clr->x, clr->y, clr->z, rv, rd);

        int i = createSphere(*pos, *clr, rv, rd);

        r[0].intVal = i;
}

C vector struct definition:

typedef struct {
        float x, y, z;
} vec3;

I would expect the printf to output to be 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8
but the output is 0.6, 0.0, 0.1, 0.4, 0.5, 0.6, 0.7, 0.8
Only the position vector gets corrupted.

The code is from here
src/umka/bindings.c, src/vector.h, scripts/game.um, scripts/r8/r8.um

Overflow checking

$ cat mike.um
import "import/std.um"
fn main() {
    var r: int8
    r = 0xff
    std.println(repr(r))
}
$ umka mike.um
-1

Recursive types cause stack overflow in error reporter

This can be trivially demonstrated using the following Umka code:

type Foo = ^Foo
var a: Foo = 0

Because the error reporter attempts to output the full definition of the type, resolving any type definitions, it loops infinitely on a recursive type. Since it uses recursion, this infinite loop quickly outgrows the stack and causes a segmentation fault.

function no passing arguments

I have a function:

fn (i: ^img) scale*(x, y: real32) {
	printf("umka vals: %f, %f\n", x, y)
	imgsetscale(x, y, i.handle)
}

and call it like this:

img.scale(1, 1)

But the output it prints is: umka vals: 0.000000, 0.000000

I tried with multiple values, not only 1.

Variable redeclaration warning/error

This passes just fine for some reason:

var i: int

fn somefunc() {
  i := 2
}

fn main() {
  i = 3

  somefunc()

  printf("%d\n", i)
}

This will print out 3, but I think, it should return an warning. It can be really confusing.

Stack trace on runtime error

It would really help.

Import needs path

I have a working Felix binding to basic Umka, here is the run:

~/felix>flx umkahello.flx
init ok = true
compile ok = true
Hello Umka!
run ok = true

~/felix>cat umkahello.flx
include "std/umka";
open Umka;

var amt = 1024 * 1024;
var umka = umkaAlloc();
var hellostr =
c"""fn main() {
    printf("Hello Umka!\\n")
}
""";

var ok = umkaInit (umka, c"Dummy", hellostr, amt, amt,0,C_hack::cast[+(+char)]0);
println$ "init ok = " + ok.str;
ok = umkaCompile umka;
println$ "compile ok = " + ok.str;
ok = umkaRun umka;
println$ "run ok = " + ok.str;
umkaFree umka;

This is fine! However to do anything complex I need to be able to import modules, in particular, the standard library std.um. This raises some issues:

First, loading a file from an embedded application is not acceptable, nor is loading it from an executable written in C and redistributed to clients: the executable should just run from anywhere and with no need to access the client file system. This is because Umka is intended as a small footprint micro embedded interpreter.

Secondly, even with a hosted application, the file search algorithm is not specified.

Third, using an operating system specific filename is not acceptable. Note that in C, using Unix filenames works on all platforms including Windows.

Possible solutions

One way to fix this is to decouple the language specific module loading from its location.
Python does this, for example, and so does Felix. You could say:

require module "std";

in Umka. Now, how do we find it? The most general way is to use a C API call to provide a string containing the module text, and associate it with the module name, something like:

bool ok = umkaRegisterModule (umka, "modname", "//module code goes here");

Then, the C program is responsible for finding the file and loading it, or, it can just physically include the text of the module as a C string, which is what you'd want for an embedded application.

Note that in a real embedded application, the programmer would want strict control over what C functions Umka scripts written by their clients could call, and to pass any security vetting the host C program would necessarily have to be self-contained, and visibly restrict Umka scripts to a fixed, trusted, set of C functions.

Just an FYI: it's worse. The embedded module scripts would almost certainly also have to be encrypted either for commercial or national security reasons (string literals in executables are easy to not only see, but also modify). But this is another story.

`array[:n]`, `array[n:]` and `array[n:o]` support

Is this supported/does it have different syntax from go?

Overriding bindings of std.um functions

I need to provide my custom function for fopen. I could make a separate tophat/io.um module, but I think that would be weird. Is it ok to use umkaBind on fopen?

How to save/load bytecode

Possible?

Thanks

Jarrod

umkaAddFunc() fails on PPC platform

system.um

fn init() {
  printf("Initializing system\n")
  allocateFramebuffer()
}

fn loop() {
  printf("loop\n")
}

main.c

/*
Copyleft (ɔ) 2020 sandthief

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU Affero General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

This code is based on code from

        Vasiliy Tereshkov
	Peter Mackay
	Eluan Miranda
	Fabio Olimpieri

Thank you!
*/

#include <stdlib.h>
#include <stdio.h>
#include <umka_api.h>
#include <string.h>
#include <gccore.h>
#include <wiiuse/wpad.h>

// Global variables
static void       *xfb              = NULL;
static GXRModeObj *rmode            = NULL;
           void	    	*framebuffer[2]	= {NULL, NULL};

void allocateFramebuffer(UmkaStackSlot *params, UmkaStackSlot *result) {
	printf("Allocating framebuffer");
}
int main(int argc, char **argv) {

  VIDEO_Init();
  WPAD_Init();

  rmode = VIDEO_GetPreferredMode(NULL);
  xfb = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));

  console_init(xfb, 20, 20, rmode->fbWidth, rmode->xfbHeight,
               rmode->fbWidth * VI_DISPLAY_PIX_SZ);

  VIDEO_Configure(rmode);
  VIDEO_SetNextFramebuffer(xfb);
  VIDEO_SetBlack(FALSE);
  VIDEO_Flush();
  VIDEO_WaitVSync();

  if (rmode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync();

  if (!fatInitDefault()) {
    printf("Unable to initialise FAT subsystem, exiting.\n");
    exit(0);
  }

  void *umka = umkaAlloc();
  umkaInit(umka, "sd:/system.um", 1024 * 1024, 1024 * 1024, 0, NULL);

	// Add builtin functions
	umkaAddFunc(umka, "allocateFramebuffer", &allocateFramebuffer);

  umkaCompile(umka);

  // Get functions
 int init   = umkaGetFunc(umka, "sd:/system.um", "init");
 int loop = umkaGetFunc(umka, "sd:/system.um", "loop");

  umkaCall(umka, init, 0, NULL, NULL);



  while (1) {
    // Call WPAD_ScanPads each loop, this reads the latest controller states
    WPAD_ScanPads();

    // WPAD_ButtonsDown tells us which buttons were pressed in this loop
    // this is a "one shot" state which will not fire again until the button has
    // been released
    u32 pressed = WPAD_ButtonsDown(0);

    // We return to the launcher application via exit
    if (pressed & WPAD_BUTTON_HOME) exit(0);

		umkaCall(umka, loop, 0, NULL, NULL);

    // Wait for the next frame
    VIDEO_WaitVSync();
  }

	umkaFree(umka);
  return 0;
}

Am I doing something wrong?

Thank you so much for helping me

Init with string

The existing umkaInit function takes a string naming a file.

This is useful only for testing correctness of umka, it is of no use for the
primary purpose of the product, namely as an embedded scripting language
which can interact with a C environment.

So I propose to add a function that accepts a char const * which is an NTBS containing
the text of an Umka script.

A decision must be made on the ownership of the string and documented.
If the caller retains ownership, the lifetime must be specified.
Otherwise if ownership is passed to the called function, the allocation method the client
must use (eg malloc()) must be specified.

I think, although not at all sure, that the client should retain ownership, because
a common case would be to pass a string literal, which is likely in static storage
and cannot be deleted.

Use non-recursive ref counting

Naive implementation of freeing reference counted memory requires recursion. Depth of recursion calls is equal depth of object graph. There are example that Umka crashes on:

type list = struct {
  value: int
  next: ^list
}

fn test() {
  var p: ^list

  for i := 0; i < 1000000; i++ {
    n := new(list)
    n.value = i
    n.next = p
    p = n
  }
}

fn main() {
  test()
  printf("Ok")
}

Download: stack-overflow.um.

There are a way for freeing reference counted memory with constant stack.

method not found even though method exists

I have this function:

fn (i: ^img) scale*(x, y: real32) {
	imgsetscale(x, y, i^)
}

Then I have an image in entity struct like this:

type ent* = struct {
	p: polygon.poly
	image: image.img	
	color: uint32
	id: int32
}

But when I want to call the function, I get Method scale is not found, structure expected to look for field.

I call it like this:

	player := entity.mk(p, 0xff00ffff, 20)
	img := image.load("test.bmp")
	player.image = img

	player.image.scale(0.2, 0.2)

What am I doing wrong?

Memory leak when the last array ref is an item ref

This code causes a memory leak:

type ent = []int	

fn main() {
	var s: ^ent
	t := []ent{}
	
	for i := 0; i < 3; i++ {
		t = append(t, []int{7})
		s = &t[0]
	}
}

A shorter example without append():

var p: ^^int

fn main() {
	a := []^int{new(int), new(int)}
	p = &a[1]
}

How to write a Cloneable interface?

Я попробовал это сделать так:

type Point = struct {
  x: int
  y: int
  z: int
}

fn (self: ^Point) clone(): ^Point {
  p := new(Point)
  p.x = self.x
  p.y = self.y
  p.z = self.z
  return p
}

type Cloneable = interface {
  clone(): Cloneable
}

fn main() {
  p := new(Point)
  var c: Cloneable
  c = p
}

Получаю ошибку

Error clone.um (16, 21): Unknown identifier Cloneable

Исправляю, чтобы метод интерфейса Cloneable возвращал указатель:

…

type Cloneable = interface {
  clone(): ^Cloneable
}
…

Получаю другую ошибку:

Error clone.um (23, 1): Method clone has incompatible signature

Третья попытка:

type Point = struct {
  x: int
  y: int
  z: int
}

type Cloneable = interface {
  clone(): ^Cloneable
}

fn (self: ^Point) clone(): ^Cloneable {
  p := new(Point)
  p.x = self.x
  p.y = self.y
  p.z = self.z
  pp := new(^Cloneable)
  pp^ = p
  return pp
}

fn main() {
  p := new(Point)
  var c: Cloneable
  c = p
}

Третья ошибка:

Error clone.um (18, 1): Incompatible types ^Cloneable and ^Point

Interior pointers are not ref-counted

This code causes a segmentation fault:

fn main() {    
    var p: ^int
    {
        a := new([2]int)
        a[1] = 7
        p = &a[1]
    }
    printf(repr(p^) + '\n')
}

Interpreter segfaults on pointer assignment

Example:

type (
  P1 = ^S1
  P2 = ^S2

  S1 = struct {
    x: int
    next: P1
  }

  S2 = struct {
    x: int
    next: P2
  }
)

fn main() {
  var p1 : P1

  p1 = new(S2)
}

Download: pointers.um.txt.

There are problem in implementation of structural type equivalence. Umka implements structural type system, types are equivalent if its have same structure. Types P1 and P2 are equivalent by the specification (Type compatibility), but type checker goes mad on recursive equivalence.

GDB proofs my opinion

D:\…\umka_0.4_x86-64_windows_mingw>gdb --args umka.exe pointers.um
GNU gdb (GDB) 7.6
Copyright (C) 2013 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-w64-mingw32".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from D:\…\umka.exe...done.
(gdb) r
Starting program: D:\…\umka.exe pointers.um
[New Thread 5796.0x1770]
[New Thread 5796.0x25cc]
[New Thread 5796.0x2d9c]
[New Thread 5796.0x1ebc]

Program received signal SIGSEGV, Segmentation fault.
0x000000006ec53bce in typeEquivalent () from D:\…\libumka.dll
(gdb) bt
#0  0x000000006ec53bce in typeEquivalent () from D:\…\libumka.dll
#1  0x0000000000000000 in ?? ()
(gdb) q
A debugging session is active.

        Inferior 1 [process 5796] will be killed.

Quit anyway? (y or n) y

Interpreter fails at a function named typeEquivalent().

Structural type system is very interesting!

Comparison with Go

Please add differences from the Go language to the description. This will make it easier to understand the capabilities of the new language.

Illegal expression

I'm getting this error: (51, 66): Illegal expression, although I think, I have it correctly.

Code:

 47   infs = []infc{ 
 48     infc {9, 0, 1000, fn() { player.magespeed = 0.08 }, inf {0, fn() { player.magespeed = 0.1 }}}, // slowdown
 49     infc {19, 10, 1000, fn() { player.magespeed = 0.12 }, inf {0, fn() { player.magespeed = 0.1 }}}, // speedup 
 50     infc {24, 20, 0, fn() { player.shieldend = global.t + 10000 }, inf {0, fn() {  }}}, // slowdown
 51     infc {29, 25, 0, fn() { player.hp = 10 }, inf {0, fn() { }}}, // health regen
 52   }

Here are the two structs:

type inf = struct {
	end: int
	endfunc: fn()
}

type infc = struct {
	s: int
	b: int
	l: int
	do: fn()
	inf: inf
}

How to compile the '3dcam' example?

Hi,
How to compile the embedded example in 3dcam.c?
Thanks
Ben

Using slice on string

I tried to use slice on string, and it gave me the incompatible type error. Then I tried casting it to []char, like you would do in go, which gave me the invalid type cast error. Is there a way to slice strings?

UndefinedBehaviorSanitizer warnings: load/store of misaligned address

o) gcc-clang под -fsanitize=undefined ругается
o) address и memory OK ;)

$ ../umka tour.um 
src/umka_common.c:223:23: runtime error: left shift of 193487582 by 5 places cannot be represented in type 'int'
src/umka_common.c:223:29: runtime error: signed integer overflow: -1942746351 + -2038341088 cannot be represented in type 'int'
src/umka_const.c:39:50: runtime error: store to misaligned address 0x7fc435fa80a4 for type 'double', which requires 8 byte alignment
0x7fc435fa80a4: note: pointer points here
  6c 64 21 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00
              ^ 
Arr:    2.300   -2.050    2.380
Done
src/umka_vm.c:366:50: runtime error: store to misaligned address 0x7fc435fa6f5f for type 'void *', which requires 8 byte alignment
0x7fc435fa6f5f: note: pointer points here
 00 00 00 00 00  00 00 00 00 00 00 00 00  04 00 00 00 00 00 00 00  28 00 00 00 00 00 00 00  a8 60 6a
             ^ 
3 is odd
src/umka_vm.c:333:59: runtime error: load of misaligned address 0x7fc435fa6f5f for type 'void *', which requires 8 byte alignment
0x7fc435fa6f5f: note: pointer points here
 c4 7f 00 00 58  61 6a 35 c4 7f 00 00 00  04 00 00 00 00 00 00 00  28 00 00 00 00 00 00 00  a8 60 6a
             ^ 
src/umka_vm.c:356:50: runtime error: store to misaligned address 0x7fc435fa6f3f for type 'int64_t', which requires 8 byte alignment
0x7fc435fa6f3f: note: pointer points here
 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 68  62 6a 35
             ^ 
src/umka_vm.c:323:49: runtime error: load of misaligned address 0x7fc435fa6f3f for type 'int64_t', which requires 8 byte alignment
0x7fc435fa6f3f: note: pointer points here
 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 68  62 6a 35
             ^ 
src/umka_vm.c:1128:40: runtime error: load of misaligned address 0x7fc435fa6f3f for type 'int64_t', which requires 8 byte alignment
0x7fc435fa6f3f: note: pointer points here
 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 68  62 6a 35
             ^ 
src/umka_vm.c:1128:57: runtime error: store to misaligned address 0x7fc435fa6f3f for type 'int64_t', which requires 8 byte alignment
0x7fc435fa6f3f: note: pointer points here
 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 68  62 6a 35
             ^ 
src/umka_vm.c:187:18: runtime error: member access within misaligned address 0x7fc4356a6271 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a6271: note: pointer points here
 6f 64 64  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00
              ^ 
src/umka_vm.c:188:19: runtime error: member access within misaligned address 0x7fc4356a6271 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a6271: note: pointer points here
 6f 64 64  00 21 43 65 87 78 56 34  12 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00
              ^ 
src/umka_vm.c:189:17: runtime error: member access within misaligned address 0x7fc4356a6271 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a6271: note: pointer points here
 6f 64 64  00 21 43 65 87 78 56 34  12 01 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00
              ^ 
src/umka_vm.c:168:22: runtime error: member access within misaligned address 0x7fc4356a6271 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a6271: note: pointer points here
 6f 64 64  00 21 43 65 87 78 56 34  12 01 00 00 00 00 01 00  00 00 00 00 00 00 00 00  00 00 00 00 00
              ^ 
src/umka_vm.c:207:14: runtime error: member access within misaligned address 0x7fc4356a6271 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a6271: note: pointer points here
 6f 64 64  00 21 43 65 87 78 56 34  12 01 00 00 00 00 01 00  00 00 00 00 00 00 00 00  00 00 00 00 00
              ^ 
src/umka_vm.c:209:23: runtime error: member access within misaligned address 0x7fc4356a6271 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a6271: note: pointer points here
 6f 64 64  00 21 43 65 87 78 56 34  12 01 00 00 00 00 01 00  00 00 00 00 00 00 00 00  00 00 00 00 00
              ^ 
src/umka_vm.c:209:23: runtime error: member access within misaligned address 0x7fc4356a6271 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a6271: note: pointer points here
 6f 64 64  00 21 43 65 87 78 56 34  12 01 00 00 00 00 01 00  00 00 00 00 00 00 00 00  00 00 00 00 00
              ^ 
src/umka_vm.c:168:22: runtime error: member access within misaligned address 0x7fc4356a6271 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a6271: note: pointer points here
 6f 64 64  00 21 43 65 87 78 56 34  12 03 00 00 00 00 01 00  00 34 00 00 00 00 00 00  00 00 00 00 00
              ^ 
src/umka_vm.c:398:30: runtime error: member access within misaligned address 0x7fc4356a6271 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a6271: note: pointer points here
 6f 64 64  00 21 43 65 87 78 56 34  12 03 00 00 00 00 01 00  00 34 00 00 00 00 00 00  00 00 00 00 00
              ^ 
src/umka_vm.c:207:14: runtime error: member access within misaligned address 0x7fc4356a6271 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a6271: note: pointer points here
 6f 64 64  00 21 43 65 87 78 56 34  12 03 00 00 00 00 01 00  00 34 00 00 00 00 00 00  00 00 00 00 00
              ^ 
src/umka_vm.c:209:23: runtime error: member access within misaligned address 0x7fc4356a6271 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a6271: note: pointer points here
 6f 64 64  00 21 43 65 87 78 56 34  12 03 00 00 00 00 01 00  00 34 00 00 00 00 00 00  00 00 00 00 00
              ^ 
src/umka_vm.c:209:23: runtime error: member access within misaligned address 0x7fc4356a6271 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a6271: note: pointer points here
 6f 64 64  00 21 43 65 87 78 56 34  12 03 00 00 00 00 01 00  00 34 00 00 00 00 00 00  00 00 00 00 00
              ^ 
len = 4
4.680
src/umka_vm.c:364:50: runtime error: store to misaligned address 0x7fc435fa6ef7 for type 'double', which requires 8 byte alignment
0x7fc435fa6ef7: note: pointer points here
 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00
             ^ 
src/umka_vm.c:372:50: runtime error: store to misaligned address 0x7fc435fa6ee7 for type 'int64_t', which requires 8 byte alignment
0x7fc435fa6ee7: note: pointer points here
 eb 55 00 00 00  00 00 00 00 00 00 00 c9  65 6a 35 c4 7f 00 00 00  00 00 00 00 00 e0 3f 66  66 66 66
             ^ 
src/umka_vm.c:491:19: runtime error: load of misaligned address 0x7fc435fa6ed7 for type 'void *', which requires 8 byte alignment
0x7fc435fa6ed7: note: pointer points here
 00 00 00 00 c9  65 6a 35 c4 7f 00 00 f0  3b 4a 45 eb 55 00 00 86  01 00 00 00 00 00 00 c9  65 6a 35
             ^ 
src/umka_vm.c:492:19: runtime error: load of misaligned address 0x7fc435fa6edf for type 'struct Type *', which requires 8 byte alignment
0x7fc435fa6edf: note: pointer points here
 c4 7f 00 00 f0  3b 4a 45 eb 55 00 00 86  01 00 00 00 00 00 00 c9  65 6a 35 c4 7f 00 00 00  00 00 00
             ^ 
src/umka_vm.c:207:14: runtime error: member access within misaligned address 0x7fc4356a65b9 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a65b9: note: pointer points here
 00 00 00  00 21 43 65 87 78 56 34  12 01 00 00 00 18 00 00  00 00 00 00 00 00 00 e0  3f 66 66 66 66
              ^ 
src/umka_vm.c:209:23: runtime error: member access within misaligned address 0x7fc4356a65b9 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a65b9: note: pointer points here
 00 00 00  00 21 43 65 87 78 56 34  12 01 00 00 00 18 00 00  00 00 00 00 00 00 00 e0  3f 66 66 66 66
              ^ 
src/umka_vm.c:209:23: runtime error: member access within misaligned address 0x7fc4356a65b9 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a65b9: note: pointer points here
 00 00 00  00 21 43 65 87 78 56 34  12 01 00 00 00 18 00 00  00 00 00 00 00 00 00 e0  3f 66 66 66 66
              ^ 
src/umka_vm.c:339:49: runtime error: load of misaligned address 0x7fc435fa6f1f for type 'int64_t', which requires 8 byte alignment
0x7fc435fa6f1f: note: pointer points here
 eb 55 00 00 86  01 00 00 00 00 00 00 b9  64 6a 35 c4 7f 00 00 91  63 6a 35 c4 7f 00 00 81  62 6a 35
             ^ 
src/umka_vm.c:331:49: runtime error: load of misaligned address 0x7fc4356a65c9 for type 'double', which requires 8 byte alignment
0x7fc4356a65c9: note: pointer points here
 18 00 00  00 00 00 00 00 00 00 e0  3f 66 66 66 66 66 66 e6  3f cd cc cc cc cc cc ec  3f 00 00 00 00
              ^ 
Arr:    0.500    0.700    0.900
src/umka_vm.c:920:12: runtime error: store to misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00
              ^ 
src/umka_vm.c:922:18: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 70 7a 35 c4 7f 00  00 d0 6d fa 35
              ^ 
src/umka_vm.c:923:12: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 d0 6d fa 35
              ^ 
src/umka_vm.c:925:24: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 d0 6d fa 35
              ^ 
src/umka_vm.c:925:17: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 d0 6d fa 35
              ^ 
src/umka_vm.c:926:24: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 d0 4d 6a 35
              ^ 
src/umka_vm.c:926:17: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 d0 4d 6a 35
              ^ 
src/umka_vm.c:929:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 d0 4d 6a 35
              ^ 
src/umka_vm.c:929:28: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 d0 4d 6a 35
              ^ 
src/umka_vm.c:929:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 c8 4d 6a 35
              ^ 
src/umka_vm.c:930:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 c8 4d 6a 35
              ^ 
src/umka_vm.c:930:28: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 c8 4d 6a 35
              ^ 
src/umka_vm.c:930:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 c0 4d 6a 35
              ^ 
src/umka_vm.c:931:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 c0 4d 6a 35
              ^ 
src/umka_vm.c:931:28: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 c0 4d 6a 35
              ^ 
src/umka_vm.c:931:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:932:15: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 f0 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
Parent: i=0 buf=0
src/umka_vm.c:955:31: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:943:37: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:1565:18: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:1565:31: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:1568:22: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:1568:34: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:1517:21: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:1517:33: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:1520:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:1520:35: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:1523:44: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:1523:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:1523:28: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b8 4d 6a 35
              ^ 
src/umka_vm.c:1523:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b0 4d 6a 35
              ^ 
src/umka_vm.c:1524:24: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b0 4d 6a 35
              ^ 
src/umka_vm.c:1524:17: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b0 4d 6a 35
              ^ 
src/umka_vm.c:1525:16: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b0 4d 6a 35
              ^ 
src/umka_vm.c:1525:16: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 b0 4d 6a 35
              ^ 
src/umka_vm.c:1531:21: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 80 4d 6a 35
              ^ 
src/umka_vm.c:1534:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 80 4d 6a 35
              ^ 
src/umka_vm.c:1534:21: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 80 4d 6a 35
              ^ 
src/umka_vm.c:1534:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 78 4d 6a 35
              ^ 
src/umka_vm.c:1534:21: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 78 4d 6a 35
              ^ 
src/umka_vm.c:1535:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 78 4d 6a 35
              ^ 
src/umka_vm.c:1535:21: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 78 4d 6a 35
              ^ 
src/umka_vm.c:1535:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 70 4d 6a 35
              ^ 
src/umka_vm.c:1535:21: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 70 4d 6a 35
              ^ 
src/umka_vm.c:1536:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 70 4d 6a 35
              ^ 
src/umka_vm.c:1536:21: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 70 4d 6a 35
              ^ 
src/umka_vm.c:1536:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1536:21: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1538:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1538:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:975:35: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a4 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:975:47: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a4 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:975:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a4 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:975:28: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a4 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:975:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a4 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:977:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a4 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:977:26: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a4 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:980:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a4 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:980:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a4 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:987:55: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a5 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:987:69: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a5 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:987:81: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a5 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:987:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a5 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:987:28: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a5 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:987:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a5 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:989:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a5 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:989:26: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a5 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:992:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a5 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:992:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a5 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1057:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1057:26: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1058:9: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1060:22: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1060:27: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1061:31: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1061:36: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1063:67: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1063:79: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1063:34: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1063:46: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1064:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1064:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a6 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:990:39: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a7 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:990:51: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a7 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:990:9: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a7 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1170:22: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1170:27: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1172:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1172:26: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1198:19: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1198:31: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1221:19: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1221:31: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1258:22: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1258:34: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1287:59: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1287:38: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1294:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1294:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 a9 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1384:15: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 aa 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1384:20: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 aa 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1385:26: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 aa 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1385:38: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 aa 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1385:19: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 aa 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1394:27: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1394:39: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1395:29: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1401:35: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1401:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1401:28: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1401:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 40 4d 6a 35
              ^ 
src/umka_vm.c:1402:15: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 40 4d 6a 35
              ^ 
src/umka_vm.c:1416:32: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d1 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1416:44: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d1 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1417:32: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d1 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1417:44: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d1 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1472:90: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d1 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1472:42: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d1 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1490:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d1 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1490:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d1 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1035:22: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d2 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1036:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d2 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1036:21: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d2 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1036:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d2 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 00 4d 6a 35
              ^ 
src/umka_vm.c:1037:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d2 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 00 4d 6a 35
              ^ 
src/umka_vm.c:1037:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d2 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 00 4d 6a 35
              ^ 
src/umka_vm.c:1070:38: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d5 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1071:30: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d5 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1071:42: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d5 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1072:38: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d5 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1072:50: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d5 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1076:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d5 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1076:26: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d5 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1079:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d5 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1079:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d5 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1028:70: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d9 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1028:75: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d9 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1028:21: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d9 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:1028:33: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d9 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:1028:62: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d9 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:1029:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d9 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:1029:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d9 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:731:80: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 df 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:732:61: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 df 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:733:30: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 df 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:733:42: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 df 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:760:56: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 df 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:762:41: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 df 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:762:41: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 df 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:763:40: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 df 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:763:40: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 df 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:765:45: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 df 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:765:45: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 df 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1021:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e0 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1021:15: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e0 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1022:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e0 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:1022:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e0 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:998:46: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e4 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:998:58: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e4 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:998:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e4 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:998:28: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e4 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:998:13: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e4 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:998:79: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e4 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:999:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e4 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:999:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e4 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1378:22: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e9 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:1378:34: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e9 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:1378:15: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e9 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:1077:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 eb 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1077:19: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 eb 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 08 4d 6a 35
              ^ 
src/umka_vm.c:1545:43: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:1545:48: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 10 4d 6a 35
              ^ 
src/umka_vm.c:1545:34: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 18 4d 6a 35
              ^ 
src/umka_vm.c:1546:43: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 18 4d 6a 35
              ^ 
src/umka_vm.c:1546:48: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 18 4d 6a 35
              ^ 
src/umka_vm.c:1546:34: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 20 4d 6a 35
              ^ 
src/umka_vm.c:1547:43: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 20 4d 6a 35
              ^ 
src/umka_vm.c:1547:48: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 20 4d 6a 35
              ^ 
src/umka_vm.c:1547:34: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 28 4d 6a 35
              ^ 
src/umka_vm.c:1550:23: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 28 4d 6a 35
              ^ 
src/umka_vm.c:1550:16: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 28 4d 6a 35
              ^ 
src/umka_vm.c:1551:33: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 38 4d 6a 35
              ^ 
src/umka_vm.c:1551:38: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 38 4d 6a 35
              ^ 
src/umka_vm.c:1551:17: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 40 4d 6a 35
              ^ 
src/umka_vm.c:1553:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 40 4d 6a 35
              ^ 
src/umka_vm.c:1553:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ee 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 40 4d 6a 35
              ^ 
src/umka_vm.c:1604:26: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ef 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 40 4d 6a 35
              ^ 
src/umka_vm.c:1497:30: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ef 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 40 4d 6a 35
              ^ 
src/umka_vm.c:1497:35: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ef 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 40 4d 6a 35
              ^ 
src/umka_vm.c:1508:20: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ef 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1508:28: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ef 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1508:40: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ef 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1508:20: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ef 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1509:19: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ef 00 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1613:27: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b4 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1174:19: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b8 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1177:22: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b8 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1177:34: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b8 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1181:67: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b8 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1182:42: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b8 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1184:22: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 b8 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:1050:35: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 c3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1050:47: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 c3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1050:5: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 c3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1051:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 c3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
src/umka_vm.c:1051:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 c3 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 48 4d 6a 35
              ^ 
Child : i=0 buf=0
src/umka_vm.c:1262:34: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d4 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 58 4d 6a 35
              ^ 
src/umka_vm.c:942:32: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d7 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:942:37: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 d7 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
Parent: i=1 buf=0
src/umka_vm.c:1107:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ad 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1107:26: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ad 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1114:22: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ad 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1114:34: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ad 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1122:43: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ad 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1122:48: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ad 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 60 4d 6a 35
              ^ 
src/umka_vm.c:1123:30: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ad 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1123:42: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ad 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1164:10: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ad 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1164:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 ad 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
Child : i=1 buf=7
Parent: i=2 buf=3
Child : i=2 buf=14
Parent: i=3 buf=6
Child : i=3 buf=21
Parent: i=4 buf=9
Child : i=4 buf=28
Parent: i=5 buf=12
src/umka_vm.c:1387:14: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 aa 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1387:18: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 aa 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 68 4d 6a 35
              ^ 
src/umka_vm.c:1502:22: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e8 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 c0 4d 6a 35
              ^ 
src/umka_vm.c:1503:36: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e8 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 c0 4d 6a 35
              ^ 
Parent: i=6 buf=35
Parent: i=7 buf=42
Parent: i=8 buf=49
Parent: i=9 buf=56
src/umka_vm.c:168:22: runtime error: member access within misaligned address 0x7fc4356a65e1 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a65e1: note: pointer points here
 cc cc ec  3f 21 43 65 87 78 56 34  12 01 00 00 00 b8 00 00  00 00 71 4a 45 eb 55 00  00 e8 01 00 00
              ^ 
src/umka_vm.c:506:26: runtime error: member access within misaligned address 0x7fc4356a65e1 for type 'struct HeapChunkHeader', which requires 8 byte alignment
0x7fc4356a65e1: note: pointer points here
 cc cc ec  3f 21 43 65 87 78 56 34  12 01 00 00 00 b8 00 00  00 00 71 4a 45 eb 55 00  00 e8 01 00 00
              ^ 
src/umka_vm.c:507:40: runtime error: member access within misaligned address 0x7fc4356a65f1 for type 'struct Fiber', which requires 8 byte alignment
0x7fc4356a65f1: note: pointer points here
 b8 00 00  00 00 71 4a 45 eb 55 00  00 e8 01 00 00 00 00 00  00 10 50 ea 34 c4 7f 00  00 c0 4d 6a 35
              ^ 

repr():
3 
2.380000 
0.138015 
"Hello World" 
0 
"Hello World!" 
{2.300000 -2.050000 2.380000 } 
{{0 0 0 0 0 } {0 0 0 0 0 } {0 0 0 0 0 } {10 20 30 40 50 } } 
{q: {1.000000 0.000000 0.000000 0.000000 } normalized: true } 
4.680000 
a 
fn 
src/umka_vm.c:597:19: runtime error: load of misaligned address 0x7fc435fa6f0f for type 'void *', which requires 8 byte alignment
0x7fc435fa6f0f: note: pointer points here
 cc cc ec 3f c9  65 6a 35 c4 7f 00 00 f0  3b 4a 45 eb 55 00 00 86  01 00 00 00 00 00 00 b9  64 6a 35
             ^ 
src/umka_vm.c:598:19: runtime error: load of misaligned address 0x7fc435fa6f17 for type 'struct Type *', which requires 8 byte alignment
0x7fc435fa6f17: note: pointer points here
 c4 7f 00 00 f0  3b 4a 45 eb 55 00 00 86  01 00 00 00 00 00 00 b9  64 6a 35 c4 7f 00 00 91  63 6a 35
             ^ 
{0.500000 0.700000 0.900000 } 
0x55eb45479530

About REPL...

You know the logic of parsing and interpreting Umka better than I do. The question is, how expensive is it to implement a command-line REPL like Lua or Python?

Methods requiring import

I have a audio.sound, called hitsnd and it is defined in global.um. When I try using a method play() on it in another file, than global.um, I still need to import tophat/audio.um.

memory leak -

ломатьнестроить

$ cat mike.um
import "import/std.um"    
                                                                                
fn main() {
    h := make([]int, -1)
}
$ umka mike.um
Memory leak at 0x7fd62cdd4010 (1 refs)

Implement 64-bit uint

Hello!

According to the documentation (and umka_types.c), Umka has the following built-in types:

void
int8 int16 int32 int
uint8 uint16 uint32
bool
char
real32 real
fiber

In order to give users more choice/flexibility and achieve better compatibility with C and C++ code (when using Umka as an embedded/extension language) I would like to suggest taking inspiration from other languages and consider the following:

Adding int64 and uint64
Renaming real* to float*
Adding float64
Adding ssize (or isize) and usize (equivalent of C's ssize_t and size_t, or Rust's isize and usize)
Adding c_(u)short, c_(u)int etc. (perhaps with better names 😉) and mapping them to C's (unsigned) short, (unsigned) int, etc. (like Zig)

Thank you for starting this interesting project as well as considering the above suggestions 😊

No MSVC++ build script

Is it expected this will build on MacOS and on Windows with MSVC++ with a suitable build script? I'm willing to help on this. I would like to embed umka in Felix as a standard component and have some specific tasks in mind for it, but it has to build with my build tools on all the platforms Felix supports: Linux (gcc and clang), MacOS (clang) and Windows (MSVC++), and, down the track, Apple iOS and Android.

Are there any weird features needed to implement anything?

Weird error numbers

I'm not sure, if this is umka's fault or mine, but my errors look something like this: Umka error gamescn.um (1528899539, 32636): .

ifdef, or platform specific code

I need to define some constants differently, when running on windows, than on linux. Is there a way to do this?

Umka fails on SPARC due to misaligned pointers

Solaris 11, clang, SPARC.

кое что работает:

$ ../umka gc.um 
See any memory leak warnings?
$

но все остальное прочно сломано

$ ../umka tour.um 
Bus Error (core dumped)

надо чинить все предыдущие и другая платформа сама заработает.

std.clock() return values are weird.

The values given don't seem to make any sense.

Error making no sense

I'm sorry for asking here, but since umka isn't that popular, I don't have any other option. I'm having an issue with an error, that doesn't make any sense at all. Here is the code:

type poly = int

// this line causes the issue:
fn newpoly*(x, y, vcount: int, v: []int): poly

fn (p: ^poly) setpos*(x, y: int) {
	cpolysetpos(x, y, p)
}

fn cpolysetpos(x, y: int, p: poly)

//fn (p ^poly) getpos*(): (int, int)

The error is: Umka error umka/poly.um (6, 1): . expected but ; found

What am I missing?

MinGW compilation

I don't know, if this is really an umka problem, but I'm trying to corss compile something for windows using mingw. The compilation itself is ok, but then it can't load libumka.dll, even though I statically link libumka.a. How should I do compile it?

Here is, how I compile it: x86_64-w64-mingw32-gcc src/*.c lib/windows/*.a -o tophat.exe -Wall -lm -Llib/windows -lumka -Ldl -Ilib/rawdraw -lopengl32 -lgdi32 -luser32

map.um error

Just including the map module brings this error:
Umka error umka/std/map.um (7, 2): Declaration expected but < found

umkaGetFunction() returns wrong value on PPC platform

So when compiling for the Wii, umkaGetFunction always returns the value '0'
when compiling the same code on macOS everything works fine

I isolated the problem I think to the function getIdent called from umkaGetFunction

Source Files

a.um

import "b.um"

fn main() {
  printf("hello from a!\n")
}

b.um

fn a*() {printf("b:a!\n")}
fn b*() {printf("b:b!\n")}

main.c

#include <stdlib.h>
#include <stdio.h>
#include <umka_api.h>
#include <string.h>

#ifdef __wii__
#include <gccore.h>
#include <wiiuse/wpad.h>
#endif

#ifdef __wii__
static void *xfb = NULL;
static GXRModeObj *rmode = NULL;
#endif

enum { ASM_BUF_SIZE = 2 * 1024 * 1024 };

//---------------------------------------------------------------------------------
int main(int argc, char **argv) {
  //---------------------------------------------------------------------------------
  char *fileA;
  char *fileB;

#ifdef __wii__
  fileA = "sd:/a.um";
  fileB = "sd:/b.um";

  VIDEO_Init();
  WPAD_Init();

  rmode = VIDEO_GetPreferredMode(NULL);
  xfb = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));

  console_init(xfb, 20, 20, rmode->fbWidth, rmode->xfbHeight,
               rmode->fbWidth * VI_DISPLAY_PIX_SZ);

  VIDEO_Configure(rmode);
  VIDEO_SetNextFramebuffer(xfb);
  VIDEO_SetBlack(FALSE);
  VIDEO_Flush();
  VIDEO_WaitVSync();

  if (rmode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync();

  if (!fatInitDefault()) {
    printf("Unable to initialise FAT subsystem, exiting.\n");
    exit(0);
  }
#else
  fileA = "a.um";
  fileB = "b.um";

#endif

  void *umka = umkaAlloc();
  umkaInit(umka, fileA, 1024 * 1024, 1024 * 1024, 0, NULL);
  umkaCompile(umka);

  /* write file */
  char *asmBuf = malloc(ASM_BUF_SIZE);
  umkaAsm(umka, asmBuf);

  FILE *asmFile = fopen("test.asm", "w");
  if (!asmFile) {
    printf("Cannot open file test.asm\n");
    return 1;
  }
  if (fwrite(asmBuf, strlen(asmBuf), 1, asmFile) != 1) {
    printf("Cannot write file test.asm\n");
    return 1;
  }

  fclose(asmFile);
  free(asmBuf);

  /* call functions */
  int func_a = umkaGetFunc(umka, fileB, "a");
  int func_b = umkaGetFunc(umka, fileB, "b");
  int func_main = umkaGetFunc(umka, fileA, "main");

  printf("function values: %i %i %i\n", func_a, func_b, func_main);

  umkaCall(umka, func_a, 0, NULL, NULL);
  umkaCall(umka, func_b, 0, NULL, NULL);
  umkaCall(umka, func_main, 0, NULL, NULL);

  umkaFree(umka);

#ifdef __wii__
  while (1) {
    // Call WPAD_ScanPads each loop, this reads the latest controller states
    WPAD_ScanPads();

    // WPAD_ButtonsDown tells us which buttons were pressed in this loop
    // this is a "one shot" state which will not fire again until the button has
    // been released
    u32 pressed = WPAD_ButtonsDown(0);

    // We return to the launcher application via exit
    if (pressed & WPAD_BUTTON_HOME) exit(0);

    // Wait for the next frame
    VIDEO_WaitVSync();
  }
#endif

  return 0;
}

Output

assembly produced on macOS



Module: a.um
000000000      4                         GOTO 25



Module: b.um


000000001      1                  ENTER_FRAME 0
000000002      1                         PUSH int 0
000000003      1                      POP_REG 15
000000004      1                         PUSH ^ 0x7ff8e8d0000f
000000005      1                      POP_REG 14
000000006      1                         PUSH int 0
000000007      1                 CALL_BUILTIN void printf
000000008      1                          POP
000000009      1                     PUSH_REG 15
000000010      1                          POP
000000011      1                  LEAVE_FRAME
000000012      1                       RETURN 0


000000013      2                  ENTER_FRAME 0
000000014      2                         PUSH int 0
000000015      2                      POP_REG 15
000000016      2                         PUSH ^ 0x7ff8e8d00015
000000017      2                      POP_REG 14
000000018      2                         PUSH int 0
000000019      2                 CALL_BUILTIN void printf
000000020      2                          POP
000000021      2                     PUSH_REG 15
000000022      2                          POP
000000023      2                  LEAVE_FRAME
000000024      2                       RETURN 0


Module: a.um


000000025      5                  ENTER_FRAME 0
000000026      4                         PUSH int 0
000000027      4                      POP_REG 15
000000028      4                         PUSH ^ 0x7ff8e8d0001b
000000029      4                      POP_REG 14
000000030      4                         PUSH int 0
000000031      4                 CALL_BUILTIN void printf
000000032      4                          POP
000000033      4                     PUSH_REG 15
000000034      5                          POP
000000035      5                  LEAVE_FRAME
000000036      5                         PUSH ^ 0x7ff8e8f0b700; DEREF
000000037      5               CHANGE_REF_CNT -- ^void; POP
000000038      5                         HALT

assembly produced on wii



Module: sd:/a.um
000000000      4                         GOTO 25



Module: sd:/b.um


000000001      1                  ENTER_FRAME 0
000000002      1                         PUSH int 0
000000003      1                      POP_REG 15
000000004      1                         PUSH ^ 0x802e01e7
000000005      1                      POP_REG 14
000000006      1                         PUSH int 0
000000007      1                 CALL_BUILTIN void printf
000000008      1                          POP
000000009      1                     PUSH_REG 15
000000010      1                          POP
000000011      1                  LEAVE_FRAME
000000012      1                       RETURN 0


000000013      2                  ENTER_FRAME 0
000000014      2                         PUSH int 0
000000015      2                      POP_REG 15
000000016      2                         PUSH ^ 0x802e01ed
000000017      2                      POP_REG 14
000000018      2                         PUSH int 0
000000019      2                 CALL_BUILTIN void printf
000000020      2                          POP
000000021      2                     PUSH_REG 15
000000022      2                          POP
000000023      2                  LEAVE_FRAME
000000024      2                       RETURN 0


Module: sd:/a.um


000000025      5                  ENTER_FRAME 0
000000026      4                         PUSH int 0
000000027      4                      POP_REG 15
000000028      4                         PUSH ^ 0x802e01f3
000000029      4                      POP_REG 14
000000030      4                         PUSH int 0
000000031      4                 CALL_BUILTIN void printf
000000032      4                          POP
000000033      4                     PUSH_REG 15
000000034      5                          POP
000000035      5                  LEAVE_FRAME
000000036      5                         PUSH ^ 0x802c70e8; DEREF
000000037      5               CHANGE_REF_CNT -- ^void; POP
000000038      5                         HALT

Console output on macOS

function values: 1 13 25
b:a!
b:b!
hello from a!

Console output on Wii

function values: 0 0 0
hello from a!
hello from a!
hello from a1

What do you think could be causing this?

Loading imported modules from string

This could be useful for embedding scripts into binaries.

Improve memory safety

Consider the potentially unsafe features that may result in VM crash, if used inappropriately:

~~Pointer type casts~~
~~Weak pointers~~
~~Functions returning pointers to local variables~~
~~Reading pointers from files~~

Compiler warnings in 32-bit mode: cast pointer to/from int64_t

под 32бита куча ошибок хоть и проходит тесты, конечно, на 64бит все ок

$ make
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka.o src/umka.c
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_api.o src/umka_api.c
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_common.o src/umka_common.c
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_compiler.o src/umka_compiler.c
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_const.o src/umka_const.c
src/umka_const.c: In function 'constAssign':
src/umka_const.c:41:52: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   41 |         case TYPE_STR:          *(void *   *)lhs = (void *)rhs->ptrVal; break;
      |                                                    ^
src/umka_const.c:44:45: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   44 |         case TYPE_INTERFACE:    memcpy(lhs, (void *)rhs->ptrVal, size); break;
      |                                             ^
src/umka_const.c: In function 'constBinary':
src/umka_const.c:76:40: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   76 |             case TOK_PLUS:      strcat((char *)lhs->ptrVal, (char *)rhs->ptrVal); break;
      |                                        ^
src/umka_const.c:76:61: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   76 |             case TOK_PLUS:      strcat((char *)lhs->ptrVal, (char *)rhs->ptrVal); break;
      |                                                             ^
src/umka_const.c:78:54: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   78 |             case TOK_EQEQ:      lhs->intVal = strcmp((char *)lhs->ptrVal, (char *)rhs->ptrVal) == 0; break;
      |                                                      ^
src/umka_const.c:78:75: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   78 |             case TOK_EQEQ:      lhs->intVal = strcmp((char *)lhs->ptrVal, (char *)rhs->ptrVal) == 0; break;
      |                                                                           ^
src/umka_const.c:79:54: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   79 |             case TOK_NOTEQ:     lhs->intVal = strcmp((char *)lhs->ptrVal, (char *)rhs->ptrVal) != 0; break;
      |                                                      ^
src/umka_const.c:79:75: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   79 |             case TOK_NOTEQ:     lhs->intVal = strcmp((char *)lhs->ptrVal, (char *)rhs->ptrVal) != 0; break;
      |                                                                           ^
src/umka_const.c:80:54: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   80 |             case TOK_GREATER:   lhs->intVal = strcmp((char *)lhs->ptrVal, (char *)rhs->ptrVal) >  0; break;
      |                                                      ^
src/umka_const.c:80:75: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   80 |             case TOK_GREATER:   lhs->intVal = strcmp((char *)lhs->ptrVal, (char *)rhs->ptrVal) >  0; break;
      |                                                                           ^
src/umka_const.c:81:54: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   81 |             case TOK_LESS:      lhs->intVal = strcmp((char *)lhs->ptrVal, (char *)rhs->ptrVal) <  0; break;
      |                                                      ^
src/umka_const.c:81:75: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   81 |             case TOK_LESS:      lhs->intVal = strcmp((char *)lhs->ptrVal, (char *)rhs->ptrVal) <  0; break;
      |                                                                           ^
src/umka_const.c:82:54: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   82 |             case TOK_GREATEREQ: lhs->intVal = strcmp((char *)lhs->ptrVal, (char *)rhs->ptrVal) >= 0; break;
      |                                                      ^
src/umka_const.c:82:75: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   82 |             case TOK_GREATEREQ: lhs->intVal = strcmp((char *)lhs->ptrVal, (char *)rhs->ptrVal) >= 0; break;
      |                                                                           ^
src/umka_const.c:83:54: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   83 |             case TOK_LESSEQ:    lhs->intVal = strcmp((char *)lhs->ptrVal, (char *)rhs->ptrVal) <= 0; break;
      |                                                      ^
src/umka_const.c:83:75: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   83 |             case TOK_LESSEQ:    lhs->intVal = strcmp((char *)lhs->ptrVal, (char *)rhs->ptrVal) <= 0; break;
      |                                                                           ^
src/umka_const.c: In function 'constCallBuiltin':
src/umka_const.c:183:55: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  183 |         case BUILTIN_LEN:       arg->intVal  = strlen((char *)arg->ptrVal); break;
      |                                                       ^
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_decl.o src/umka_decl.c
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_expr.o src/umka_expr.c
src/umka_expr.c: In function 'doCharToStrConv':
src/umka_expr.c:62:28: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
   62 |         constant->ptrVal = (int64_t)buf;
      |                            ^
src/umka_expr.c: In function 'doApplyStrCat':
src/umka_expr.c:305:29: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  305 |         int bufLen = strlen((char *)constant->ptrVal) + strlen((char *)rightConstant->ptrVal) + 1;
      |                             ^
src/umka_expr.c:305:64: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  305 |         int bufLen = strlen((char *)constant->ptrVal) + strlen((char *)rightConstant->ptrVal) + 1;
      |                                                                ^
src/umka_expr.c:309:21: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  309 |         strcpy(buf, (char *)constant->ptrVal);
      |                     ^
src/umka_expr.c:310:28: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  310 |         constant->ptrVal = (int64_t)buf;
      |                            ^
src/umka_expr.c: In function 'parseArrayOrStructLiteral':
src/umka_expr.c:941:28: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  941 |         constant->ptrVal = (int64_t)&comp->storage.data[comp->storage.len];
      |                            ^
src/umka_expr.c:987:44: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  987 |                 constAssign(&comp->consts, (void *)(constant->ptrVal + itemOffset), itemConstant, expectedItemType->kind, itemSize);
      |                                            ^
src/umka_expr.c: In function 'parseFactor':
src/umka_expr.c:1356:36: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
 1356 |                 constant->ptrVal = (int64_t)comp->lex.tok.strVal;
      |                                    ^
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_gen.o src/umka_gen.c
src/umka_gen.c: In function 'genPushGlobalPtr':
src/umka_gen.c:184:112: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  184 |     const Instruction instr = {.opcode = OP_PUSH, .tokKind = TOK_NONE, .typeKind = TYPE_PTR, .operand.ptrVal = (int64_t)ptrVal};
      |                                                                                                                ^
src/umka_gen.c: In function 'genChangeRefCnt':
src/umka_gen.c:272:126: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  272 |         const Instruction instr = {.opcode = OP_CHANGE_REF_CNT, .tokKind = tokKind, .typeKind = TYPE_NONE, .operand.ptrVal = (int64_t)type};
      |                                                                                                                              ^
src/umka_gen.c: In function 'genChangeRefCntAssign':
src/umka_gen.c:282:134: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  282 |         const Instruction instr = {.opcode = OP_CHANGE_REF_CNT_ASSIGN, .tokKind = TOK_NONE, .typeKind = TYPE_NONE, .operand.ptrVal = (int64_t)type};
      |                                                                                                                                      ^
src/umka_gen.c: In function 'genSwapChangeRefCntAssign':
src/umka_gen.c:294:159: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  294 |         const Instruction instr = {.opcode = OP_CHANGE_REF_CNT_ASSIGN, .inlineOpcode = OP_SWAP, .tokKind = TOK_NONE, .typeKind = TYPE_NONE, .operand.ptrVal = (int64_t)type};
      |                                                                                                                                                               ^
src/umka_gen.c: In function 'genAssertType':
src/umka_gen.c:345:120: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  345 |     const Instruction instr = {.opcode = OP_ASSERT_TYPE, .tokKind = TOK_NONE, .typeKind = TYPE_NONE, .operand.ptrVal = (int64_t)type};
      |                                                                                                                        ^
src/umka_gen.c: In function 'genCallExtern':
src/umka_gen.c:373:120: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  373 |     const Instruction instr = {.opcode = OP_CALL_EXTERN, .tokKind = TOK_NONE, .typeKind = TYPE_NONE, .operand.ptrVal = (int64_t)entry};
      |                                                                                                                        ^
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_ident.o src/umka_ident.c
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_lexer.o src/umka_lexer.c
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_runtime.o src/umka_runtime.c
src/umka_runtime.c: In function 'rtlfopen':
src/umka_runtime.c:10:18: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   10 |     char *name = (char *)params[1].ptrVal;
      |                  ^
src/umka_runtime.c:11:18: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   11 |     char *mode = (char *)params[0].ptrVal;
      |                  ^
src/umka_runtime.c:14:22: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
   14 |     result->ptrVal = (int64_t)file;
      |                      ^
src/umka_runtime.c: In function 'rtlfclose':
src/umka_runtime.c:20:18: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   20 |     FILE *file = (FILE *)params[0].ptrVal;
      |                  ^
src/umka_runtime.c: In function 'rtlfread':
src/umka_runtime.c:27:18: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   27 |     void *buf  = (void *)params[3].ptrVal;
      |                  ^
src/umka_runtime.c:30:18: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   30 |     FILE *file = (FILE *)params[0].ptrVal;
      |                  ^
src/umka_runtime.c: In function 'rtlfwrite':
src/umka_runtime.c:38:18: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   38 |     void *buf  = (void *)params[3].ptrVal;
      |                  ^
src/umka_runtime.c:41:18: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   41 |     FILE *file = (FILE *)params[0].ptrVal;
      |                  ^
src/umka_runtime.c: In function 'rtlfseek':
src/umka_runtime.c:49:20: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   49 |     FILE *file   = (FILE *)params[2].ptrVal;
      |                    ^
src/umka_runtime.c: In function 'rtlremove':
src/umka_runtime.c:64:18: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   64 |     char *name = (char *)params[0].ptrVal;
      |                  ^
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_stmt.o src/umka_stmt.c
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_types.o src/umka_types.c
c99 -fPIC -O3 -Wall -Wno-format-security   -c -o src/umka_vm.o src/umka_vm.c
src/umka_vm.c: In function 'doBasicDeref':
src/umka_vm.c:320:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  320 |         case TYPE_INT8:         slot->intVal  = *(int8_t   *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c:321:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  321 |         case TYPE_INT16:        slot->intVal  = *(int16_t  *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c:322:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  322 |         case TYPE_INT32:        slot->intVal  = *(int32_t  *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c:323:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  323 |         case TYPE_INT:          slot->intVal  = *(int64_t  *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c:324:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  324 |         case TYPE_UINT8:        slot->intVal  = *(uint8_t  *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c:325:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  325 |         case TYPE_UINT16:       slot->intVal  = *(uint16_t *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c:326:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  326 |         case TYPE_UINT32:       slot->intVal  = *(uint32_t *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c:327:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  327 |         case TYPE_UINT:         slot->uintVal = *(uint64_t *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c:328:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  328 |         case TYPE_BOOL:         slot->intVal  = *(bool     *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c:329:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  329 |         case TYPE_CHAR:         slot->intVal  = *(char     *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c:330:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  330 |         case TYPE_REAL32:       slot->realVal = *(float    *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c:331:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  331 |         case TYPE_REAL:         slot->realVal = *(double   *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c:333:60: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  333 |         case TYPE_STR:          slot->ptrVal  = (int64_t)(*(void *   *)slot->ptrVal); break;
      |                                                            ^
src/umka_vm.c:333:49: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  333 |         case TYPE_STR:          slot->ptrVal  = (int64_t)(*(void *   *)slot->ptrVal); break;
      |                                                 ^
src/umka_vm.c:339:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  339 |         case TYPE_FN:           slot->intVal  = *(int64_t  *)slot->ptrVal; break;
      |                                                  ^
src/umka_vm.c: In function 'doBasicAssign':
src/umka_vm.c:366:52: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  366 |         case TYPE_STR:          *(void *   *)lhs = (void *)rhs.ptrVal; break;
      |                                                    ^
src/umka_vm.c:371:45: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  371 |         case TYPE_FIBER:        memcpy(lhs, (void *)rhs.ptrVal, structSize); break;
      |                                             ^
src/umka_vm.c: In function 'doFillReprBuf':
src/umka_vm.c:535:64: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  535 |         case TYPE_PTR:      len = snprintf(buf, maxLen, "%p ", (void *)slot->ptrVal);                       break;
      |                                                                ^
src/umka_vm.c:536:68: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  536 |         case TYPE_STR:      len = snprintf(buf, maxLen, "\"%s\" ", (char *)slot->ptrVal);                   break;
      |                                                                    ^
src/umka_vm.c:542:29: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  542 |             void *itemPtr = (void *)slot->ptrVal;
      |                             ^
src/umka_vm.c:547:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  547 |                 Slot itemSlot = {.ptrVal = (int64_t)itemPtr};
      |                                            ^
src/umka_vm.c:561:31: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  561 |             DynArray *array = (DynArray *)slot->ptrVal;
      |                               ^
src/umka_vm.c:567:48: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  567 |                     Slot itemSlot = {.ptrVal = (int64_t)itemPtr};
      |                                                ^
src/umka_vm.c:597:29: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  597 |             void *__self = *(void **)slot->ptrVal;
      |                             ^
src/umka_vm.c:598:33: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  598 |             Type *__selftype = *(Type **)(slot->ptrVal + type->field[1]->offset);
      |                                 ^
src/umka_vm.c:602:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  602 |                 Slot selfSlot = {.ptrVal = (int64_t)__self};
      |                                            ^
src/umka_vm.c: In function 'doBuiltinPrintf':
src/umka_vm.c:731:44: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  731 |     void *stream      = console ? stdout : (void *)fiber->reg[VM_REG_IO_STREAM].ptrVal;
      |                                            ^
src/umka_vm.c:732:25: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  732 |     char *format      = (char *)fiber->reg[VM_REG_IO_FORMAT].ptrVal;
      |                         ^
src/umka_vm.c: In function 'doBuiltinScanf':
src/umka_vm.c:773:43: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  773 |     void *stream      = console ? stdin : (void *)fiber->reg[VM_REG_IO_STREAM].ptrVal;
      |                                           ^
src/umka_vm.c:774:25: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  774 |     char *format      = (char *)fiber->reg[VM_REG_IO_FORMAT].ptrVal;
      |                         ^
src/umka_vm.c:804:50: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  804 |         cnt = fsscanf(string, stream, curFormat, (void *)fiber->top->ptrVal, &len);
      |                                                  ^
src/umka_vm.c: In function 'doBuiltinMake':
src/umka_vm.c:819:24: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  819 |     DynArray *result = (DynArray *)(fiber->top++)->ptrVal;
      |                        ^
src/umka_vm.c:824:30: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  824 |     (--fiber->top)->ptrVal = (int64_t)result;
      |                              ^
src/umka_vm.c: In function 'doBuiltinMakefrom':
src/umka_vm.c:833:22: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  833 |     DynArray *dest = (DynArray *)(fiber->top++)->ptrVal;
      |                      ^
src/umka_vm.c:834:22: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  834 |     void *src      = (void     *)(fiber->top++)->ptrVal;
      |                      ^
src/umka_vm.c:837:30: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  837 |     (--fiber->top)->ptrVal = (int64_t)dest;
      |                              ^
src/umka_vm.c: In function 'doBuiltinAppend':
src/umka_vm.c:844:24: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  844 |     DynArray *result = (DynArray *)(fiber->top++)->ptrVal;
      |                        ^
src/umka_vm.c:845:24: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  845 |     void *item       = (void     *)(fiber->top++)->ptrVal;
      |                        ^
src/umka_vm.c:846:24: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  846 |     DynArray *array  = (DynArray *)(fiber->top++)->ptrVal;
      |                        ^
src/umka_vm.c:858:30: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  858 |     (--fiber->top)->ptrVal = (int64_t)result;
      |                              ^
src/umka_vm.c: In function 'doBuiltinDelete':
src/umka_vm.c:865:24: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  865 |     DynArray *result = (DynArray *)(fiber->top++)->ptrVal;
      |                        ^
src/umka_vm.c:867:24: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  867 |     DynArray *array  = (DynArray *)(fiber->top++)->ptrVal;
      |                        ^
src/umka_vm.c:879:30: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  879 |     (--fiber->top)->ptrVal = (int64_t)result;
      |                              ^
src/umka_vm.c: In function 'doBuiltinLen':
src/umka_vm.c:891:51: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  891 |         case TYPE_DYNARRAY: fiber->top->intVal = ((DynArray *)(fiber->top->ptrVal))->len; break;
      |                                                   ^
src/umka_vm.c:892:57: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  892 |         case TYPE_STR:      fiber->top->intVal = strlen((char *)fiber->top->ptrVal); break;
      |                                                         ^
src/umka_vm.c: In function 'doBuiltinSizeofself':
src/umka_vm.c:903:25: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  903 |     Type *__selftype = *(Type **)(fiber->top->ptrVal + sizeof(void *));
      |                         ^
src/umka_vm.c: In function 'doBuiltinFiberspawn':
src/umka_vm.c:915:22: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  915 |     void *anyParam = (void *)(fiber->top++)->ptrVal;
      |                      ^
src/umka_vm.c:929:30: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  929 |     (--child->top)->ptrVal = (int64_t)fiber;                  // Push parent fiber pointer
      |                              ^
src/umka_vm.c:930:30: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  930 |     (--child->top)->ptrVal = (int64_t)anyParam;               // Push arbitrary pointer parameter
      |                              ^
src/umka_vm.c:935:30: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  935 |     (--fiber->top)->ptrVal = (int64_t)child;
      |                              ^
src/umka_vm.c: In function 'doBuiltinFibercall':
src/umka_vm.c:942:17: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  942 |     *newFiber = (Fiber *)(fiber->top++)->ptrVal;
      |                 ^
src/umka_vm.c: In function 'doBuiltinFiberalive':
src/umka_vm.c:951:20: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  951 |     Fiber *child = (Fiber *)fiber->top->ptrVal;
      |                    ^
src/umka_vm.c: In function 'doBuiltinRepr':
src/umka_vm.c:962:18: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
  962 |     Type *type = (Type *)(fiber->top++)->ptrVal;
      |                  ^
src/umka_vm.c:969:26: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  969 |     fiber->top->ptrVal = (int64_t)buf;
      |                          ^
src/umka_vm.c: In function 'doPushLocalPtr':
src/umka_vm.c:987:30: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
  987 |     (--fiber->top)->ptrVal = (int64_t)((int8_t *)fiber->base + fiber->code[fiber->ip].operand.intVal);
      |                              ^
src/umka_vm.c: In function 'doPushStruct':
src/umka_vm.c:1005:17: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1005 |     void *src = (void *)(fiber->top++)->ptrVal;
      |                 ^
src/umka_vm.c: In function 'doAssign':
src/umka_vm.c:1061:17: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1061 |     void *lhs = (void *)(fiber->top++)->ptrVal;;
      |                 ^
src/umka_vm.c: In function 'doChangeRefCnt':
src/umka_vm.c:1070:25: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1070 |     void *ptr         = (void *)fiber->top->ptrVal;
      |                         ^
src/umka_vm.c:1072:25: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1072 |     Type *type        = (Type *)fiber->code[fiber->ip].operand.ptrVal;
      |                         ^
src/umka_vm.c: In function 'doChangeRefCntAssign':
src/umka_vm.c:1089:18: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1089 |     void *lhs  = (void *)(fiber->top++)->ptrVal;
      |                  ^
src/umka_vm.c:1090:18: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1090 |     Type *type = (Type *)fiber->code[fiber->ip].operand.ptrVal;
      |                  ^
src/umka_vm.c:1093:39: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1093 |     doBasicChangeRefCnt(fiber, pages, (void *)rhs.ptrVal, type, TOK_PLUSPLUS, error);
      |                                       ^
src/umka_vm.c:1096:32: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
 1096 |     Slot lhsDeref = {.ptrVal = (int64_t)lhs};
      |                                ^
src/umka_vm.c:1098:39: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1098 |     doBasicChangeRefCnt(fiber, pages, (void *)lhsDeref.ptrVal, type, TOK_MINUSMINUS, error);
      |                                       ^
src/umka_vm.c: In function 'doUnary':
src/umka_vm.c:1122:29: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1122 |                 void *ptr = (void *)(fiber->top++)->ptrVal;
      |                             ^
src/umka_vm.c:1143:29: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1143 |                 void *ptr = (void *)(fiber->top++)->ptrVal;
      |                             ^
src/umka_vm.c: In function 'doBinary':
src/umka_vm.c:1181:54: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1181 |                 char *buf = chunkAlloc(pages, strlen((char *)fiber->top->ptrVal) + strlen((char *)rhs.ptrVal) + 1, error);
      |                                                      ^
src/umka_vm.c:1181:91: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1181 |                 char *buf = chunkAlloc(pages, strlen((char *)fiber->top->ptrVal) + strlen((char *)rhs.ptrVal) + 1, error);
      |                                                                                           ^
src/umka_vm.c:1182:29: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1182 |                 strcpy(buf, (char *)fiber->top->ptrVal);
      |                             ^
src/umka_vm.c:1183:29: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1183 |                 strcat(buf, (char *)rhs.ptrVal);
      |                             ^
src/umka_vm.c:1184:38: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
 1184 |                 fiber->top->ptrVal = (int64_t)buf;
      |                                      ^
src/umka_vm.c:1188:61: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1188 |             case TOK_EQEQ:      fiber->top->intVal = strcmp((char *)fiber->top->ptrVal, (char *)rhs.ptrVal) == 0; break;
      |                                                             ^
src/umka_vm.c:1188:89: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1188 |             case TOK_EQEQ:      fiber->top->intVal = strcmp((char *)fiber->top->ptrVal, (char *)rhs.ptrVal) == 0; break;
      |                                                                                         ^
src/umka_vm.c:1189:61: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1189 |             case TOK_NOTEQ:     fiber->top->intVal = strcmp((char *)fiber->top->ptrVal, (char *)rhs.ptrVal) != 0; break;
      |                                                             ^
src/umka_vm.c:1189:89: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1189 |             case TOK_NOTEQ:     fiber->top->intVal = strcmp((char *)fiber->top->ptrVal, (char *)rhs.ptrVal) != 0; break;
      |                                                                                         ^
src/umka_vm.c:1190:61: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1190 |             case TOK_GREATER:   fiber->top->intVal = strcmp((char *)fiber->top->ptrVal, (char *)rhs.ptrVal)  > 0; break;
      |                                                             ^
src/umka_vm.c:1190:89: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1190 |             case TOK_GREATER:   fiber->top->intVal = strcmp((char *)fiber->top->ptrVal, (char *)rhs.ptrVal)  > 0; break;
      |                                                                                         ^
src/umka_vm.c:1191:61: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1191 |             case TOK_LESS:      fiber->top->intVal = strcmp((char *)fiber->top->ptrVal, (char *)rhs.ptrVal)  < 0; break;
      |                                                             ^
src/umka_vm.c:1191:89: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1191 |             case TOK_LESS:      fiber->top->intVal = strcmp((char *)fiber->top->ptrVal, (char *)rhs.ptrVal)  < 0; break;
      |                                                                                         ^
src/umka_vm.c:1192:61: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1192 |             case TOK_GREATEREQ: fiber->top->intVal = strcmp((char *)fiber->top->ptrVal, (char *)rhs.ptrVal) >= 0; break;
      |                                                             ^
src/umka_vm.c:1192:89: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1192 |             case TOK_GREATEREQ: fiber->top->intVal = strcmp((char *)fiber->top->ptrVal, (char *)rhs.ptrVal) >= 0; break;
      |                                                                                         ^
src/umka_vm.c:1193:61: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1193 |             case TOK_LESSEQ:    fiber->top->intVal = strcmp((char *)fiber->top->ptrVal, (char *)rhs.ptrVal) <= 0; break;
      |                                                             ^
src/umka_vm.c:1193:89: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1193 |             case TOK_LESSEQ:    fiber->top->intVal = strcmp((char *)fiber->top->ptrVal, (char *)rhs.ptrVal) <= 0; break;
      |                                                                                         ^
src/umka_vm.c: In function 'doGetArrayPtr':
src/umka_vm.c:1309:22: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1309 |         len = strlen((char *)fiber->top->ptrVal);
      |                      ^
src/umka_vm.c: In function 'doGetDynArrayPtr':
src/umka_vm.c:1326:23: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1326 |     DynArray *array = (DynArray *)(fiber->top++)->ptrVal;
      |                       ^
src/umka_vm.c:1337:30: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
 1337 |     (--fiber->top)->ptrVal = (int64_t)(array->data + itemSize * index);
      |                              ^
src/umka_vm.c: In function 'doAssertType':
src/umka_vm.c:1364:24: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1364 |     void *interface  = (void *)(fiber->top++)->ptrVal;
      |                        ^
src/umka_vm.c:1365:24: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1365 |     Type *type       = (Type *)fiber->code[fiber->ip].operand.ptrVal;
      |                        ^
src/umka_vm.c:1371:30: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
 1371 |     (--fiber->top)->ptrVal = (int64_t)((__selftype && typeEquivalent(type, __selftype)) ? __self : NULL);
      |                              ^
src/umka_vm.c: In function 'doCallExtern':
src/umka_vm.c:1408:21: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1408 |     ExternFunc fn = (ExternFunc)fiber->code[fiber->ip].operand.ptrVal;
      |                     ^
src/umka_vm.c: In function 'doCallBuiltin':
src/umka_vm.c:1472:58: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
 1472 |         case BUILTIN_NEW:           fiber->top->ptrVal = (int64_t)chunkAlloc(pages, fiber->top->intVal, error); break;
      |                                                          ^
src/umka_vm.c:1488:75: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1488 |         case BUILTIN_ERROR:         error->handlerRuntime(error->context, (char *)fiber->top->ptrVal); return;
      |                                                                           ^
src/umka_vm.c: In function 'doReturn':
src/umka_vm.c:1503:21: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1503 |         *newFiber = (Fiber *)(fiber->top + 1)->ptrVal;
      |                     ^
src/umka_vm.c: In function 'doEnterFrame':
src/umka_vm.c:1523:30: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
 1523 |     (--fiber->top)->ptrVal = (int64_t)fiber->base;
      |                              ^
src/umka_vm.c: In function 'doLeaveFrame':
src/umka_vm.c:1551:19: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1551 |     fiber->base = (Slot *)(fiber->top++)->ptrVal;
      |                   ^
src/umka_vm.c: In function 'vmAsm':
src/umka_vm.c:1674:54: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1674 |                 chars += sprintf(buf + chars, " %p", (void *)instr->operand.ptrVal);
      |                                                      ^
src/umka_vm.c:1692:80: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1692 |         case OP_CALL_EXTERN:            chars += sprintf(buf + chars, " %p",   (void *)instr->operand.ptrVal); break;
      |                                                                                ^
src/umka_vm.c:1699:63: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
 1699 |             chars += sprintf(buf + chars, " %s", typeSpelling((Type *)instr->operand.ptrVal, typeBuf));
      |                                                               ^
c99 -static-libgcc -o umka src/umka.o src/umka_api.o src/umka_common.o src/umka_compiler.o src/umka_const.o src/umka_decl.o src/umka_expr.o src/umka_gen.o src/umka_ident.o src/umka_lexer.o src/umka_runtime.o src/umka_stmt.o src/umka_types.o src/umka_vm.o -lm
c99 -static-libgcc -shared -fPIC -o libumka.so src/umka_api.o src/umka_common.o src/umka_compiler.o src/umka_const.o src/umka_decl.o src/umka_expr.o src/umka_gen.o src/umka_ident.o src/umka_lexer.o src/umka_runtime.o src/umka_stmt.o src/umka_types.o src/umka_vm.o -lm

Alternatives to cyclic imports

I have a function like this in file called game.um:

fn getdist*(x1, y1, x2, y2: int32): real

Then I try to call it in another file (they are both in the same directory):

if game.getdist(e.ent.p.x, e.ent.p.y, mage.p.x, mage.p.y) < 200 {

But I get this error: Unknown identifier getdist

I import game.um, so I don't know, why it doesn't work. Is it a problem, because game.um contains the main function? I normally call functions from other files.

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.