--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/agcl/parsifal/cpp.syn	Sat Dec 22 17:52:45 2007 -0500
@@ -0,0 +1,1351 @@
+/*
+ * AnaGram, A System for Syntax Directed Programming
+ * Copyright 1993-2002 Parsifal Software. All Rights Reserved.
+ * See the file COPYING for license and usage terms.
+ */
+{
+//  class AstNode;
+
+  #include "cppdefs.h"
+  #include "agstk.h"
+  #include <stdio.h>
+  #include "mpp.h"
+
+  extern int columnNumber;
+
+  #define INPUT_CODE(t) inputCode(t)
+
+#ifndef SYNTAX_ERROR
+#define SYNTAX_ERROR printf("%s\n", (PCB).error_message)
+#endif
+
+
+  parse_pcb_type *pcbPointer = 0;
+  #define PCB (*pcbPointer)
+
+  extern char *inputName[];
+  InputToken *trackPointer;
+
+  int inputCode(const InputToken &t) {
+    int code = t.code;
+    if (code == IDENTIFIER) code = getTokenType(t.handle);
+    PCB.column = t.column;
+    if (PCB.pointer == trackPointer) return code;
+    trackPointer = PCB.pointer;
+    if (code == LINE) printf("[%02d] %s(%d): %d\n", scopeStack.size(), inputName[code], code, t.handle);
+    else printf("[%02d] %s(%d): %s\n", scopeStack.size(), inputName[code], code, td[t.handle]);
+    return code;
+  }
+
+  AgStack<ParserState> stateStack;
+
+  #include "cpp.h"
+}
+[
+  pointer input
+  pointer type = InputToken *
+  default Input type = InputToken
+  //default token type = AstNode *
+  context type = ParserState
+  input values
+  ~declare PCB
+  ~lines and columns
+  parser name = parse
+  parser file name = "#.cpp"
+  line numbers
+  disregard line number
+  error trace
+  ~allow macros
+  sticky {
+    statement,                // resolve if/else conflict
+    type specifier seq,       // conflict between * as dereference and as multiply
+    ptr operator,             // conflict between * as dereference and as multiply
+    class name,               // qualifying :: on type and global :: on declarator
+    IDENTIFIER,               // Resolves ctor/bitfield conflict
+    explicitly typed identifier,
+    nested name specifier,
+    NEW,
+    DELETE
+  }
+  enum {                               // See TOKEN.H
+    eof               =0,
+    SPACE             =' ',
+    AND               ='A', // "&&"
+    ADD_EQ,                 // "+="
+    AND_EQ,                 // "&="
+    ARROW,                  // "->"
+    CONCAT,                 // "##"
+    DECR,                   // "--"
+    DIV_EQ,                 // "/="
+    ELLIPSIS,               // "..."
+    EQ,                     // "=="
+    GE,                     // ">="
+    INCR,                   // "++"
+    LE,                     // "<="
+    LS,                     // "<<"
+    LS_EQ,                  // "<<="
+    MOD_EQ,                 // "%="
+    MULT_EQ,                // "*="
+    NE,                     // "!="
+    OR,                     // "||"
+    OR_EQ,                  // "|="
+    RS,                     // ">>"
+    RS_EQ,                  // ">>="
+    SUB_EQ,                 // "-="
+    XOR_EQ,                 // "^="
+    CHARACTERconstant,      // character constant
+    STRINGliteral,          // character string
+    DOT_STAR = 'a',
+    ARROW_STAR,
+    QUAL,
+    LINE,
+    IDENTIFIER = 129,
+    CLASS_NAME,
+    ENUM_NAME,
+    TYPEDEF_NAME,
+    TEMPLATE_NAME,
+    NAMESPACE_NAME,
+    NAMESPACE_ALIAS,
+    UNSIGNEDqualifier,
+    LONGqualifier,
+    FLOATqualifier,
+    HEXconstant,
+    OCTconstant,
+    DECconstant,
+    FLOATconstant,          // real
+    AUTO,                   // "auto"
+    BREAK,                  // "break"
+    CASE,                   // "case"
+    CHAR,                   // "char"
+    CONSTANT,               // "const"
+    CONTINUE,               // "continue"
+    DEFAULT,                // "default"
+    DO,                     // "do"
+    DOUBLE,                 // "double"
+    ELSE,                   // "else"
+    ENUM,                   // "enum"
+    EXTERN,                 // "extern"
+    FLOAT,                  // "float"
+    FOR,                    // "for"
+    GOTO,                   // "goto"
+    IF,                     // "if"
+    INT,                    // "int"
+    LONG,                   // "long"
+    REGISTER,               // "register"
+    RETURN,                 // "return"
+    SHORT,                  // "short"
+    SIGNED,                 // "signed"
+    SIZEOF,                 // "sizeof"
+    STATIC,                 // "static"
+    STRUCT,                 // "struct"
+    SWITCH,                 // "switch"
+    TYPEDEF,                // "typedef"
+    UNION,                  // "union"
+    UNSIGNED,               // "unsigned"
+    VOID,                   // "void"
+    VOLATILE,               // "volatile"
+    WHILE,                  // "while"
+    ASM,
+    BITAND,
+    BITOR,
+    BOOL,
+    CATCH,
+    CLASS,
+    COMPL,
+    CONST_CAST,
+    DELETE,
+    DYNAMIC_CAST,
+    EXPLICIT,
+    EXPORT,
+    FALSE,
+    FRIEND,
+    INLINE,
+    MUTABLE,
+    NAMESPACE,
+    NEW,
+    NOT,
+    NOT_EQ,
+    OPERATOR,
+    PRIVATE,
+    PROTECTED,
+    PUBLIC,
+    REINTERPRET_CAST,
+    STATIC_CAST,
+    TEMPLATE,
+    THIS,
+    THROW,
+    TRUE,
+    TRY,
+    TYPEID,
+    TYPENAME,
+    USING,
+    VIRTUAL,
+    WCHAR_T,
+    CDECL,
+    PASCAL,
+    RTLENTRY,
+    NEAR,
+    FAR,
+    UNRECOGNIZED
+  }
+]
+
+(void) line number
+ -> LINE:x                          =PCB.line = x.handle;
+ -> CDECL + PASCAL +RTLENTRY + NEAR + FAR           //hack to skip non ANSI stuff
+
+skip = LINE + CDECL + PASCAL + RTLENTRY + NEAR + FAR
+
+translation unit $
+ -> declaration list, eof                              // 3.5
+
+literal
+ -> HEXconstant
+ -> OCTconstant
+ -> DECconstant
+ -> FLOATconstant
+ -> CHARACTERconstant
+ -> STRINGliteral...                    //Concatenate adjacent strings
+
+(TypeDefinition) class name
+ -> CLASS_NAME:n                    =TypeDefinition(n);
+// -> TYPEDEF_NAME
+ -> template id:n                   =TypeDefinition(n);
+
+// 5.1
+primary expression
+ -> literal
+ -> THIS
+ -> QUAL, IDENTIFIER
+ -> QUAL, operator function id
+ -> qualified id
+ -> '(', expression hack 1, ')'
+ -> unqualified id
+
+id expression
+ -> unqualified id
+ -> qualified id
+
+unqualified id
+ -> IDENTIFIER:n                        ={
+      TypeDefinition d(n);
+      if (typedefFlag) {
+        d.tokenType = TYPEDEF_NAME;
+        typedefFlag = 0;
+      }
+      scopeStack.top()->addIdentifier(d);
+    }
+ -> operator function id
+ -> conversion function id
+
+(Scope *) qualified id
+ -> nested name specifier:s, QUAL, unqualified id        =s;
+ -> nested name specifier:s, QUAL, TEMPLATE, unqualified id    =s;
+
+(Scope *) nested name specifier
+ -> class name:n                                  =n.scope;
+ -> namespace name:n                              =n.scope;
+ -> QUAL, class name:n                            = scopeStack[0]->getNestedScope(n.handle);
+ -> QUAL, namespace name:n                        = scopeStack[0]->getNestedScope(n.handle);
+ -> nested name specifier:s, QUAL, class name:n   = (s == 0) ? 0 : s->getNestedScope(n.handle);
+ -> nested name specifier:s, QUAL, namespace name:n   =(s == 0) ? 0 : s->getNestedScope(n.handle);
+
+//5.2
+
+postfix expression
+ -> primary expression
+ -> postfix expression, '[', expression, ']'
+ -> postfix expression, '(', expression list?, ')'
+ -> simple type specifier, '(', expression list?, ')'
+ -> postfix expression, '.', id expression
+ -> postfix expression, '.', TEMPLATE, id expression
+ -> postfix expression, ARROW, id expression
+ -> postfix expression, ARROW, TEMPLATE, id expression
+ -> postfix expression, '.', pseudo destructor name
+ -> postfix expression, ARROW, pseudo destructor name
+ -> postfix expression, INCR
+ -> postfix expression, DECR
+ -> DYNAMIC_CAST, '<', type id, '>', '(', expression, ')'
+ -> STATIC_CAST, '<', type id, '>', '(', expression, ')'
+ -> REINTERPRET_CAST, '<', type id, '>', '(', expression, ')'
+ -> CONST_CAST, '<', type id, '>', '(', expression, ')'
+ -> TYPEID, '(', expression hack 1, ')'
+ -> TYPEID, '(', type id, ')'
+
+expression list
+ -> assignment expression
+ -> expression list, ',', assignment expression
+
+pseudo destructor name
+ -> nonclass type name, QUAL, '~', nonclass type name
+ -> nested name specifier, QUAL, nonclass type name, QUAL, '~', nonclass type name
+ -> QUAL, nonclass type name, QUAL, '~', nonclass type name
+ -> '~', nonclass type name
+ -> nested name specifier, QUAL, '~', nonclass type name
+ -> QUAL, '~', nonclass type name
+
+// 5.3
+
+unary expression
+ -> postfix expression
+ -> INCR, cast expression
+ -> DECR, cast expression
+ -> unary operator, cast expression
+ -> SIZEOF, unary expression
+ -> SIZEOF, '(', type id, ')'
+ -> new expression
+ -> delete expression
+
+unary operator
+ -> '&' | '*' | '+' | '-' | '~' | '!'
+
+new expression
+ ->  new, new type id, new initializer?
+ ->  new, new placement, new type id, new initializer?
+ ->  new, '(', type id, ')', new initializer?
+ ->  new, new placement, '(', type id, ')', new initializer?
+
+new
+ -> NEW
+ -> QUAL, NEW
+
+new placement
+ -> '(', expression list hack 2, ')'
+
+expression list hack 2
+ -> retry, expression list
+ -> retry, retry, resynch      =diagnose("expression list hack 2");
+
+new type id
+ -> type specifier seq
+ -> type specifier seq, new declarator
+
+new declarator
+ -> ptr operator
+ -> ptr operator, new declarator
+ -> direct new declarator
+
+direct new declarator
+ -> '[', expression, ']'
+ -> direct new declarator, '[', constant expression, ']'
+
+new initializer
+ -> '(', expression list?, ')'
+
+delete expression
+ -> delete, cast expression
+ -> delete, '[', ']', cast expression
+
+delete
+ -> DELETE
+ -> QUAL, DELETE
+
+cast expression
+ -> unary expression
+ -> '(', type id, ')', cast expression
+
+expression hack 1
+ -> retry, expression
+ -> retry, error, resynch       =diagnose("expression hack 1");
+
+restricted assignment expression hack 5
+ -> retry, restricted assignment expression
+ -> retry, error, resynch       =diagnose("expression hack 1");
+
+pm expression
+ -> cast expression
+ -> pm expression, DOT_STAR, cast expression
+ -> pm expression, ARROW_STAR, cast expression
+
+multiplicative expression
+ -> pm expression
+ -> multiplicative expression, '*', pm expression
+ -> multiplicative expression, '/', pm expression
+ -> multiplicative expression, '%', pm expression
+
+additive expression
+ -> multiplicative expression
+ -> additive expression, '+', multiplicative expression
+ -> additive expression, '-', multiplicative expression
+
+shift expression
+ -> additive expression
+ -> shift expression, LS, additive expression
+ -> shift expression, RS, additive expression
+
+relational expression
+ -> shift expression
+ -> relational expression, '<', shift expression
+ -> relational expression, '>', shift expression
+ -> relational expression, LE, shift expression
+ -> relational expression, GE, shift expression
+
+equality expression
+ -> relational expression
+ -> equality expression, EQ, relational expression
+ -> equality expression, NE, relational expression
+
+and expression
+ -> equality expression
+ -> and expression, '&', equality expression
+
+exclusive or expression
+ -> and expression
+ -> exclusive or expression, '^', and expression
+
+inclusive or expression
+ -> exclusive or expression
+ -> inclusive or expression, '|', exclusive or expression
+
+logical and expression
+ -> inclusive or expression
+ -> logical and expression, AND, inclusive or expression
+
+logical or expression
+ -> logical and expression
+ -> logical or expression, OR, logical and expression
+
+conditional expression
+ -> logical or expression
+ -> logical or expression, '?', expression, ':', conditional expression
+
+assignment expression
+ -> conditional expression
+ -> logical or expression, assignment operator, assignment expression
+ -> throw expression
+
+assignment operator
+ -> '=' | MULT_EQ | DIV_EQ | MOD_EQ | ADD_EQ | SUB_EQ
+ -> LS_EQ | RS_EQ | AND_EQ | OR_EQ | XOR_EQ
+
+expression
+ -> assignment expression
+ -> expression, ',', assignment expression
+
+constant expression
+ -> conditional expression
+
+statement
+ -> labeled statement
+ -> compound statement
+ -> selection statement
+ -> iteration statement
+ -> jump statement
+ -> try block
+ -> block declaration
+ -> variable declaration
+ -> function definition 2
+ -> retry, statement try 2
+
+statement try 2
+ -> type qualifier?, declarator list, ';'
+ -> function definition 1
+ -> retry, statement try 3
+
+statement try 3
+ -> expression statement
+ -> retry, resynch             =diagnose("statement try 3");
+
+labeled statement
+ -> IDENTIFIER, ':', statement
+ -> CASE, constant expression, ':', statement
+ -> DEFAULT, ':', statement
+
+expression statement
+ -> expression, ';'
+
+compound statement
+ -> begin block , statement seq?, '}'  =restoreScope();
+
+begin block
+ -> '{'                                =nestScope();
+
+statement seq
+ -> statement
+ -> statement seq, statement
+
+selection statement
+ -> IF, '(', condition, ')', statement
+ -> IF, '(', condition, ')', statement, ELSE, statement
+ -> SWITCH, '(', condition, ')', statement
+
+condition
+ -> condition kernel
+
+condition kernel
+ -> type specifier seq, declarator, '=', assignment expression
+ -> retry, condition kernel 2
+
+condition kernel 2
+ -> expression
+ -> retry, resynch    =diagnose("condition kernel 2");
+
+
+iteration statement
+ -> WHILE, '(', condition, ')', statement
+ -> DO, statement, WHILE, '(', condition, ')', ';'
+ -> for header, for init statement?, ';', condition?, ';', expression?, ')', statement =restoreScope();
+
+for header
+ -> FOR, '('       =nestScope();
+
+for init statement
+ -> for init
+
+
+for init
+ -> for variable declaration
+ -> retry, for init 2
+
+for variable declaration
+ -> decl specifier seq
+ -> decl specifier seq, init declarator list
+
+for init 2
+ -> expression
+ -> retry, resynch    =diagnose("for init 2");
+
+jump statement
+ -> BREAK, ';'
+ -> CONTINUE, ';'
+ -> RETURN, expression?, ';'
+ -> GOTO, IDENTIFIER, ';'
+
+(int) declaration seq
+ ->                                               =0;
+ -> declaration seq, declaration hack
+
+declaration list
+ -> declaration seq
+
+declaration hack
+ -> declaration =printf("declaration hack complete\n");
+
+declaration
+ -> block declaration
+ -> simple declaration
+ //-> template declaration
+ -> explicit instantiation
+ -> explicit specialization
+ -> linkage specification
+ -> namespace definition
+
+block declaration
+ -> asm definition
+ -> namespace alias definition
+ -> using declaration
+ -> using directive
+
+(void) retry
+ -> error                =CONTEXT.restore();
+
+simple declaration
+ -> variable declaration         =printf("variable declaration\n");
+ -> template header, variable declaration         =printf("variable declaration\n"), restoreScope();
+ -> EXPORT, template header, variable declaration         =printf("variable declaration\n"), restoreScope();
+ -> function definition 2        =printf("function definition 2\n");
+ -> template header, function definition 2        =printf("function definition 2\n"), restoreScope();
+ -> EXPORT, template header, function definition 2        =printf("function definition 2\n"), restoreScope();
+ -> retry, attempt declarator list
+
+attempt declarator list
+ -> type qualifier?, declarator list, ';'         =printf("declarator list\n");
+ -> template header, type qualifier?, declarator list, ';'         =printf("declarator list\n"), restoreScope();
+ -> function definition 1        =printf("function definition 1\n");
+ -> retry, resynch =diagnose("attempt declarator list");
+
+resynch
+ -> resynch text, ';'
+ -> resynch text, balanced braces
+ -> resynch text, eof             =PCB.pointer--;
+
+resynch text
+// -> resynch item
+ ->
+ -> resynch text, resynch item
+
+resynch item
+ -> ~(eof + skip + '(' + ')' + '[' + ']' + '{' + '}' + ';')
+ -> balanced parens
+ -> balanced brackets
+
+(void) balanced parens
+ -> '(', not right paren, ')'
+
+(void) balanced brackets
+ -> '[', not right bracket, ']'
+
+(void) balanced braces
+ -> '{', not right brace, '}'
+
+not right paren
+ ->
+ -> not right paren, resynch item
+ -> not right paren, ';' + ']' + '}'
+ -> not right paren, balanced braces
+
+not right bracket
+ ->
+ -> not right bracket, resynch item
+ -> not right bracket, ';' + ')' + '}'
+ -> not right bracket, balanced braces
+
+not right brace
+ ->
+ -> not right brace, resynch item
+ -> not right brace, ';' + ')' + ']'
+ -> not right brace, balanced braces
+
+variable declaration
+ -> decl specifier seq?, ';'
+ -> decl specifier seq, init declarator list, ';'
+
+/*
+ If there are no decl specifiers, then the declarator must be a constructor,
+ destructor, or type conversion operator. In this case, there can be no
+ initialization, so we use a declarator list instead of an init declarator list
+*/
+
+declarator list
+ -> declarator
+ -> declarator list, ',', declarator
+
+
+decl specifier seq
+ -> fundamental type
+ -> fundamental type, predefined specifier...
+ -> type qualifier..., fundamental type, predefined specifier?...
+ -> user defined specifier, type qualifier?...
+ -> type qualifier..., user defined specifier, type qualifier?...
+
+restricted decl specifier seq
+ -> fundamental type
+ -> fundamental type, predefined specifier...
+ -> type qualifier..., fundamental type, predefined specifier?...
+ -> restricted specifier, type qualifier?...
+ -> type qualifier..., restricted specifier, type qualifier?...
+
+restricted specifier
+ -> qualified type name
+
+storage class specifier
+ -> AUTO
+ -> REGISTER
+ -> STATIC
+ -> EXTERN
+ -> MUTABLE
+
+function specifier
+ -> INLINE
+ -> VIRTUAL
+ -> EXPLICIT
+
+simple type specifier
+ -> qualified type name
+ -> fundamental type
+
+
+predefined specifier
+ -> type qualifier
+ -> fundamental type
+
+type qualifier
+ -> storage class specifier
+ -> function specifier
+ -> FRIEND
+ -> TYPEDEF                             =typedefFlag = 1;
+ -> cv qualifier
+
+fundamental type
+ -> CHAR
+ -> WCHAR_T
+ -> BOOL
+ -> SHORT
+ -> INT
+ -> LONG
+ -> SIGNED
+ -> UNSIGNED
+ -> FLOAT
+ -> DOUBLE
+ -> VOID
+
+user defined specifier
+ -> class specifier
+ -> enum specifier
+ -> elaborated type specifier
+ -> qualified type name
+
+user type specifier
+ -> elaborated type specifier
+ -> qualified type name
+
+qualified type name
+ -> ENUM_NAME
+ -> TYPEDEF_NAME
+ -> nested name specifier
+ -> nested name specifier, QUAL, ENUM_NAME
+ -> nested name specifier, QUAL, TYPEDEF_NAME
+
+nonclass type name
+ -> ENUM_NAME
+ -> TYPEDEF_NAME
+
+elaborated type specifier
+ -> class key, IDENTIFIER:n   ={
+      TypeDefinition d(n);
+      if (templateFlag) {
+        d.tokenType = TEMPLATE_NAME;
+        scopeStack[scopeStack.size() - 2]->addIdentifier(d);
+      }
+      else {
+        d.tokenType = CLASS_NAME;
+        scopeStack.top()->addIdentifier(d);
+      }
+    }
+ -> class key, class name:d   ={
+      if (templateFlag) {
+        d.tokenType = TEMPLATE_NAME;
+        scopeStack[scopeStack.size() - 2]->addIdentifier(d);
+      }
+      else {
+        d.tokenType = CLASS_NAME;
+        scopeStack.top()->addIdentifier(d);
+      }
+    }
+ -> class key, name qualifier:scope, IDENTIFIER:n ={
+      TypeDefinition d(n);
+      d.tokenType = templateFlag ? TEMPLATE_NAME : CLASS_NAME;
+      scope->addIdentifier(d);
+    }
+ -> class key, name qualifier:scope, class name:d    ={
+      d.tokenType = templateFlag ? TEMPLATE_NAME : CLASS_NAME;
+      scope->addIdentifier(d);
+    }
+ -> ENUM, IDENTIFIER
+ -> ENUM, name qualifier, IDENTIFIER
+ -> explicitly typed identifier
+ -> explicitly typed identifier, '<', template argument list, '>'
+
+explicitly typed identifier
+ -> TYPENAME, nested name specifier, QUAL, IDENTIFIER
+
+enum specifier
+ -> ENUM, '{', enumerator list?, '}'
+ -> ENUM, IDENTIFIER:n, '{', enumerator list?, '}' ={
+      TypeDefinition d(n);
+      d.tokenType = ENUM_NAME;
+      scopeStack.top()->addIdentifier(d);
+    }
+
+enumerator list
+ -> enumerator definition
+ -> enumerator list, ',', enumerator definition
+
+enumerator definition
+ -> IDENTIFIER
+ -> IDENTIFIER, '=', constant expression
+
+(TypeDefinition) namespace name
+ -> NAMESPACE_NAME:n          =TypeDefinition(n);
+ -> NAMESPACE_ALIAS:n         =TypeDefinition(n);
+
+namespace definition
+ -> named namespace definition
+ -> unnamed namespace definition
+
+named namespace definition
+ -> original namespace definition
+ -> extension namespace definition
+
+original namespace definition
+ -> NAMESPACE, IDENTIFIER, '{', namespace body, '}'
+
+extension namespace definition
+ -> NAMESPACE, NAMESPACE_NAME, '{', namespace body, '}'
+
+unnamed namespace definition
+ -> NAMESPACE, '{', namespace body, '}'
+
+namespace body
+ -> declaration seq
+
+namespace alias definition
+ -> NAMESPACE, IDENTIFIER, '=', qualified namespace specifier, ';'
+
+qualified namespace specifier
+ -> name qualifier, namespace name
+
+using declaration
+ -> USING, nested name specifier, QUAL, unqualified id, ';'
+ -> USING, TYPENAME, nested name specifier, QUAL, unqualified id, ';'
+ -> USING, QUAL, unqualified id, ';'
+
+using directive
+ -> USING, NAMESPACE, namespace name, ';'
+ -> USING, NAMESPACE, name qualifier, namespace name, ';'
+
+(Scope *) name qualifier
+ -> QUAL                                         =scopeStack[0];
+ -> class name:n, QUAL                           =getNestedScope(n.handle);
+ -> namespace name:n, QUAL                       =getNestedScope(n.handle);
+ -> name qualifier:s, class name:n, QUAL              =s->getNestedScope(n.handle);
+ -> name qualifier:s, namespace name:n, QUAL          =(s == 0) ? 0 : s->getNestedScope(n.handle);
+
+asm definition
+ -> ASM, '(', STRINGliteral, ')', ';'
+
+linkage specification
+ -> EXTERN, STRINGliteral, '{', declaration list, '}'
+ -> EXTERN, STRINGliteral, declaration
+
+init declarator list
+ -> init declarator
+ -> init declarator list, ',', init declarator
+
+init declarator
+ -> direct declarator
+ -> direct declarator, initializer
+ -> ptr operator, init declarator
+
+(Scope *) declarator
+ -> direct declarator:s             =s;
+ -> ptr operator, declarator:s      =s;
+
+(Scope *) direct declarator
+ -> declarator id:s  =s;
+ -> direct declarator:s, '(', parameter declaration clause hack 4, ')', cv qualifier seq?, exception specification? =s;
+ -> direct declarator:s, '[', constant expression?, ']' =s;
+ -> '(', declarator:s, ')'                              =s;
+
+declarator hack
+ -> direct declarator hack
+ -> ptr operator, declarator hack
+
+direct declarator hack
+ -> declarator id
+ -> direct declarator hack, '(', parameter declaration clause hack 4, ')', cv qualifier seq?, exception specification?
+ -> direct declarator hack, '[', constant expression?, ']'
+ -> '(', declarator hack 3, ')'
+
+ptr operator
+ -> '*', cv qualifier seq?
+ -> '&'
+ -> nested name specifier, QUAL, '*', cv qualifier seq?
+
+cv qualifier seq
+ -> cv qualifier, cv qualifier seq?
+
+cv qualifier
+ -> CONSTANT
+ -> VOLATILE
+
+(Scope *) declarator id
+ -> unqualified id                      =new Scope;
+ -> nested name specifier:s, QUAL, unqualified id        =s;
+ -> nested name specifier:s, QUAL, CLASS_NAME             =s;
+ -> nested name specifier:s, QUAL, '~', CLASS_NAME             =s;
+ -> nested name specifier:s, QUAL, TEMPLATE_NAME      =s;
+ -> nested name specifier:s, QUAL, '~', TEMPLATE_NAME      =s;
+ -> CLASS_NAME:n                        ={
+      TypeDefinition d(n);
+      if (typedefFlag) {
+        d.tokenType = TYPEDEF_NAME;
+        typedefFlag = 0;
+        scopeStack.top()->addIdentifier(d);
+      }
+      return new Scope;
+    }
+ -> TEMPLATE_NAME:n                        ={
+      TypeDefinition d(n);
+      if (typedefFlag) {
+        d.tokenType = TYPEDEF_NAME;
+        typedefFlag = 0;
+        scopeStack.top()->addIdentifier(d);
+      }
+      return new Scope;
+    }
+ -> '~',  CLASS_NAME:n     =TypeDefinition(n).scope;        // '~' is a unary operator
+ -> '~',  TEMPLATE_NAME:n  =TypeDefinition(n).scope;          // '~' is a unary operator
+
+type id
+ -> type specifier seq, abstract declarator?
+
+type specifier seq
+ -> fundamental type
+ -> fundamental type, predefined specifier...
+ -> cv qualifier..., fundamental type
+ -> cv qualifier..., fundamental type, predefined specifier...
+ -> user type specifier, cv qualifier?...
+ -> cv qualifier..., user type specifier, cv qualifier?...
+
+
+abstract declarator hack
+ -> ptr operator, abstract declarator hack?
+ -> direct abstract declarator hack
+
+direct abstract declarator hack
+ -> '(', ')', cv qualifier seq?, exception specification?
+ -> '(', parameter declaration clause hack 3, ')', cv qualifier seq?, exception specification?
+ -> '[', constant expression?, ']'
+ -> '(', /* hack 3 */ abstract declarator, ')'
+ -> direct abstract declarator hack, '(', parameter declaration clause?, ')', cv qualifier seq?, exception specification?
+ -> direct abstract declarator hack, '[', constant expression?, ']'
+
+abstract declarator
+ -> ptr operator, abstract declarator?
+ -> direct abstract declarator
+
+direct abstract declarator
+ -> '(', ')', cv qualifier seq?, exception specification?
+ -> '(', parameter declaration clause, ')', cv qualifier seq?, exception specification?
+ -> '[', constant expression?, ']'
+ -> '(', abstract declarator, ')'
+ -> direct abstract declarator, '(', parameter declaration clause?, ')', cv qualifier seq?, exception specification?
+ -> direct abstract declarator, '[', constant expression?, ']'
+
+parameter declaration clause
+ -> parameter declaration list
+ -> ELLIPSIS
+ -> parameter declaration list, ELLIPSIS
+ -> parameter declaration list, ',', ELLIPSIS
+
+parameter declaration list
+ -> parameter declaration
+ -> parameter declaration list, ',', parameter declaration
+
+parameter declaration
+ -> decl specifier seq, declarator hack
+ -> decl specifier seq, declarator hack, '=', assignment expression
+ -> decl specifier seq, abstract declarator hack?
+ -> decl specifier seq, abstract declarator hack?, '=', assignment expression
+
+parameter declaration clause hack 3
+ -> parameter declaration clause
+
+declarator hack 3
+ -> retry, declarator
+ -> retry, error, ~eof, resynch  =diagnose("declarator hack 3");
+
+parameter declaration clause hack 4
+ -> parameter declaration clause?
+
+expression list hack 4
+ -> retry, expression list
+ -> retry, error, ~(eof + skip + ')')?...  =diagnose("expression list hack 4");
+
+function definition 1
+ -> constructor identifier, ctor initializer?, function body  ={if (templateFlag) restoreScope();}
+ -> constructor identifier, constructor try block             ={if (templateFlag) restoreScope();}
+
+constructor try block
+ -> TRY, ctor initializer?, function body, handler seq
+
+constructor identifier
+ -> type qualifier?, declarator:s                         =nestScope(s);
+ -> template header, type qualifier?, declarator:s        =nestScope(s);
+ -> EXPORT, template header, type qualifier?, declarator:s        =nestScope(s);
+
+function definition 2
+ -> function identifier, function body
+ -> function identifier, function try block
+
+function identifier
+ -> decl specifier seq, declarator:s                         =nestScope(s);
+
+function body
+ -> '{', statement seq?, '}'          =restoreScope();
+
+function try block
+ -> TRY, function body, handler seq
+
+
+initializer
+ -> '=', initializer clause
+ -> '(', expression list hack 4, ')'
+
+initializer clause
+ -> assignment expression
+ -> '{', initializer list, ','?, '}'
+ -> '{', '}'
+
+initializer list
+ -> initializer clause
+ -> initializer list, ',', initializer clause
+
+class specifier
+ -> class head, '{', member specification?, '}'                    =restoreScope();
+ -> class head, ':', base clause, '{', member specification?, '}'  =restoreScope();
+
+specifier lookahead
+ -> '{'+ ':'                   =CONTEXT.restore();
+
+class head
+ -> class key, specifier lookahead              ={
+      nestScope();
+    }
+ -> class key, IDENTIFIER:n, specifier lookahead   ={
+      TypeDefinition d(n);
+      int flag = templateFlag;
+      d.scope = nestScope(d.handle);
+      if (flag) {
+        d.tokenType = TEMPLATE_NAME;
+        scopeStack[scopeStack.size() - 3]->addIdentifier(d);
+      }
+      else {
+        d.tokenType = CLASS_NAME;
+        scopeStack[scopeStack.size() - 2]->addIdentifier(d);
+      }
+    }
+ -> class key, class name:d, specifier lookahead      ={
+      d.tokenType = templateFlag? TEMPLATE_NAME : CLASS_NAME;
+      int flag = templateFlag;
+      d.scope = nestScope(d.handle);
+      if (flag) scopeStack[scopeStack.size() - 3]->addIdentifier(d);
+      else scopeStack[scopeStack.size() - 2]->addIdentifier(d);
+    }
+ -> class key, TEMPLATE_NAME:n, specifier lookahead      ={
+      TypeDefinition d(n);
+      d.tokenType = templateFlag? TEMPLATE_NAME : CLASS_NAME;
+      int flag = templateFlag;
+      d.scope = nestScope(d.handle);
+      if (flag) scopeStack[scopeStack.size() - 3]->addIdentifier(d);
+      else scopeStack[scopeStack.size() - 2]->addIdentifier(d);
+    }
+ -> class key, name qualifier:s, IDENTIFIER:n, specifier lookahead  ={
+      if (s != 0) s->nest(new Scope(n.handle));
+    }
+ -> class key, name qualifier:s, TEMPLATE, template id:h, specifier lookahead   ={
+      if (s != 0) s->nest(new Scope(h.handle));
+    }
+
+class key
+ -> CLASS
+ -> STRUCT
+ -> UNION
+
+member specification
+ -> member declaration hack
+ -> member specification, member declaration hack
+
+
+member declaration hack
+ -> member declaration
+ -> member restore, type qualifier?, member declarator list, ';'
+ -> member restore, function definition 1
+ -> member restore, error, resynch =diagnose("member specification");
+
+member restore
+ -> retry  =printf("try member declarator list\n");
+
+member declaration
+ -> ';'
+ -> decl specifier seq, member declarator list?, ';'
+ -> function definition 2
+ -> using declaration
+// -> template declaration
+ -> access specifier, ':'
+
+member declarator list
+ -> member declarator
+ -> member declarator list, ',', member declarator
+
+member declarator
+ -> declarator
+ -> declarator, pure specifier
+ -> declarator, constant intializer
+ -> ':', constant expression
+ -> IDENTIFIER, ':', constant expression
+
+pure specifier
+ -> '=', '0'
+
+constant intializer
+ -> '=', constant expression
+
+base clause
+ -> base specifier list
+
+base specifier list
+ -> base specifier:s                           =scopeStack.top()->addBase(s);
+ -> base specifier list, ',', base specifier:s =scopeStack.top()->addBase(s);
+
+(Scope *) base specifier
+ -> CLASS_NAME:n                                            =getNestedScope(n.handle);
+ -> TEMPLATE_NAME:n                                            =getNestedScope(n.handle);
+ -> qualified class name:s                                  =s;
+ -> VIRTUAL, access specifier?, qualified class name:s      =s;
+ -> access specifier, VIRTUAL?, qualified class name:s       =s;
+ -> access specifier, VIRTUAL?, CLASS_NAME:n                 =getNestedScope(n.handle);
+ -> access specifier, VIRTUAL?, TEMPLATE_NAME:n                 =getNestedScope(n.handle);
+
+(Scope *) qualified class name
+ -> name qualifier:s, class name:n          =(s == 0) ? 0 : s->getNestedScope(n.handle);
+
+access specifier
+ -> PRIVATE
+ -> PROTECTED
+ -> PUBLIC
+
+conversion function id
+ -> OPERATOR, conversion type id
+
+conversion type id
+ -> type specifier seq, conversion declarator?
+
+conversion declarator
+ -> ptr operator, conversion declarator?
+
+ctor initializer
+ -> ':', mem initializer list
+
+mem initializer list
+ -> mem initializer
+ -> mem initializer list, ',', mem initializer
+
+mem initializer
+ -> mem initializer id, '(', expression list?,  ')'
+
+mem initializer id
+ -> qualified class name
+ -> class name
+ -> IDENTIFIER
+
+operator function id
+ -> OPERATOR, operator
+
+operator
+ -> NEW
+ -> DELETE
+ -> NEW, '[', ']'
+ -> DELETE, '[', ']'
+ -> '+'                  // =PLUS_OP;
+ -> '-'                  // =MINUS_OP;
+ -> '*'                  // =MUL_OP;
+ -> '/'                  // =DIV_OP;
+ -> '%'                  // =MOD_OP;
+ -> '^'                  // =XOR_OP;
+ -> '&'                  // =AND_OP;
+ -> '|'                  // =OR_OP;
+ -> '~'                  // =COM_OP;
+ -> '!'                  // =NOT_OP;
+ -> '='                  // =ASSIGN_OP;
+ -> '<'                  // =LT_OP;
+ -> '>'                  // =GT_OP;
+ -> MULT_EQ
+ -> DIV_EQ
+ -> MOD_EQ
+ -> ADD_EQ
+ -> SUB_EQ
+ -> LS_EQ
+ -> RS_EQ
+ -> AND_EQ
+ -> OR_EQ
+ -> XOR_EQ
+ -> LS
+ -> RS
+ -> EQ
+ -> NE
+ -> LE
+ -> GE
+ -> AND
+ -> OR
+ -> INCR
+ -> DECR
+ -> ','
+ -> ARROW_STAR
+ -> ARROW
+ -> '(', ')'             // =PAREN_OP;
+ -> '[', ']'             // =BRACKET_OP;
+
+/*
+template declaration
+ -> template header, declaration                                      =restoreScope();
+ -> EXPORT, template header, declaration                              =restoreScope();
+*/
+
+template header
+ -> TEMPLATE, '<', !nestScope();, template parameter list, '>' =templateFlag = 1;
+
+template parameter list
+ -> template parameter
+ -> template parameter list, ',', template parameter
+
+template parameter
+ -> type parameter
+ -> template parameter declaration
+
+template parameter declaration
+ -> restricted decl specifier seq, declarator hack
+ -> restricted decl specifier seq, declarator hack, '=', restricted assignment expression
+ -> restricted decl specifier seq, abstract declarator hack?
+ -> restricted decl specifier seq, abstract declarator hack?, '=', restricted assignment expression
+
+restricted assignment expression
+ -> restricted conditional expression
+ -> shift expression, assignment operator, restricted assignment expression
+ -> restricted throw expression
+
+restricted conditional expression
+ -> shift expression
+ -> shift expression, '?', shift expression, ':', restricted conditional expression
+
+restricted throw expression
+ -> THROW, restricted assignment expression?
+
+type parameter
+ -> CLASS
+ -> CLASS, IDENTIFIER:n                              =scopeStack.top()->addIdentifier(TypeDefinition(n.handle, CLASS_NAME));
+ -> CLASS, '=', type id
+ -> CLASS, IDENTIFIER, '=', type id
+ -> TYPENAME, IDENTIFIER?
+ -> TYPENAME, IDENTIFIER?, '=', type id
+ -> TEMPLATE, '<', template parameter list, '>', CLASS, IDENTIFIER?
+ -> TEMPLATE, '<', template parameter list, '>', CLASS, IDENTIFIER?, '=', TEMPLATE_NAME
+
+(InputToken) template id
+ -> TEMPLATE_NAME:n, '<', template argument list, '>'   =n;
+
+template argument list
+ -> template argument
+ -> template argument list, ',', template argument
+
+template argument
+ -> restricted assignment expression hack 5
+ -> TEMPLATE_NAME
+ -> type id
+
+explicit instantiation
+ -> TEMPLATE, declaration
+
+explicit specialization
+ -> TEMPLATE, '<', '>', declaration
+
+try block
+ -> TRY, compound statement, handler seq
+
+handler seq
+ -> handler
+ -> handler seq, handler
+
+handler
+ -> CATCH, '(', exception declaration, ')', compound statement
+
+exception declaration
+ -> type specifier seq, declarator hack
+ -> type specifier seq, abstract declarator hack
+ -> type specifier seq
+ -> ELLIPSIS
+
+throw expression
+ -> THROW, assignment expression?
+
+exception specification
+ -> THROW, '(', type id list?, ')'
+
+type id list
+ -> type id
+ -> type id list, ',', type id
+
+{
+
+#include "mpp.h"
+#include "token.h"
+
+#define GET_CONTEXT CONTEXT = ParserState()
+
+int typedefFlag = 0;
+AgStack<int> typedefStack;
+int templateFlag = 0;
+AgStack<int> templateStack;
+
+AgStack<InputToken> tokenStack;
+
+ParserState::ParserState()
+  : pointer(pcbPointer ? pcbPointer->pointer : 0),
+    line(pcbPointer ? pcbPointer->line : 0),
+    scopeStackDepth(scopeStack.size()),
+    typedefStackDepth(typedefStack.size()),
+    nLocalVariables(scopeStackDepth ? scopeStack.top()->nLocals(): 0),
+    templateStackDepth(templateStack.size()),
+    typedefFlag(::typedefFlag),
+    templateFlag(::templateFlag)
+{ }
+
+void ParserState::restore() {
+  PCB.pointer = pointer;
+  PCB.line = line;
+  while (scopeStack.size() > scopeStackDepth) scopeStack.pop();
+  while (typedefStack.size() > typedefStackDepth) typedefStack.pop();
+  while (templateStack.size() > templateStackDepth) templateStack.pop();
+  scopeStack.top()->restoreLocals(nLocalVariables);
+  ::typedefFlag = typedefFlag;
+  ::templateFlag = templateFlag;
+}
+void diagnose(char *msg) {
+  printf("Error: %s\n", msg);
+  PCB.exit_flag = AG_SEMANTIC_ERROR_CODE;
+}
+
+c_parser::c_parser() {
+  pcbPointer = &pcb;
+  //init_parse();                                // init parse
+}
+
+
+// Destructor
+
+c_parser::~c_parser() {
+}
+
+
+// Reset Parser
+
+c_parser &reset(c_parser &c) {
+  return c;
+}
+
+
+// Transmit token to c_parser
+
+/*
+  The overloaded operator "<<" is used to transmit data to a parser.
+  Newline tokens are filtered out, since they are passed along by the
+  token scanner only in case text output of the preprocessor is
+  required.
+
+  If the parser has encountered an error, there is no point in giving
+  it any further input.
+
+  Otherwise, the input_code and input_value fields of the pcb are set
+  up and cc() is called to deal with the token.
+*/
+
+token_sink &c_parser::operator << (InputToken c) {
+  printf("%d\n", c.code);
+  if (c.code == 10) return *this;
+  tokenStack.push(c);
+  if (c.code == END_OF_FILE) {
+    int k = tokenStack.size();
+    int n = k;
+    InputToken *tokenArray = new InputToken[k];
+    while (k--) {
+      tokenStack.pop(tokenArray[k]);
+    }
+    PCB.pointer = tokenArray;
+    trackPointer = tokenArray - 1;
+    PCB.line = 1;
+    scopeStack.push(new Scope);                      // global scope
+    parse();
+  }
+  return *this;
+}
+
+token_sink &c_parser::operator << (InputToken *s) {
+  while (s->code != END_OF_FILE) {
+    if ((int) s->code == 10) continue;
+    tokenStack.push(*s++);
+  }
+  return *this;
+}
+
+}