kos-lang / kos Goto Github PK

• Constant expression folding, including immutable constants.
• Basic dead code elimination (with a warning).
• Unused variable elimination (with a warning).

• Add argument -c to pass a script on the command line.
• ? In case of a script passed with -c, lang module should be automatically included.
• Also add another argument (just a dash?) to read a script from stdin. No default import needed here.

A separate 'unicode' module is needed for these operations to be handled properly. The default implementation should do a binary comparison and ASCII lower/upper.

Write a Kos script which checks coding style.

Update source code to correct any coding style errors.

The current routine used for extracting doubles from strings has a minor roundoff error when the number of digits reaches the limits of double precision.

Pass stack frame pointer instead of context pointer.

Require all threads invoking Kos functions to be registered. KOS_get_stack_frame() invoked to obtain a stack frame pointer should take care of registering automagically.

In debug builds: assert if current thread is not the thread registered in the stack frame.

Allocate stack frames from a buffer (except for stack frames for generators). Initial measurements suggest that we spend a lot of time allocating stack frames.

Keep exception status in the stack frame. Initial measurements suggest that TLS access is too slow for that.

Consider keeping registers in stack frame as well, or alternatively keeping them in a growable register array (except independent variables and generators).

Improve some error messages and provide better hints on how to fix them, both during compilation and during run time

Derive all exceptions thrown internally and by modules from a exception prototype and correctly print exception string for these exceptions.

Run one script (or multiple if necessary) multiple times, with an error index passed on the command line, incremented on every run. All conditions which can possibly fail should be ordered an each error condition should fail on subsequent runs.

This will require building interpreter/lang/modules with a special flag.

Write a Kos script which generates valid source code with predictable results. Test the generated scripts.

Consider adding unicode support in 'unicode' module.

Some amount of memory may be required for unicode tables, so it may make sense to put this in a module.

An alternative is to support it in core.

Consider parsing the public Unicode tables, e.g.:
http://www.unicode.org/Public/9.0.0/ucd/UnicodeData.txt
to extract lowercase/uppercase relations and ordering (for lexicographical sorting).

Investigate adding a test based on thread sanitizer and possibly other sanitizers as well.

These are described here: https://github.com/google/sanitizers

Add _KOS_printf function which can be re-implemented when embedding Kos if needed.

All code in Kos should use it for all internal prints.

Consider it also for any stdout interaction.

• Two ways of collecting garbage: scavenge (frequent) and full (rare).
• Objects (most?) allocated in a scavenged pool.

Problem to solve: how to handle external calls, native functions and objects held by C functions without races?

One possibility: individual short-lived (scavenged) heaps for each thread.