preparse.y

开放源码的编译器open watcom 1.6.0版的源代码

                createConstr4Label(LABCT_DEFINED, $1, $2, $4, $5)); }
    ;

/*======================== EXPRESSIONS ===================================*/
/* This part is common to both preparse.y and cparse.y                    */
/*========================================================================*/

primary-expression
    : literal
    | Y_LEFT_PAREN expression Y_RIGHT_PAREN
        { $$ = createCTree1(createConstr2Label(LABCT_PAREN_EXPR, $1, $3), $2); }
    | identifier
        { $$ = createCTreeRoot(createTokenLabel($1)); }
    ;

postfix-expression
    : primary-expression
    | postfix-expression Y_LEFT_BRACKET expression Y_RIGHT_BRACKET
        { $$ = createCTree2(createConstr2Label(LABCT_INDEX, $2, $4), $1,  $3); }
    | postfix-expression Y_LEFT_PAREN expression-list-opt Y_RIGHT_PAREN
        { $$ = createCTree2(createConstr2Label(LABCT_CALL, $2, $4), $1,  $3); }
    | postfix-expression Y_DOT identifier
        { $$ = createCTree2(createConstr1Label(LABCT_DOT, $2), $1,
                            createCTreeRoot(createTokenLabel($3))); }
    | postfix-expression Y_ARROW identifier
        { $$ = createCTree2(createConstr1Label(LABCT_ARROW, $2), $1,
                            createCTreeRoot(createTokenLabel($3))); }
    ;

expression-list-opt
    : /* Nothing */
        { $$ = createNULLCTree(); }
    | expression-list
    ;

expression-list
    : assignment-expression
    | expression-list Y_COMMA assignment-expression
        { $$ = createCTree2(createConstr1Label(LABCT_EXPR_LIST, $2), $1, $3); }
    ;

unary-expression
    : postfix-expression
    | unary-operator cast-expression
        { $$ = createCTree1( $1, $2 ); }
    | Y_SIZEOF unary-expression
        { $$ = createCTree1(createConstr1Label(LABCT_SIZEOF_EXPR, $1), $2); }
    | Y_SIZEOF Y_LEFT_PAREN type-name Y_RIGHT_PAREN
        { $$ = createCTree1(createConstr3Label(LABCT_SIZEOF_TYPE, $1, $2, $4), $3); }
    ;

unary-operator
    : Y_TIMES
        { $$ = createConstr1Label(LABCT_VALUE_AT_ADDR, $1); }
    | Y_AND
        { $$ = createConstr1Label(LABCT_ADDR_OF_VALUE, $1); }
    | Y_PLUS
        { $$ = createConstr1Label(LABCT_UNARY_PLUS, $1); }
    | Y_MINUS
        { $$ = createConstr1Label(LABCT_UNARY_MINUS, $1); }
    | Y_EXCLAMATION
        { $$ = createConstr1Label(LABCT_EXCLAMATION, $1); }
    | Y_TILDE
        { $$ = createConstr1Label(LABCT_TILDE, $1); }
    ;

cast-expression
    : unary-expression
    | Y_LEFT_PAREN type-name Y_RIGHT_PAREN cast-expression
        { $$ = createCTree2(createConstr2Label(LABCT_CAST_EXPR, $1, $3), $2, $4); }
    ;

multiplicative-expression
    : cast-expression
    | multiplicative-expression Y_TIMES cast-expression
        { $$ = createCTree2(createConstr1Label(LABCT_TIMES, $2), $1, $3); }
    | multiplicative-expression Y_DIVIDE cast-expression
        { $$ = createCTree2(createConstr1Label(LABCT_DIVIDE, $2), $1, $3); }
    | multiplicative-expression Y_PERCENT cast-expression
        { $$ = createCTree2(createConstr1Label(LABCT_PERCENT, $2), $1, $3); }
    ;

additive-expression
    : multiplicative-expression
    | additive-expression Y_PLUS multiplicative-expression
        { $$ = createCTree2(createConstr1Label(LABCT_PLUS, $2), $1, $3); }
    | additive-expression Y_MINUS multiplicative-expression
        { $$ = createCTree2(createConstr1Label(LABCT_MINUS, $2), $1, $3); }
    ;

shift-expression
    : additive-expression
    | shift-expression Y_RSHIFT additive-expression
        { $$ = createCTree2(createConstr1Label(LABCT_RSHIFT, $2), $1, $3); }
    | shift-expression Y_LSHIFT additive-expression
        { $$ = createCTree2(createConstr1Label(LABCT_LSHIFT, $2), $1, $3); }
    ;

