# for now, invoke with: # grep -v "^#include" c-testsuite/tests/single-exec/00164.c |cc -E -| grep -v "^#" | tee zzz.c | ./c /dev/stdin # # NOTE: Since writing this I have written an 'exclude' utility at # # /home/gtoal/src/mkptypes/exclude.c # # which expands include files but only local ones using "filename.h" rather # than system ... # to avoid problems with system headers try using the header files from dietlibc with -I ./include and the --nostdinc option to cpp # I may or may not have a problem with types "int16_t" etc. Need to look into that. # Also, if it's needed, there's a version of the C preprocessor (with binaries # in ~gtoal/bin/gtcpp and ~gtoal/bin/gtcpp_FILE) with the sources being in # /home/gtoal/src/unicode/mcpp/* - this is the hacked pre-processor that # uses '$define' instead of '#define' and supports redefinition of C array # syntax using [] rather than (). E.g. $define x[a][b] instead of #define x(a,b) # (the choice of plain or _FILE variant is to allow the choice of expanding __FILE__ # either in gtcpp or leaving it for cpp to handle in the processed output, which is # usually preferred). # This is a somewhat crude attempt to parse C (somewhere around the C99 level) # that does successfully parse just about all of my own code. I wrote it for # two reasons: 1) to create a context-sensitive filter for C code (to be used # in my static binary translators and also in my Imp to C language translator) # and 2) just to see if C could be parsed with my 'uparse' (Edinburgh-style) # parser without using a lexer. # There are a couple of areas that it still has some minor problems with - # a) some of the more complex typedefs # and # b) struct initialisation # also # c) some later extensions that are now in common use such as "for (int i=0; i>AST_type_shift)&AST_type_mask]); return tmp; } wchar_t *pooltowstr_inner(StrpoolIDX p, const char *file, const int line) { if (p == -1) { fprintf(stderr, "* Error: pooltowstr passed -1 (uninitialised string) from %s, line %d\n", file, line); } else if (P_AST_type(p) == 0) { fprintf(stderr, "* Error: pooltowstr passed an untagged index from %s, line %d\n", file, line); } else if (P_AST_type(p) == STRING_TYPE) { fprintf(stderr, "* Error: pooltowstr passed a STRING_TYPE rather than an AST_POOL_LIT from %s, line %d\n", file, line); } else if (P_AST_type(p) == AST_ATOM_LIT) { fprintf(stderr, "* Error: pooltowstr passed a AST_ATOM_LIT rather than an AST_POOL_LIT from %s, line %d\n", file, line); } else if (P_AST_type(p) != AST_POOL_LIT) { fprintf(stderr, "* Error: pooltowstr passed an unexpected tag type %d:", P_AST_type(p) >> AST_type_shift); fprintf(stderr, " %ls from %s, line %d\n", Decode(p), file, line); } p = p & AST_idx_mask; return &Stringpool(p); } } # The project that this came from used built-in routines fairly heavily. # This version based on the new Unicode parser should be able to replace # these with C<> code or regular expressions in many cases. # It's not any particular standard C version, but it's close enough to # the C that I write that it parses all my code which was all I wanted # it for (actually it was originally for my static binary translator # project where the output of the translator had to be massaged a little, # but now it's for my Imp to C project for similar reasons!) # Note that all I will be using this for will be relatively simple # almost macro-like transformations to make the generated C more readable, # for instance replacing A[(5) - (0) + (1)] with A[6] ... B = 0; B = 2; C = { #ifdef IN_PARSER while (source(TP).ch==' ' || source(TP).ch=='\n' || source(TP).ch=='\t' || source(TP).ch=='\f') { TP += 1; } #endif return TRUE; }; C = { #ifdef IN_PARSER int debug_stropping = 0; // The 'C' line reconstruction was thrown together in a couple of minutes and without // any consideration to the subtleties of C's lexing. So expect major problems in this // area until it is looked at properly and actually designed. Current testing // environment strips out all lines starting with '#', and all comments too. So // the comment stripping here hasn't even been tested yet. // Note that line reconstruction in C is unlike in Imp and even unlike lexing in // a yacc/lex C compiler. It is *only* here to remove multiple leading spaces and // comments before non-space characters (not *tokens*), however care must be taken // in parsing to skip spaces where spaces must be skipped, while checking that there // are no spaces in multi-character tokens whose characters must not have spaces // between them. This will require some assistance from the grammar, it cannot // all be done in the line reconstruction phase. // So far the only concession to C's lexing conventions are that we check that keywords // are not followed by an extension of the keyword, so "intx" is not confused with "int x". // Otherwise, spaces are pretty much skipped. I suspect that something like "constint" // would currently be accepted for "const int". I either have to modify uparse.c to // handle whitespace differently, or add explicit whitespace to the grammar. // The source file has already been read trivially into source(). // We will copy from source() into temp(), then perform line reconstruction // on temp(), writing back to source(). The parser will then parse source() // into atoms according to the grammar. Initially it will only store the // reconstructed characters into the atoms, but once it is working, I will // modify it to also store the unreconstructed source for use in source-to-source // translations, where whitespace, embedded comments, and indentation is // desired in the translation, in order to mirror the original file. // All arrays are flex and the upper bound is a limit, not a minimum. // TODO: free SYM at the end of this procedure using FREE_FLEX(SYM). #define MAX_SYM 128000000 DECLARE(SYM, reconstructed, MAX_SYM); // was 600000 #define _SYM(x) WRITE(x,SYM,reconstructed) #define SYM(x) READ(x,SYM,reconstructed) int LASTP, P = 0; _SYM(0).start = 0; while (source(P).ch != 0 /* WEOF */) { _SYM(P).ch = source(P).ch; if (P > 0) _SYM(P).start = SYM(P-1).end; _SYM(P).end = P+1; P += 1; } _SYM(P).ch = 0 /* WEOF */; if (P > 0) _SYM(P).start = SYM(P-1).end; _SYM(P).end = P; // no chars for EOF LASTP = P; if (debug_stropping) { int I; fprintf(stderr, "source() moved to SYM(0:%d) = \"", LASTP); for (I = 0; I < LASTP; I++) { fprintf(stderr, "%lc", SYM(I).ch); } if (SYM(LASTP).ch != 0) fprintf(stderr, "[%d]", SYM(LASTP).ch); fprintf(stderr, "\";\n"); }; int FP = 0, PP = 0; // Fetch Pointer, Put Pointer. #define DONE() \ do { \ FP -= 1; /* the terminating 0*/ \ _source(PP).ch = 0; \ if (PP > 0) _source(PP).start = SYM(PP-1).end; \ _source(PP).end = SYM(FP).end; \ if (debug_stropping) { \ int I; \ fprintf(stderr, "SYM(0:%d) moved back to source(0:%d) = \"", FP, PP); \ for (I = 0; I < PP; I++) { \ fprintf(stderr, "%lc", source(I).ch); \ } \ if (source(PP).ch != 0) fprintf(stderr, "[%d]", source(PP).ch); \ fprintf(stderr, "\";\n"); \ } \ TP = 0; FREE_FLEX(SYM); return TRUE; \ } while (0) wint_t WC, Peek; // uparse.c had been modified so that its implicit whitespace skipping no longer skipped '\n'. // (The algol60 parser in contrast treats all \n's the same as spaces, as we are now doing here) #define CHECK_EOF(x) do if ((x) == 0) DONE(); else { if (PP > 0) _source(PP).start = source(PP-1).end; if (FP > 0) _source(PP).end = SYM(FP-1).end; } while (0) // PP is the 'current' slot we are writing into. _source(PP).start = SYM(FP).start; for (;;) { if (PP > 0) _source(PP).start = source(PP-1).end; // Keep updated. _source(PP).end = SYM(FP).end; // Keep updated. WC = SYM(FP++).ch; CHECK_EOF(WC); Peek = SYM(FP).ch; //CHECK_EOF(Peek); if ((WC == '/') && (Peek == '*')) { // TODO: fold multiple spaces and comments into one. // Instead of using the saved WC to provide spacing and newlines in the output, we // should use the saved comment text, while saving only a ' ' rather then \n \t \f as ch. // TODO: remember that fred/*...*/jim generates two tokens, so a comment // that is not surrounded by spaces still must be treated as a space. // Matters for C such as (when b = 2, c = 3): // b- --c = 0 // b-- -c = -1 // b---c = -1 // b-/**/--c = 0 // b--/**/-c = -1 // (and this is before we get into token pasting in the preprocessor!) for (;;) { WC = SYM(FP++).ch; CHECK_EOF(WC); Peek = SYM(FP).ch; //CHECK_EOF(Peek); if ((WC == '*') && (Peek == '/')) { WC = SYM(FP++).ch; CHECK_EOF(WC); Peek = SYM(FP).ch; //CHECK_EOF(Peek); break; // but still looking. } } continue; } else if ((WC == '/') && (Peek == '/')) { // Note: C's '//' comments are not quite the same as Imp's '!' comments, // as the Imp ones are a statement that must come at the start of a boundary // whereas the C ones can be appended to any line. They are more like // the Imp '{' but without a matching '}' before the end of the line. // Whereas C's /* ... */ comments are *not* like Imp { ... } comments // because those are single-line only. Translating comments from Imp to C // is going to be ugly. Fortunately this program doesn't care :-) for (;;) { WC = SYM(FP++).ch; CHECK_EOF(WC); Peek = SYM(FP).ch; //CHECK_EOF(Peek); if (WC == '\n') { break; // but still looking. } } continue; } else if (WC == '\'') { _source(PP++).ch = WC; for (;;) { WC = SYM(FP++).ch; CHECK_EOF(WC); Peek = SYM(FP).ch; //CHECK_EOF(Peek); if (WC == '\'') { _source(PP).ch = WC; if (PP > 0) _source(PP).start = source(PP-1).end; // Leave Peek for later. if (FP > 0) _source(PP).end = SYM(FP-1).end; // Leave Peek for later. PP++; break; } else if (WC == '\\') { _source(PP++).ch = WC; _source(PP++).ch = Peek; FP++; } else { _source(PP++).ch = WC; } } continue; } else if (WC == '"') { _source(PP++).ch = WC; for (;;) { WC = SYM(FP++).ch; CHECK_EOF(WC); Peek = SYM(FP).ch; //CHECK_EOF(Peek); if (WC == '"') { _source(PP).ch = WC; if (PP > 0) _source(PP).start = source(PP-1).end; // Leave Peek for later. if (FP > 0) _source(PP).end = SYM(FP-1).end; // Leave Peek for later. PP++; break; } else if (WC == '\\') { _source(PP++).ch = WC; _source(PP++).ch = Peek; FP++; } else { _source(PP++).ch = WC; } } continue; } else if (WC == ' ' || WC == '\n' || WC == '\t' || WC == '\f') { // use iswblank(WC) instead? // TODO: fold multiple spaces and comments into one. // Instead of using the saved WC to provide spacing and newlines in the output, we // should use the saved comment text, while saving only a ' ' rather then \n \t \f as ch. _source(PP++).ch = WC; continue; } else { // everything else just returns one significant non-space character. _source(PP++).ch = WC; continue; } // Still skipping whitespace ... } DONE(); P = 0; while (source(P).ch != 0) { if (debug_stropping) fprintf(stderr, "%d: ch='%lc' start=%d:end=%d\n", P, source(P).ch, source(P).start, source(P).end); P++; } TP = 0; //for (;;) { // fprintf(stderr, "TP = %d start = %d end = %d ch = '%c'\n", TP, source(TP).start, source(TP).end, source(TP).ch); // // should show comment text etc too. // TP += 1; // if (source(TP).ch == 0) break; //} //exit(0); //TP = 0; FREE_FLEX(SYM); #undef DONE #endif return TRUE; }; # for the initial implementation, preprocessor directives (and anything # starting with a '#' at the start of a line such as pragmas) will not # be handled. So they had been have been stripped from the inputs first! # I'm consider a mechanism to allow spaces before rules by default but # not allowed if the rule is explicitly prefixed by a test which # checks there are no spaces present. This ought to e possible solely # as a C<...> rule, with no code changes needed to the parser. # I believe these are the regular expression types that this regex package supports: # ^string (start of text) # string$ (end of text or end of line???) # [ABC] # [ABC]? # [ABC]+ # [^ABC] # [^ABC]? # [^ABC]+ # [A-Za-z0-9] # . (any) # abc* (i.e ab abc abcc abccd etc) # abc+ (i.e abc abcc abccd etc) # (abc|def) # (abc|def)? # (abc|def)+ # ... and combinations (sequences) of the above # \< and \> are for unimplemented word boundary functionality. # where \< must match [A-Za-z0-9_] and \> must match [^A-Za-z0-9_] # Probably should be in here too: P = , # 1.1 must be parsed before 1 , , ; # Not sure if allowing spaces anywhere in any constant is valid, but I'll accept it for now. P = 'U', 'u', ; P = 'L', 'l', ; P = 'U' , 'L' , ; P = , , , ; P = «[1-9][0-9]*»; P = «0[0-7]*»; P = «0[xX][0-9a-fA-F]+»; P = «0[bB][0-1]+»; P = , , ; # octal too? ##P = «([0-9]*\\\\.)?[0-9]+»; P = '.' , '.'; P = «[eE][+-]?[0-9]*»; P = , ; ##P = «([0-9]*\\\\.)?[0-9]+([eE][+-]?[0-9]*)?[flFL]?», ## «[0-9]+[eE][+-]?[0-9]*[flFL]?»; P = «[flFL]?»; P = «[0-9]+»; P = , ; P = , ; P = «0[xX]» «[flFL]?», «0[xX]» «[flFL]?»; P = «0[bB]» «[flFL]?», «0[bB]» «[flFL]?»; P = «[A-Fa-f0-9]+»; P = «[A-Fa-f0-9]*» '.' «[A-Fa-f0-9]+», «[A-Fa-f0-9]+» '.'; P = «[0-1]+»; P = «[0-1]*» '.' «[0-1]+», «[0-1]+» '.'; P = «[pP][+-]?[0-9]+»; P = ; # WARNING: Looks like \ handling is not yet done properly in regexps? # - what is entered in the .g file should look just like what # would be entered in a .c file ... ##P = «[L]?'(\\\\[\\\\'\\"?abfnrtv]|[~'])*'»; P = «'» «'»; P = , ; P = «[^'\\\\]», ; P = '\\' «[\\\\\\"'?abfnrtvx0-9]»; P = 'L', ; ##This will replace ##P = «[L]?\\"(\\\\[\\"'?abfnrtv]|[~\\"])*\\"»; P = «[A-Za-z_][A-Za-z0-9_]*» ; # «[ ]*[A-Za-z][A-Za-z ]*» P = «'»; # temporarily needed for disambiguating L'ch' in . ##These have been replaced by : ##P = '\\' , «.»; ##P = , ; ##P<_sqstring> = ; ##P = <_sqstring>; ##Replaced by regexps based on https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf ##though I still wonder if Ll or lL are allowed as well as ll and LL. ##(personally I think lower-case L should *never* be allowed in integer constants!) ##P = ; ##P = 'LL', 'L', ; ##P = 'U', ; P = '"'; P = '\\' , «.»; P = , ; P = ; P = , ; # implicit concatenation # The uparse parser now supports creating an automatic list of keywords from # any strings enclosed in ""s. Not so for ''s. We still have to work out how # to access that list from here as a predicate though! C = { #ifdef IN_PARSER int SAVE = TP; parse_whitespace(); if (TP != SAVE) return 0; if (TP == 0) return 0; if ((source(TP-1).ch >= 'a' && source(TP-1).ch <= 'z') || (source(TP-1).ch >= 'A' && source(TP-1).ch <= 'Z') || (source(TP-1).ch >= '0' && source(TP-1).ch <= '9') || source(TP-1).ch == '_') { TP = SAVE; return 1; } TP = SAVE; #endif return 0; }; P = ; # indirection caused by bug with skipped spaces not being backtracked on error... (TODO) # BUG: causes a runtime error. WHY???? ###P = ### ; ##P = ## ; P = ; P = ; P = ; #P = # { # fprintf(stderr, "Calling C code to compile identifier.\n"); # t[1] = -1; # t[2] = compile(P(2), depth+1 /* P_unchecked_identifier */); # return t[0] = P_mktuple(P_identifier, alt, 2/*phrases*/, t); /* (note t[], not T[]) */ #}; C = { #ifdef IN_PARSER // Is a boolean return what is needed here? return ((source(TP).ch >= 'a') && (source(TP).ch <= 'z')) || ((source(TP).ch >= 'A') && (source(TP).ch <= 'Z')) || ((source(TP).ch >= '0') && (source(TP).ch <= '9')) || (source(TP).ch == '_'); #else return 0; #endif }; ## C = { ## return is_in_array(last_internal_identifier_seen, keyword, NUM_KEYWORDS); ## }; # I've added a mechanism that allows uparse to build a list of keywords from strings in "quotes" # (which is triggered by C being defined) but for now I'll just use a hard-coded list... P = ; P = "if", "const", "struct", "union", "sizeof", "typeof", "double", "long", "char", "float", "void", "enum", "short", "int", "signed", "unsigned", "volatile", "auto", "register", "static", "extern", "goto", "continue", "break", "return", "while", "do", "for", "switch", "else", "case", "default", "typedef"; P = ; P = ; P = , ; C = { #ifdef IN_PARSER int WP = TP; // Pick up start of white space parse_whitespace(); if (source(TP).ch == '#') { // Although we currently read from a '#' at the start of a *statement*, // C requires us to accept preprocessor directives only from the start // of a *line* (modulo leading spaces) so (TODO) we need to keep a // 'start of line' flag as well, and test that when checking for a // preprocessor directive. // Actually even this scheme isn't proper C because a preprocessor // directive can be at the start of a line yet in the middle of // a statement. I think this means it *must* be handled during // line reconstruction, which means (if we are going to handle // #define as well as #pragma not to mention #include), that all // of cpp needs to be built in to the line reconstruction and // a special mechanism (hack) has to be added to pass #pragma // instructions through to the compiler part. _source(TP).start = WP; TP += 1; while (source(TP).ch != '\n') TP += 1 /* skip */; // maybe should include the \n for a # directive? if (TP > 0) _source(TP).start = source(TP-1).end; _source(TP).end = TP; return 1; } else #endif return 0; }; P = , ';', , ';', , # do these need a ';' ? , # " " " " ? ';'; # null statement # Oops - these can be initialised. Not yet done so. # P = '{' '}', '{' '}', ; # semicolon needed??? P = "struct", "union"; P = ; P = , ; P = ';', ';'; # added to support "union { int a; int b; };" without a name (i.e. "union { int a; int b; } fred;") # I originally thought you could only initialise an array after a declaration # that had '[]' in it. But not the case - a typedef'd declaration may have # the array part in the typedef rather than the instance. Ugly language. # # Also we can have initialised structs :-/ # # These can be the fields of a struct??? that doesn't make sense. # - it's the top-level struct declaration that should be initialisable, not the fields. # should allow: # struct { int a; int b; int c; } s = {1, 2, 3}; # or # struct S {int a; int b;}; # struct S s = { .b = 2, .a = 1}; P = ; # The part of function pointers is usually going to be "= &procname"... any other type of scalar is dubious... P = , '(' ')' '(' ')' , ; P = ',' , ; ##P = ## '=' , ## ; # The original code failed to handle "int b = a = 123;" or "int b = a[123] = 123;" or "int b = fred + (a = 123);" # and my quick hack fix failed as well - I think it's # another example of the 'maximal munch' problem same as # with a series of casts before a bracketed variable. # No - wait - it's more likely that does not allow assignment statements? ##P = '=' , ; P = '=' , ##'=' , ##'=' , ; P = ; P = , ; P = ; P = '?' ':' , ; P = ; P = ; P = ',' , ; P = ; P = "||" , ; P = ; P = "&&" , ; P = ; P = '|' , ; P = ; P = '^' , ; P = ; P = '&' , ; P = ; P = , ; P = ; P = , ; P = ; P = , ; P = ; P = , ; P = ; P = , ; # my reading of the spec is that "sizeof" is valid but "sizeof" '(' ')' is not, # however the latter appears to be accepted by gcc. # Should we merge with ? Is ever used without an optional '*' following? P = , , , , "sizeof" , "sizeof" , "sizeof" , "sizeof" '(' ')', ; P = , ; P = '[' ']' , '(' ')' , '.' , "->" , , ; # Unfortunately with this parser, '...' strings are really '.' '.' '.' sequences, and # each unit is allowed to have whitespace separating it. Using "..." will force no # spaces between the characters, but will have the side-effect of adding "..." into # an internal table that was intended for use in checking keywords. But we can live # with that. P = "++", "--"; P = , ; P = ',' , ; P = , , , ; P = ; P = '[' ']' , '(' ')' , '.' , "->" , , ; P = '[' ']' , '(' ')' , '.' , "->" , ; # this does not recognise '(unsigned) *p' in "int jim = 123; int *p = &jim; unsigned int fred = (unsigned) *p;" P = ; # # There is a problem parsing (cast)(expr), because multiple casts are allowed, # as in (unsigned long)(long)(variable) # so the rule gobbles up the (variable) and what follows then causes a # syntax error. Or worse, doesn't ... as in (long) (short) (fred)*(jim) # which parses as a cast of "*(jim)" rather than a cast of "(fred)*(jim)". # # There doesn't seem to be a way to fix this in this sort of parser without # mixing the syntactic and semantic levels which unfortunately rules out # program-at-a-time parsing. Meanwhile working around it with this hack # which limits the number of cascading casts! # P = , , , '(' ')', # before a bracketed expression is the only place where the maximal-munch of causes problems: '(' ')', '(' ')', '(' ')', '(' ')'; P = , ; P = '(' ')', '(' "typeof" '(' ')' ')', '(' "typeof" '(' ')' ')'; # looks just like except that it only # happens in a declaration, not a data access. The significant difference is that the '*' # can be preceded by a "const" (and maybe "volatile") keyword, eg "int const *fred" which # is a constant pointer to an int. # P = '*' , ; P = '*' ; P = '*' , ; P = , ; # TO DO: This has to interact with the back-end in order to distinguish typedef'd names from anything else! # unfortunately this completely breaks the separation of syntax from semantics. C is badly designed as it # assumes (and indeed almost forces) a particular organisation of compiler structure. P = ; # I think struct or union or enum specifier below can be an actual declaration using '{}'s # rather than just a struct or enum name. # P = "void", "double", "long" "double", "float", "char", , , ; P = "enum" '{' '}', "enum" '{' '}', "enum" ; # do these need a ';' ? P = ; P = ',' , ',', ; P = '=' , ; P = ; # does this omit "signed int"? - check, and add "int" if needed... P = "short" , "long" "long" , "long" , "int", "signed", "unsigned"; P = "int", ; P = "signed", "unsigned", ; P = "&&", '&'; # && is a gcc extension for arrays of labels. P = "++", "--"; # precedence is built in to this grammar. It's easier than handling it # with operators of equal precedence and a reverse-polish stack shunting # yard algorithm. P = '~' ; P = '~' , ; P = '!' ; P = '!' , ; P = '+', '-'; P = '*', '/', '%'; P = '+', '-'; P = "<<", ">>"; P = "<=", '<', ">=", '>'; P = "==", "!="; P = '='; P = '=' , # a guard, just in case there's a comparison also valid with the same input up to this point... "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", "^=", "|="; P = , ; P = '=' '{' '}', '=' , ; P = ; P = ',' , ',', ; P = , '{' '}'; P = '' { //fprintf(stdout, "/*hack1*/"); }; P = '' { //fprintf(stdout, "/*hack2*/"); }; P = '[' ']' ; P = '[' ']' , ; P = , ; P = , # (hmmm.... includes 'void') , , "typeof" '(' ')', "typeof" '(' ')', "void"; P = , ; P = "const", "volatile"; # The C standard suggests we could put "typedef" in here and use # variable declaration syntax in place of typedef declarations... # note that "register fred" should be equivalent to "register int fred" # but does not parse because does not have a null option. # rules that parse a non-null in phrases # that include ' ' should allow a null # and default the declaration to "int". This code does not # implement that option and rejects those declarations. It can be # done by using a rule to detect the presence of one of these # keywords, and a guard in P before the null phrase. P = "auto", "register", "static", "extern", ; P = ; P = ',' , ; P = ';', ; P = ; P = , ; P = '(' '*' ')', ; P = '(' ')'; P = ',' , ; P = , '(' ')' ';' ; P = '{' '}', '{' '}' { //fprintf(stdout, "\n"); }; # Actually I don't think declarations inside a block are allowed # to be preceded by labels. # So the three lines below (which are in P) probably should # be separated out and put in below separately from the # options which can have in front of them. # # , # , # ; # Also still to add are label declarations (inside blocks): # P = # "__label__" ';'; # (I'm not sure if "label" as a keyword is valid too, or does it have to be #define'd as __label__ ? P = ; P = , ; # added as a test: , P = ';', , , , , ';', , , ; # WAS: ; P = , ; P = "struct" '{' '}'; P = # what about the ';'s between members? , ; P = , , ; P = ';'; P = ; P = ';'; P = ',' , ; P = ; P = ; P = ',' , ; P = , ; # 'HACK' is a test of marking contents of [] expressions so they can be re-written to # use a different base given in a macro definition, to support Imp's multi-dimensional arrays. P = '[' ']' ; P = '[' ']' , ; P = "goto"