SYNTH * figure out a way to get transients like before: i'd like to stack instruments, so short lives ones can just re-instate long lived ones: don't save everything, just the init word. DICT/CACHE * fix multiple macro definitions in state file. (see below) * make it possible for a macro to create a variable. more specificly: make it possible to create any couple of words and variables together. (this means a macro can create a macro.. probably means re-introducing some reflection). * find a policy for overwriting macros. currently i'm using a combination of forth style redefining, which due to early binding actually is managable: top code won't change down code, but for macros this is not the case. some mechanism needs to be installed that enforces this, otherwise there are going to be some nasty surprises.. also, macros are global for a compilation unit! (note: this is part of the unified dictionary idea) * it is possible to redefine macros in a compilation unit: the last one wins. but it is not a good idea to redefine procedure words: make this into an error. in fact, fix the policy about names in compilation units explicitly, and figure out a way to compile multiple units, or at least to save them in intermediate (s-expression) form. * figure out a (poor man's) depenency management system * it's essential to have macro creating macros, or at least macros that can allot ram memory. * unify dictionaries: put macros in the main dict as lists, store ram addresses as variables, and find a way to postpone compilation of macros to their corresponding values if they reduce to values (are constants/variables/labels...) CORE * switching project: use the id returned from 'ping' to load the correct project. * find a way to better deal with conditionals instead of always having to create macros. (see conditionals.f for more traditional forth words with flags on the stack) * fix named macro arguments syntax to prefix notation: make it more forth-like: forward parsing only. * add a 'update from darcs' command which cleans then compiles everything and brings the system in a predictable state. * figure out why lexing is so slow -> simplify tokenizer and parsing + use reader extensions. * add code defaults for <<< and >>> macros * add better 'scrap' interactive metaprogramming tools: interaction scripts etc.. can this somehow be unified? 2 different meta-languages (macro + command) makes it a bit awkward to use.. * add data initialization code: instead of inline code, do this with tables to save space. * use reader extensions to load forth files? * why can't meta functions be extensible? maybe every macro should have its meta function equivalent? can this be made meaningful? * find a way to insert comments in the instruction stream that are invisible for the optimizer's pattern matcher. best with an additional annotate function. this probably means moving to abstract data types for instructions. * find and eliminate the bottleneck in @forth->macro/code * switch parser to syntax stream, including read-syntax * figure out how to unify simulation and partial evaluation