relational-expression
    : shift-expression
    | relational-expression Y_LT shift-expression
        { $$ = createCTree2(createConstr1Label(LABCT_LT, $2), $1, $3); }
    | relational-expression Y_LE shift-expression
        { $$ = createCTree2(createConstr1Label(LABCT_LE, $2), $1, $3); }
    | relational-expression Y_GT shift-expression
        { $$ = createCTree2(createConstr1Label(LABCT_GT, $2), $1, $3); }
    | relational-expression Y_GE shift-expression
        { $$ = createCTree2(createConstr1Label(LABCT_GE, $2), $1, $3); }
    ;

equality-expression
    : relational-expression
    | equality-expression Y_EQ relational-expression
        { $$ = createCTree2(createConstr1Label(LABCT_EQ, $2), $1, $3); }
    | equality-expression Y_NE relational-expression
        { $$ = createCTree2(createConstr1Label(LABCT_NE, $2), $1, $3); }
    ;

and-expression
    : equality-expression
    | and-expression Y_AND equality-expression
        { $$ = createCTree2(createConstr1Label(LABCT_AND, $2), $1, $3); }
    ;

exclusive-or-expression
    : and-expression
    | exclusive-or-expression Y_XOR and-expression
        { $$ = createCTree2(createConstr1Label(LABCT_XOR, $2), $1, $3); }
    ;

inclusive-or-expression
    : exclusive-or-expression
    | inclusive-or-expression Y_OR exclusive-or-expression
        { $$ = createCTree2(createConstr1Label(LABCT_OR, $2), $1, $3); }
    ;

logical-and-expression
    : inclusive-or-expression
    | logical-and-expression Y_AND_AND inclusive-or-expression
        { $$ = createCTree2(createConstr1Label(LABCT_AND_AND, $2), $1, $3); }
    ;

logical-or-expression
    : logical-and-expression
    | logical-or-expression Y_OR_OR logical-and-expression
        { $$ = createCTree2(createConstr1Label(LABCT_OR_OR, $2), $1, $3); }
    ;

conditional-expression
    : logical-or-expression
    | logical-or-expression Y_QUESTION expression Y_COLON assignment-expression
        {
            $$ = createCTree2(createConstr1Label(LABCT_QUESTION, $2), $1,
                        createCTree2(createConstr1Label(LABCT_COLON, $4), $3, $5));
        }
    ;

assignment-expression
    : conditional-expression
    ;

expression
    : assignment-expression
    | expression Y_COMMA assignment-expression
        { $$ = createCTree2(createConstr1Label(LABCT_EXPR_SEPARATOR, $2), $1, $3); }
    ;

constant-expression
    : conditional-expression
    ;

decl-specs
    : non-type-decl-specs type-spec maybe-type-decl-specs
        { $$ = combine2DeclInfo(combine2DeclInfo($1, $2), $3); }
    | non-type-decl-specs type-spec
        { $$ = combine2DeclInfo($1, $2); }
    |                     type-spec maybe-type-decl-specs
        { $$ = combine2DeclInfo($1, $2); }
    |                     type-spec
    | non-type-decl-specs
    ;

non-type-decl-specs
    : non-type-decl-spec
    | non-type-decl-specs non-type-decl-spec
        { $$ = combine2DeclInfo($1, $2); }
    ;

non-type-decl-spec
    : storage-class-spec
    | cv-qualifier
    ;

type-spec
    : scalar-type-spec
    | typedef-name
    | struct-or-union-spec
        { $$ = createDeclInfoSTRUCT($1); }
    | enum-spec
        { $$ = createDeclInfoENUM($1); }
    ;

typedef-name
    : Y_TYPEDEF_NAME
        { $$ = dupDeclInfo($1->data->repr.pTypeDecl, $1->pos); zapToken($1); }
    ;


maybe-type-decl-specs
    : non-type-decl-spec
    | scalar-type-spec
    | maybe-type-decl-specs non-type-decl-spec
        { $$ = combine2DeclInfo($1, $2); }
    | maybe-type-decl-specs scalar-type-spec
        { $$ = combine2DeclInfo($1, $2); }
    ;

storage-class-spec
    : Y_AUTO
        { $$ = createStgClassDeclInfo(STG_AUTO, $1); }
    | Y_REGISTER
        { $$ = createStgClassDeclInfo(STG_REGISTER, $1); }
    | Y_EXTERN
        { $$ = createStgClassDeclInfo(STG_EXTERN, $1); }
    | Y_STATIC
        { $$ = createStgClassDeclInfo(STG_STATIC, $1); }
    | Y_TYPEDEF
        { $$ = createStgClassDeclInfo(STG_TYPEDEF, $1); }
    ;

