{/*

    Copyright (C) 1989,1990 James A. Roskind, All rights reserved.

    This grammar was developed  and  written  by  James  A.  Roskind.
    Copying  of  this  grammar  description, as a whole, is permitted
    providing this notice is intact and applicable  in  all  complete
    copies.   Translations as a whole to other parser generator input
    languages  (or  grammar  description  languages)   is   permitted
    provided  that  this  notice is intact and applicable in all such
    copies,  along  with  a  disclaimer  that  the  contents  are   a
    translation.   The reproduction of derived text, such as modified
    versions of this grammar, or the output of parser generators,  is
    permitted,  provided  the  resulting  work includes the copyright
    notice "Portions Copyright (c)  1989,  1990  James  A.  Roskind".
    Derived products, such as compilers, translators, browsers, etc.,
    that  use  this  grammar,  must also provide the notice "Portions
    Copyright  (c)  1989,  1990  James  A.  Roskind"  in   a   manner
    appropriate  to  the  utility,  and in keeping with copyright law
    (e.g.: EITHER displayed when first invoked/executed; OR displayed
    continuously on display terminal; OR via placement in the  object
    code  in  form  readable in a printout, with or near the title of
    the work, or at the end of the file).  No royalties, licenses  or
    commissions  of  any  kind are required to copy this grammar, its
    translations, or derivative products, when the copies are made in
    compliance with this notice. Persons or corporations that do make
    copies in compliance with this notice may charge  whatever  price
    is  agreeable  to  a  buyer, for such copies or derivative works.
    THIS GRAMMAR IS PROVIDED ``AS IS'' AND  WITHOUT  ANY  EXPRESS  OR
    IMPLIED  WARRANTIES,  INCLUDING,  WITHOUT LIMITATION, THE IMPLIED
    WARRANTIES  OF  MERCHANTABILITY  AND  FITNESS  FOR  A  PARTICULAR
    PURPOSE.

    James A. Roskind
    Independent Consultant
    516 Latania Palm Drive
    Indialantic FL, 32903
    (407)729-4348
    jar@ileaf.com
    or ...!uunet!leafusa!jar


 ******************************************************************************

 Translation to AnaGram and Interfacing
 Copyright 1993 Parsifal Software. All rights reserved.

 This software is provided 'as-is', without any express or implied
 warranty.  In no event will the authors be held liable for any damages
 arising from the use of this software.

 Permission is granted to anyone to use this software for any purpose,
 including commercial applications, and to alter it and redistribute it
 freely, subject to the following restrictions:

 1. The origin of this software must not be misrepresented; you must not
    claim that you wrote the original software. If you use this software
    in a product, an acknowledgment in the product documentation would be
    appreciated but is not required.
 2. Altered source versions must be plainly marked as such, and must not be
    misrepresented as being the original software.
 3. This notice may not be removed or altered from any source distribution.

 ******************************************************************************

*/

#include "mpp.h"

}

[
  grammar token = prog start
 ~nest comments
  sticky { statement}                    //Resolves if-then-else conflict
  event driven
  far tables                             // Comment out for 32 bit compilers
 ~allow macros
  input values
  line numbers
  //escape backslashes                   // uncomment if using MSVC++
  error trace
  parser name = cc
  default input type = token
  header file name = "jrc.h"
  parser file name = "jrc.cpp"
 ~test range
  enum {
    eof               =0,
    SPACE             =' ',
    ANDAND            ='A', // "&&"
    ANDassign,              // "&="
    ARROW,                  // "->"
    CONCAT,                 // "##"
    DECR,                   // "--"
    DIVassign,              // "/="
    ELLIPSIS,               // "..."
    EQ,                     // "=="
    ERassign,               // "^="
    GE,                     // ">="
    ICR,                    // "++"
    LE,                     // "<="
    LS,                     // "<<"
    LSassign,               // "<<="
    MODassign,              // "%="
    MINUSassign,            // "-="
    MULTassign,             // "*="
    NE,                     // "!="
    ORassign,               // "|="
    OROR,                   // "||"
    PLUSassign,             // "+="
    RS,                     // ">>"
    RSassign,               // ">>="
    CHARACTERconstant,      // character constant
    STRINGliteral,          // character string
    HEXconstant       =129,
    OCTconstant,
    DECconstant,
    FLOATconstant,          // real
    NAME,
    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"
    VOIDkey,                // "void"
    VOLATILE,               // "volatile"
    WHILE,                  // "while"
    UNRECOGNIZED,
  }
]

OCTALconstant    = OCTconstant
INTEGERconstant  = DECconstant
FLOATINGconstant = FLOATconstant
CONST            = CONSTANT
VOID             = VOIDkey

prog start
 -> translation unit?, eof

/* CONSTANTS */

