fg123 / wendy Goto Github PK

With the new reference counted allocations, we end up with reference cycles easily. The best way is probably to implement a GC like Python's: https://rushter.com/blog/python-garbage-collector/

Once we attempt to print a list, we don't make VM calls anymore, so we need to change how list output works.

In some cases a function could leave items on the stack, messing up argument parameters, eg:

map(#:(x) x * x, sort(A))

For some reason, I think sort(A) leaves items on the stack, since map retrieves A for the first parameter instead of the lambda function.

for example:
#:(a) {}

Code like:

let a = [1, 2, 3, 4, 5];
a[0->2] = 0; // a = [0, 0, 3, 4, 5]
a[2->5] = [10, 20, 30]; // a = [0, 0, 10, 20, 30]

List based replacement should only work with lists and not all iterables, like the list concat vs append right now.

hi,
doesn't compile on macOS
the problem is the in file ast.c
line 687 enum opcode code;
error variable 'code' is used uninitialized whenever switch default is taken
what is default value ?

Needs better identifier tracking to push local function to own call stack (top level is fine because it will search in global namespace)

let a = 10
for a in 1->5 ...

Complains about redeclared a.

Release builds should still perform checking to see if the system malloc returns a valid pointer. (just no memory leak check).

Since we don't have dynamic naming of variables, codegen should know the names of all the variables (global and local), and in fact, optimizer already keeps track of these for optimization purposes. We could resolve the runtime stack into a simple index based lookup which would speed up the VM considerably both in time and space. Some work might need to be done for default function values or named arguments.

like if an import has an import, imports that have dependencies on other imports (how might that work after compile?)

for i in lst is ambiguous. i in lst could be a boolean param, or could mean i : list, iterating through list. Need way to distinguish.

Because importing a file by include instead of by pre-compilation will change the original source, source line tracking needs to be updated.

This helps with the case of forgetting to ret this at the end of struct inits.

Some syntax like ...iterable would expand to the elements in the surrounding context. This is easy to implement in codegen, just push each value of the iterable to the stack, but harder to do error checking in the AST. We probably need a "settings" struct to be passed around when recursive descending to set when we should match for these types of values.

Run REPL

call function that doesn't exist with arguments,

observe segfault

Technically not static so we should rename to shared members instead of static members

[0] * -1;

results in

Could not allocate memory! Out of memory?Program Stopped.

https://wendy.felixguo.me/code/?code=WzBdICogLTE7

need to check for negative values at https://github.com/fg123/wendy/blob/master/src/vm.c#L1279

• Function arguments can have default values

let fun => (a = 10, b = 20) ...

• Function argument passing can pass by name of arg

fun(a = 10, b = 20)

• Maybe look into multiple dispatch but that's more complicated

• Implement var-args?

• Safer function calling mechanism to prevent overflows.

Prevents a runtime error when function args don't match (also prevents pulling too many arguments from the stack thus corrupting the working stack)

alternative is to implement it like javascript

static double native_to_numeric(data* t) {
	return t->value.number;
}

static char* native_to_string(data* t) {
	return t->value.string;
}

Should throw an error if the type is not numeric or string.

eg, number of closures available, number of characters in a token string (should become char* and use malloc'ed memory)

native functions can return values but has no output

The VM takes a long time to shutdown after running, especially code with a lot of allocations.

Can't overload negation on literal number because negation is done in parsing. If we move it to a full operator, then we need to add negating literals to optimizer.

Code generation comments in disassembly auto added if called with --disassemble.

Compiled version can have optional comments with -c -v.
New flag -v, --verbose. Will interleave comments in byte-code.

Codegen doesn't understand f(x)(y) if f(x) returns a <function>

let a => () { ret 10; }

Generates:

frm
push 10
ret
end // redundant
push <noneret> // redundant
ret // redundant

This would allow for better compile time analysis and a slimmer VM.

Function bodies that have ret will prevent closing of frm from:

		write_opcode(OP_FRM);
		codegen_statement_list(state->op.block_statement);
		write_opcode(OP_END);

The automatic frames are automatically closed when ret but the memory register stack will not be popped the correct amount.