Fix bug where compiler give syntax error when ID is not found (which is misleading, should give id-not-found compile-time error message for variables and types).
MUSTDO: Items that must be done for current release
None
TODO: Items to be done for next release
Store line/col info in Ast nodes (and/or JSON PDB file)
Implement Store::update().
Implement Store::remove().
Implement continuations for Store::select()
Implement Command line options in generated code.
Document Coertion mechanism
Document Default type values
Document Shared variables
Document Tree structure
Document Struct initialization
Document Closures and continuations
Document Current vdef in parse context
BACKLOG: Items to be done in future releases
Implement Interpreter
Implement state-transition mechanism.
Implement true async mechanism for all IO operations.
Implement run-queues
Implement priority on run-queues
Implement sync'ing of run queues when creating/deleting queues.
Database: Language integrated query
Database: Entity Defs
Database: Caching
Channels: Files
Channels: Sockets
Channels: ClientSocket
Channels: ServerSocket
Implement Console input channel
Web Framework (CGI, Sessions, HTML-template, AJAX, Rich Widgets, CSS)
Implement collection token for lexer. (e.g. OPEN := x:"xx";). It currently returns entire matched string
Implement ! operator in lexer.
Implement Config files: Open/Close/Read/Write
Convert string to fileinfo (or dir) in Project class.
Implement mechanism to check if a continuation has return, and only if so, link to parent closure.
MAYBE: Unprioritized items
Function should have return value as void if out-param is ().
Error handlers can be registered(on error). On error, entire handler stack is invoked(LIFO) then call stack is discarded.
An interface is a bundle of function signatures
An interface implementation is collection of functor objects.
Implement StringFormatter functionality.
Python integration
Routine memoization
Error codes for compiler
Different warning levels for compiler
Lint for compiler
Metric - Cyclomatic complexity
Metric - LOC
Metric - Performance numbers per function
Refactor AstFactory out of ParseContext.
Implement intrinsic two-way convertion between tree (any types) and other types, especially struct. (no use cases identified)
Replace mlog/dlog/elog/wlog <- <expr>" with "*log StringFormat"
Replace all asserts with throw's due to dlgbox on Win32/MSVC
MAYBE-NOT: To track items that probably won't be done
Type checking for function call params. (gets caught by c++ compiler anyway)
Implement native string. (not necessary unless removing dependency from all libraries (including Qt) altogether)
Variable declaration expression (x := 10;) (grammar conflict, and perhaps explicit local/shared is better?)
Channels: Console output (use log's instead?)
Use import/include statements to infer object files/libraries to be included(keep compiler simple?)
Pre-processor directives (ugly?).
Anonymous functions can extend functor and call base functor. (doesn't make sense?).
WONT: To track items that will not be done
A code-block automatically locks any shared/global variable referenced within it.(obsolete)
A routine automatically locks non-const ref-parameters.(obsolete)
Refactor RunContinuation to use inctor scope. [The RunContinuation automatically stores referred env variables. This functionality is duplicated in functoin ctor] (obsolete)
Implement ability to queue continuation directly at point-of-call.
Break zcc -x into zcc -w (isGui) and zcc -c (console) (not needed, using -w instead)
GUI: define UI and generate .qml file, integrate events with continuationss. (obsolete)
GUI: define UI and generate HTML files (obsolete)
GUI: define themes for UI's
Remove native access type. (is required for native functions)
DONE: Completed items
Closure xrefs.
Struct/OutParam member references
ContinuationClosure
Set RV of child continuation to parent closure.
Rename zen.hpp to zrt.hpp (zen run time) and ztl.hpp (zen template library)
External Functions: Ability to implement functions in C++ and invoke from zen
Implement Compiler class
Call function instance
Object ownership mechanism.
Parser: Language integrated definitions
Refactor specialized code for handling zbl-namespace in Compiler and CppGen.
Coertion table implementation.
Create index on unit table
Store: Query language.
Store: insert().
Store: select().
Implement recursive function calls
Implement ctor and & in structs.
Implement recursive grammar calls
Implement function as signature + value.
Display number of unit tests + number of fibers.
Compiler command line options -os: shared library, -ol: static library
Implement functor objects (struct-like objects that wrap function calls and call parameters)
Make gramar rules into functions.
Separate builtin functions into namespaces.
Infer statement State from top of type-stack.
Implement import stack in ParseContext.
Lambda: Declaration. (int i, string s)mydecl(int a);
Lambda: Definition. y = mydecl{}
Lambda: Call. y = mydecl{}; r = y(10);
Use functor-extensions to re-implement continuation/closure model.
Ability to enque continuationss from routines, especially main().
Merge run and call continuationss
Remove ApiCaller
Implemented enum.
Remove TRACE in Parser.y
Create Ast for primary_expr (expr in bracket)
Implement loop continuation
Fix bug in lexer handling empty string constant.
Struct members must have default values.
Process project files (.zen)
Get rid of runBare(), replace with run(_pctx)
BUG: zbl::process does not return error code (returns success) if executable file not found.
External Routines: Ability to implement routines in C++ and invoke from zen(takes value or const-ref params only, should not maintain any global state)
Operator: has (was: in) (check if item is in collection)
Implement splitting a file into strings and enqueing each string with a function.