scalar-type-spec
    : Y_VOID
        { $$ = createDeclInfoSCALAR(STM_VOID, $1->pos);
          $1->pos = NULL; zapToken($1); }
    | Y_CHAR
        { $$ = createDeclInfoSCALAR(STM_CHAR, $1->pos);
          $1->pos = NULL; zapToken($1); }
    | Y_SHORT
        { $$ = createDeclInfoSCALAR(STM_SHORT, $1->pos);
          $1->pos = NULL; zapToken($1); }
    | Y_INT
        { $$ = createDeclInfoSCALAR(STM_INT, $1->pos);
          $1->pos = NULL; zapToken($1); }
    | Y_LONG
        { $$ = createDeclInfoSCALAR(STM_LONG, $1->pos);
          $1->pos = NULL; zapToken($1); }
    | Y_FLOAT
        { $$ = createDeclInfoSCALAR(STM_FLOAT, $1->pos);
          $1->pos = NULL; zapToken($1); }
    | Y_DOUBLE
        { $$ = createDeclInfoSCALAR(STM_DOUBLE, $1->pos);
          $1->pos = NULL; zapToken($1); }
    | Y_SIGNED
        { $$ = createDeclInfoSCALAR(STM_SIGNED, $1->pos);
          $1->pos = NULL; zapToken($1); }
    | Y_UNSIGNED
        { $$ = createDeclInfoSCALAR(STM_UNSIGNED, $1->pos);
          $1->pos = NULL; zapToken($1); }
    ;

struct-or-union-spec
    : struct-or-union struct-id struct-or-union-body
        { $$ = createDeclStructInfo($1, $2, $3); }
    | struct-or-union            struct-or-union-body
        { $$ = createDeclStructInfo($1, NULL, $2); }
    | struct-or-union struct-id
        { $$ = createDeclStructInfo($1, $2, NULL); }
    ;

struct-id
    : Y_ID
    | Y_TYPEDEF_NAME
    ;

struct-or-union
    : Y_STRUCT
    | Y_UNION
    ;

struct-or-union-body
    : Y_LEFT_BRACE struct-decl-list Y_RIGHT_BRACE
        {
            $$ = createDeclStructBody($2, $3->pos);
            $3->pos = NULL; zapTokens2($1, $3);
        }
    ;

struct-decl-list
    : struct-decl
        { $$ = createDeclList($1); }
    | struct-decl-list struct-decl
        { $$ = addDeclList($1, $2); }
    | struct-decl-list error
        { recoverError(); $$ = $1; }
    ;

struct-decl
    : decl-specs Y_SEMICOLON
        { $$ = addDeclInfoDclrList($1, NULL); zapToken($2); }
    | decl-specs struct-declarator-list Y_SEMICOLON
        { $$ = addDeclInfoDclrList($1, $2); zapToken($3); }
    ;

struct-declarator-list
    : struct-declarator
        { $$ = createDclrList($1); }
    | struct-declarator-list Y_COMMA struct-declarator
        { $$ = addDclrList($1, $3); zapToken($2); }
    ;

struct-declarator
    : declarator
    | declarator Y_COLON constant-expression
        {
            reportError(CERR_CANT_CONVERT_BIT_FIELDS);
            $$ = $1;
            zapToken($2);  zapCTree($3);
        }
    ;

enum-spec
    : Y_ENUM identifier Y_LEFT_BRACE enum-list Y_RIGHT_BRACE
        { $$ = createDeclEnum($1, $4); zapTokens3($2, $3, $5); }
    | Y_ENUM identifier
        { $$ = createDeclEnum($1, NULL); zapToken($2); }
    | Y_ENUM            Y_LEFT_BRACE enum-list Y_RIGHT_BRACE
        { $$ = createDeclEnum($1, $3); zapTokens2($2, $4); }
    ;

enum-list
    : enum-list-collect
        { $$ = finishEnumListCreation($1); }
    | enum-list-collect Y_COMMA              /* Watcom C extension */
        { $$ = finishEnumListCreation($1); }
    ;

enum-list-collect
    : enumerator
        { $$ = createEnumList($1); }
    | enum-list-collect comma-and-enumerator
        { $$ = addEnumList($1,  $2); }
    | enum-list-collect error
        { recoverError();  $$ = $1; }
    ;