constant
 -> FLOATINGconstant
 -> INTEGERconstant
 -> OCTALconstant
 -> HEXconstant
 -> CHARACTERconstant

/* STRING LITERALS */

string literal list
 -> STRINGliteral
 -> string literal list, STRINGliteral

/* EXPRESSIONS */

(void) primary expression
 -> IDENTIFIER
 -> constant
 -> string literal list
 -> '(', expression, ')'

postfix expression
 -> primary expression
 -> postfix expression, '[', expression, ']'
 -> postfix expression, '(', ')'
 -> postfix expression, '(', argument expression list, ')'
 -> postfix expression, '.', identifier or typedef name
 -> postfix expression, ARROW, identifier or typedef name
 -> postfix expression, ICR
 -> postfix expression, DECR

argument expression list
 -> assignment expression
 -> argument expression list, ',', assignment expression

unary expression
 -> postfix expression
 -> ICR, unary expression
 -> DECR, unary expression
 -> unary operator, cast expression
 -> SIZEOF, unary expression
 -> SIZEOF, '(', type name, ')'

unary operator
 -> '&'
 -> '*'
 -> '+'
 -> '-'
 -> '~'
 -> '!'

cast expression
 -> unary expression
 -> '(', type name, ')', cast expression

multiplicative expression
 -> cast expression
 -> multiplicative expression, '*', cast expression
 -> multiplicative expression, '/', cast expression
 -> multiplicative expression, '%', cast 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, ANDAND, inclusive OR expression

logical OR expression
 -> logical AND expression
 -> logical OR expression, OROR, logical AND expression

conditional expression
 -> logical OR expression
 -> logical OR expression, '?', expression, ':', conditional expression

assignment expression
 -> conditional expression
 -> unary expression, assignment operator, assignment expression

assignment operator
 -> '='
 -> MULTassign
 -> DIVassign
 -> MODassign
 -> PLUSassign
 -> MINUSassign
 -> LSassign
 -> RSassign
 -> ANDassign
 -> ERassign
 -> ORassign

expression
 -> assignment expression
 -> expression, ',', assignment expression

constant expression
 -> conditional expression

/* The following was used for clarity */

expression opt
 ->
 -> expression

/* DECLARATIONS */

declaration
 -> sue declaration specifier, ';'
 -> sue type specifier, ';'
 -> declaring list, ';'
 -> default declaring list, ';'

default declaring list
 -> declaration qualifier list, identifier declarator, initializer opt
 -> type qualifier list, identifier declarator, initializer opt
 -> default declaring list, ',', identifier declarator, initializer opt

declaring list
 -> declaration specifier, declarator, initializer opt
 -> type specifier, declarator, initializer opt
 -> declaring list, ',', declarator, initializer opt

declaration specifier
 -> basic declaration specifier
 -> sue declaration specifier
 -> typedef declaration specifier

type specifier
 -> basic type specifier
 -> sue type specifier
 -> typedef type specifier

declaration qualifier list
 -> storage class
 -> type qualifier list, storage class
 -> declaration qualifier list, declaration qualifier

type qualifier list
 -> type qualifier
 -> type qualifier list, type qualifier

declaration qualifier
 -> type qualifier
 -> storage class

type qualifier
 -> CONST
 -> VOLATILE

basic declaration specifier
 -> basic type specifier, storage class
 -> declaration qualifier list, basic type name
 -> basic declaration specifier, declaration qualifier
 -> basic declaration specifier, basic type name

basic type specifier
 -> basic type name
 -> type qualifier list, basic type name
 -> basic type specifier, type qualifier
 -> basic type specifier, basic type name

sue declaration specifier
 -> sue type specifier, storage class
 -> declaration qualifier list, elaborated type name
 -> sue declaration specifier, declaration qualifier

sue type specifier
 -> elaborated type name
 -> type qualifier list, elaborated type name
 -> sue type specifier, type qualifier

(void) typedef declaration specifier
 -> typedef type specifier, storage class
 -> declaration qualifier list, TYPEDEFname
 -> typedef declaration specifier, declaration qualifier

(void) typedef type specifier
 -> TYPEDEFname
 -> type qualifier list, TYPEDEFname
 -> typedef type specifier, type qualifier

storage class
 -> TYPEDEF           =typedef_flag = 1;
 -> EXTERN
 -> STATIC
 -> AUTO
 -> REGISTER

basic type name
 -> VOID
 -> CHAR
 -> SHORT
 -> INT
 -> LONG
 -> FLOAT
 -> DOUBLE
 -> SIGNED
 -> UNSIGNED

elaborated type name
 -> save flag:f, struct or union specifier      =typedef_flag = f;
 -> enum specifier

(int) save flag
 ->     ={int f = typedef_flag; typedef_flag = 0; return f;}

