* Goto did not support the class scope operator '::'. Like in DECORATE, this cannot be done with a simple '.' because it creates semantic problems with first part of a state label. This requires different syntax so that it can unambiguously distinguish between a scope identifier and the actual label
* Goto used the incorrect token PLUS for '+' instead of ADD.
* The state's duration was not stored in the AST.
* Truncating the sprite name inside the parser is probably not the best idea because it used a simple Printf to report this. Let's do this during processing of the AST where this can be properly handled as an error.
This adds:
* builtin types color, state and sound.
* ending a parameter list with an ellipsis to declare a varargs list. (A_Jump uses this.)
* allowing to declare optional arguments by giving them a default value.
* adding an 'action' qualifier for function declarations.
This uses the same property and flag tables as DECORATE with a few changes:
* it sets the parse mode to strict, so that several DECORATE warnings are now errors.
* trying to change a deprecated flag will print a warning.
* setting of editor numbers, spawn and conversation ID id not possible. Use MAPINFO to do this.
* all subclass flags must use the qualified name now (e.g. +ALWAYSPICKUP will print an error.)
* the scriptable Damage property is not yet implemented. This will require a special case with a differently named property in the processing function because in the AST it is no longer possible to distinguish between a damage value and a constant damage function.
This had been defined as a regular compound statement but in the context this will be used in, that makes very little sense, because all it can do is set some constant values.
The most important thing here is that it doesn't provide an unnecessary learning curve to its users and doing it this way will not only ensure that but also avoid redundant documentation.
To allow initialization of other user-defined properties it will require some extensions but that's a job for later and can just as easily be done in the current framework, rather than throwing everything out and start from zero.
This uses a different algorithm as the old implementation - instead of recursively resolving unknown symbols it will first collect all constants from all scopes and then process them in one operation, doing multiple passes over the list until no more constants can be resolved anymore.
- fixed class creation. There was an infinite loop and some missing checks for native classes.
- do not write the compiler's symbols to the same symbol table as the output. The output must go to GlobalSymbols but the internal symbols must go to a namespace specific table that can be discarded after compilation.
This is the first thing the compiler has to do to get access to the class's symbol table. Of course at this point the final size of a class is not known yet so these are currently all treated as tentative.
- place generated symbols into GlobalSymbols instead of a scratch table that will be discarded right away.
- allow the state object to change source file scanners (I hope this works, but the old implementation was unable to do more than one with with a parse state so I had to change it.)
- It can now parse constants.txt and insert everything in it into the global symbol table and make subsequent DECORATE compile properly.
- Enhancements to lemon to generate more compact action tables and to avoid making array bounds tests that can never fail on action table calculations. (user: drh)
- Update zcc-parse.lemon: YY_SZ_ACTTAB is now YY_ACTTAB_COUNT
- Don't bother keeping track of uncompiled nodes in a special table. Use
the regular symbol table instead. This should in the future make
compiling nodes referenced deeper than (and before) their definitions
fairly straightforward.
- Also, break up the compiler's Message() function into Warn() and Error()
and get rid of zcc_errors.h. I can't really see having a set of error
numbers being useful.
- Added new state options that DECORATE got to the lemon parser.
- Enable token generation for state options. They were previously not
generated, so the grammar treated them as function calls instead.
- AST nodes cannot be shared, because type conversion changes them in
place, and what's appropriate for one use is by no means appropriate for
all uses.
- Since the VM doesn't directly support the GT, GTEQ, and NEQ comparisons,
don't use them in the trees either. Instead, wrap them as LTEQ, LT, and
EQEQ inside a BoolNot operator.
- I can't believe I completely forgot to let the parser handle true and
false literals.
- Consolidate all the %include blocks in zcc-parse.lemon into a single
one, because Lemon all of a sudden decided it didn't like me having more
than one in the grammar file.
- Added a PBool type to represent boolean values with.
- Since the tokenizer never gives the parser negative numbers but always a
unary minus followed by a positive number, it seems reasonable to make
the parser smart enough to turn these into negative constants without
generating extra tree nodes.
- And since we're doing it for unary -, we might as well do it for unary +
as well and avoid extra nodes when we know we don't need them.
- For an enum like this:
enum { value1 = SOME_NUM*2, value2 };
Generate an increment expression for value2 of the form
(add (id value1) 1)
and not
(add (* SOME_NUM 2) 1)
- Instead of representating enumeration values with a special node type,
use the same ZCC_ConstantDef nodes that const_def produces. These are
created at the same scope as the ZCC_Enum, rather than being contained
entirely within it. To mark the end of enums for a single instance of
ZCC_Enum, a ZCC_EnumTerminator node is now appended to the chain of
ZCC_ConstantDefs.
- Instead of having ZCC_ExprString, ZCC_ExprInt, and ZCC_ExprFloat,
just use a single ZCC_ExprConstant. It should simplify type
promotion and constant folding in the future.
- Constants can fill out the type field right away. Other expressions will need
to wait until a later pass, after names have been resolved, so they get
initialized to NULL.
- Being able to omit optional function arguments is not such a nonsensical
thing after all. However, the previous grammar was still inadequate for
representing this in a useful way.
- Fixed: Trying to define a function without any parameters would silently
discard the function, because the declarator tested FuncParams instead
of FuncName to decide if it was a function.
- Fixed: state_call needs to enclose func_expr_list in LPAREN/RPAREN
itself, because func_expr_list doesn't include them. This means it also
needs a separate production to accept calls without a parameter list.
- The variable_name production now accepts an optional array size
argument. (Not yet passed to the AST.)
- The notation for using dotted ID lists as types has been changed from
[id1.id2] to .id1.id2, beacuse the former conflicts with the notation
for arrays.
Maybe TODO: Find a simple LISP pretty printer that isn't written in LISP so that the output
isn't all on one big long line.
- zcc-parse.lemon now returns the complete AST through the parse state.
- Fixed crash in PrintEnumNode().
SVN r3773 (scripting)
