| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
This will maybe be useful for live variable analysis.
|
|
God damn delete is even more complicated than insert. I think it works,
at least.
|
|
Global variables will be stored in an array which is kept in register 0.
The linker will later translate each library-ref into an integer, which
is used as an index into the globals table.
This design makes implementing eval quite straightforward, the eval
bytecode will accept a globals table and a bytevector of bytecode, save
the current set of registers, set register 0 to the new globals table,
and begin executing the given bytecode. When eval is finished, it will
restore the saved registers and return to the previous instruction
pointer. In this way, calling eval can create a call stack.
We could think about implementing function calls with eval, and it's
cool that it would work, but the CPS transformation mostly makes this
irrelevant. It's interesting to think about implementing an interpreter,
where a function call would simply eval the function's bytecode, and the
function call stack would be handled automatically.
|
|
|
|
Running the record matcher has a side-effect (raising *no-match*), so we
call it ahead of time to ensure a consistent order of evaluation.
|
|
The point of argument conversion is to validate on each function call
that the right number of arguments were passed, and to ensure that no
function has more than 1 argument. This second condition makes CPS
slightly simpler, and ensures that the arguments will all fit in locals.
We take the strategy of allocating a vector for each function call.
Ideally we would optimize away most of these allocations, but for now I
just want it to work.
|
|
|
|
|
|
I'm marginally reducing verbosity with this change,
without sacrificing readability.
|
|
|
|
I was hesitant to add a diff library, but it was surprisingly easy. A
straightforward application of dynamic programming.
|
|
I desperately need a diffing library.
|
|
Now variables can't be updated after they're created, so they can be
freely copied into closures.
|
|
|
|
I like scheme because it's possible to add any convenient language
feature I can think of.
|
|
Goodbye soup. Thanks to "Compiling with Continuations" by Appel.
|
|
Wow we actually finished CPS. Next is closure conversion, then codegen,
and then we should be able to run some end to end tests. Then we can
look at garbage collection, and from there continue building features
down the long road to self hosting.
|
|
I improved the abstraction in to-cps.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Why have void? We will just use #f.
|
|
Gone is toplevel. Now everyone lives in a library.
|
|
I'm realizing that I should have started with builtin-exit and
implemented the hard stuff later.
|
|
We're omitting libraries for now, and I'll add them in later.
|
|
|
|
|
|
|
|
This makes everything a lot easier, as it handles nested loops
automatically. My brain wave was storing the returned values in a thunk.
|
|
It works! Sometimes it emits nested loops!
|
|
|
|
I also cleaned everything up a lot. Maybe there are still bugs because
the test coverage is awful, but for now I'm happy to be done.
|
|
Computing length each time is very unnecessary.
|
|
|
|
It works!! At least it passes all the test cases.
Next I will:
1. finish the builtins,
2. add a conversion to IR2 in continuation passing style,
3. add a compiler from IR2 to bytecode,
4. and add an option to the frontend compiler to generate a
standalone executable.
|
|
Committing it because it compiles. I have to write tests and debug
it still.
|
|
This makes the control flow more clear, and eliminates the need to scan
the pattern twice. It also makes it easier to add new forms by
consolidating the pattern logic in one procedure.
|
|
I was reading about the difference, and := does what you want more often
than not.
|
|
Before we were assuming keys could be compared with eqv?. But it seems
like that assumption isn't true when we want to hold identifiers in the
hash map.
|
|
|