struct or union specifier
 -> struct or union, '{', struct declaration list, '}'
 -> struct or union, identifier or typedef name, '{', struct declaration list, '}'
 -> struct or union, identifier or typedef name

struct or union
 -> STRUCT
 -> UNION

struct declaration list
 -> struct declaration
 -> struct declaration list, struct declaration

struct declaration
 -> struct declaring list, ';'
 -> struct default declaring list, ';'

struct default declaring list
 -> type qualifier list, struct identifier declarator
 -> struct default declaring list, ',', struct identifier declarator

struct declaring list
 -> type specifier, struct declarator
 -> struct declaring list, ',', struct declarator

struct declarator
 -> declarator, bit field size opt
 -> bit field size

struct identifier declarator
 -> identifier declarator, bit field size opt
 -> bit field size

bit field size opt
 ->
 -> bit field size

bit field size
 -> ':', constant expression

enum specifier
 -> ENUM, '{', enumerator list, '}'
 -> ENUM, identifier or typedef name, '{', enumerator list, '}'
 -> ENUM, identifier or typedef name

enumerator list
 -> identifier or typedef name, enumerator value opt
 -> enumerator list, ',', identifier or typedef name, enumerator value opt

enumerator value opt
 ->
 -> '=', constant expression

parameter type list
 -> parameter list
 -> parameter list, ',', ELLIPSIS

parameter list
 -> parameter declaration
 -> parameter list, ',', parameter declaration

parameter declaration
 -> declaration specifier
 -> declaration specifier, abstract declarator
 -> declaration specifier, identifier declarator
 -> declaration specifier, parameter typedef declarator
 -> declaration qualifier list
 -> declaration qualifier list, abstract declarator
 -> declaration qualifier list, identifier declarator
 -> type specifier
 -> type specifier, abstract declarator
 -> type specifier, identifier declarator
 -> type specifier, parameter typedef declarator
 -> type qualifier list
 -> type qualifier list, abstract declarator
 -> type qualifier list, identifier declarator

(void) identifier list
 -> IDENTIFIER
 -> identifier list, ',', IDENTIFIER

(void) identifier or typedef name
 -> IDENTIFIER
 -> TYPEDEFname

type name
 -> type specifier
 -> type specifier, abstract declarator
 -> type qualifier list
 -> type qualifier list, abstract declarator

initializer opt
 ->
 -> '=', initializer

initializer
 -> '{', initializer list, '}'
 -> '{', initializer list, ',', '}'
 -> assignment expression

initializer list
 -> initializer
 -> initializer list, ',', initializer

/* STATEMENTS */

statement
 -> labeled statement
 -> compound statement
 -> expression statement
 -> selection statement
 -> iteration statement
 -> jump statement

labeled statement
 -> identifier or typedef name, ':', statement
 -> CASE, constant expression, ':', statement
 -> DEFAULT, ':', statement

compound statement
 -> '{', '}'
 -> '{', declaration list, '}'
 -> '{', statement list, '}'
 -> '{', declaration list, statement list, '}'

declaration list
 -> declaration
 -> declaration list, declaration

statement list
 -> statement
 -> statement list, statement

expression statement
 -> expression opt, ';'

selection statement
 -> IF, '(', expression, ')', statement
 -> IF, '(', expression, ')', statement, ELSE, statement
 -> SWITCH, '(', expression, ')', statement

iteration statement
 -> WHILE, '(', expression, ')', statement
 -> DO, statement, WHILE, '(', expression, ')', ';'
 -> FOR, '(', expression opt, ';', expression opt, ';', expression opt, ')', statement

jump statement
 -> GOTO, identifier or typedef name, ';'
 -> CONTINUE, ';'
 -> BREAK, ';'
 -> RETURN, expression opt, ';'

/* EXTERNAL DEFINITIONS */

translation unit
 -> external definition
 -> translation unit, external definition

external definition
 -> function definition
 -> declaration
 -> identifier declarator, ';'    /* Added by JTH! */

function definition
 -> identifier declarator, compound statement
 -> declaration specifier, identifier declarator, compound statement
 -> type specifier, identifier declarator, compound statement
 -> declaration qualifier list, identifier declarator, compound statement
 -> type qualifier list, identifier declarator, compound statement
 -> old function declarator, compound statement
 -> declaration specifier, old function declarator, compound statement
 -> type specifier, old function declarator, compound statement
 -> declaration qualifier list, old function declarator, compound statement
 -> type qualifier list, old function declarator, compound statement
 -> old function declarator, declaration list, compound statement
 -> declaration specifier, old function declarator, declaration list, compound statement
 -> type specifier, old function declarator, declaration list, compound statement
 -> declaration qualifier list, old function declarator, declaration list, compound statement
 -> type qualifier list, old function declarator, declaration list, compound statement

declarator
 -> typedef declarator
 -> identifier declarator

typedef declarator
 -> paren typedef declarator
 -> parameter typedef declarator

parameter typedef declarator
 -> TYPEDEFname
 -> TYPEDEFname, postfixing abstract declarator
 -> clean typedef declarator

clean typedef declarator
 -> clean postfix typedef declarator
 -> '*', parameter typedef declarator
 -> '*', type qualifier list, parameter typedef declarator

clean postfix typedef declarator
 -> '(', clean typedef declarator, ')'
 -> '(', clean typedef declarator, ')', postfixing abstract declarator

paren typedef declarator
 -> paren postfix typedef declarator
 -> '*', '(', simple paren typedef declarator, ')'
 -> '*', type qualifier list, '(', simple paren typedef declarator, ')'
 -> '*', paren typedef declarator
 -> '*', type qualifier list, paren typedef declarator

paren postfix typedef declarator
 -> '(', paren typedef declarator, ')'
 -> '(', simple paren typedef declarator, postfixing abstract declarator, ')'
 -> '(', paren typedef declarator, ')', postfixing abstract declarator

simple paren typedef declarator
 -> TYPEDEFname
 -> '(', simple paren typedef declarator, ')'

identifier declarator
 -> unary identifier declarator
 -> paren identifier declarator

unary identifier declarator
 -> postfix identifier declarator
 -> '*', identifier declarator
 -> '*', type qualifier list, identifier declarator

postfix identifier declarator
 -> paren identifier declarator, postfixing abstract declarator
 -> '(', unary identifier declarator, ')'
 -> '(', unary identifier declarator, ')', postfixing abstract declarator

paren identifier declarator
 -> IDENTIFIER:s                            =do_typedef(s);
 -> '(', paren identifier declarator, ')'

old function declarator
 -> postfix old function declarator
 -> '*', old function declarator
 -> '*', type qualifier list, old function declarator

postfix old function declarator
 -> paren identifier declarator, '(', identifier list, ')'
 -> '(', old function declarator, ')'
 -> '(', old function declarator, ')', postfixing abstract declarator

abstract declarator
 -> unary abstract declarator
 -> postfix abstract declarator
 -> postfixing abstract declarator

postfixing abstract declarator
 -> array abstract declarator
 -> '(', ')'
 -> '(', parameter type list, ')'

array abstract declarator
 -> '[', ']'
 -> '[', constant expression, ']'
 -> array abstract declarator, '[', constant expression, ']'

unary abstract declarator
 -> '*'
 -> '*', type qualifier list
 -> '*', abstract declarator
 -> '*', type qualifier list, abstract declarator

postfix abstract declarator
 -> '(', unary abstract declarator, ')'
 -> '(', postfix abstract declarator, ')'
 -> '(', postfixing abstract declarator, ')'
 -> '(', unary abstract declarator, ')', postfixing abstract declarator

(token) IDENTIFIER, TYPEDEFname
 -> NAME:t                                  =check_typedef(t);


{                                           // Embedded C

#define SYNTAX_ERROR syntax_error(PCB.error_message)
#define INPUT_CODE(T) (T).id

static int typedef_flag = 0;
static int use_count = 0;

symbol_type_enum symbol_table[N_SYMBOLS];


static void do_typedef(token t) {
  if (typedef_flag == 0) return;
  typedef_flag = 0;
  symbol_table[t.handle] = typedef_name;
}

static token check_typedef(token t) {
  if (symbol_table[t.handle] == typedef_name)
    CHANGE_REDUCTION(TYPEDEFname);
  return t;
}

// Member Functions for Class c_parser

// Constructor

/*
  This parser has no provisions for multiple simultaneous parses or for
  recursion. The purpose of use_count is to make sure that there is only one
  copy of the parser active at any time.
*/


c_parser::c_parser() {
  assert(use_count == 0);
  use_count++;
  typedef_flag = 0;
  memset(symbol_table, 0, sizeof(symbol_table));
  init_cc();                                // init parse
}


// Destructor

c_parser::~c_parser() {
  use_count--;                              // Makes parser available
}


// Reset Parser

c_parser &reset(c_parser &c) {
  typedef_flag = 0;
  memset(symbol_table, 0, sizeof(symbol_table));
  init_cc();                                // init parse
  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 << (token c) {
  if (PCB.exit_flag != AG_RUNNING_CODE || (int) c.id == '\n') return *this;
  PCB.input_code = c.id;
  PCB.input_value = c;
  cc();
  return *this;
}

token_sink &c_parser::operator << (token *s) {
  while (s->id != END_OF_FILE && PCB.exit_flag == AG_RUNNING_CODE) {
    if ((int) s->id == 10) continue;
    PCB.input_code = s->id;
    PCB.input_value = *s++;
    cc();
  }
  return *this;
}

}                                           // End Embedded C