plusplus.y

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

    : /* nothing */
    | modifier
    { CheckNewModifier( $1 ); }
    ;

new-placement
    : Y_LEFT_PAREN expression-list Y_RIGHT_PAREN
    { $$ = $2; }
    ;

new-type-id
    : dynamic-type-id
    | Y_LEFT_PAREN special-new-type-id Y_RIGHT_PAREN
    { $$ = $2; }
    ;

new-initializer-opt
    : /* nothing */
    { $$ = NULL; }
    | Y_LEFT_PAREN Y_RIGHT_PAREN
    { $$ = NULL; } /* ARM p.61 '()' is syntactic convenience */
    | Y_LEFT_PAREN expression-list Y_RIGHT_PAREN
    { $$ = $2; }
    ;

dynamic-type-id
    : type-specifiers
    {
        $$ = MakeNewTypeId( DoDeclSpec( state->gstack->u.dspec ) );
        GStackPop( &(state->gstack) );
    }
    | type-specifiers new-declarator
    {
        $$ = $2;
        GStackPop( &(state->gstack) );
    }
    ;

new-declarator
    : partial-ptr-declarator actual-new-declarator
    { $$ = MakeNewDeclarator( state->gstack->u.dspec, $1, $2 ); }
    | partial-ptr-declarator
    { $$ = MakeNewDeclarator( state->gstack->u.dspec, $1, NULL ); }
    |                        actual-new-declarator
    { $$ = MakeNewDeclarator( state->gstack->u.dspec, NULL, $1 ); }
    ;

partial-ptr-declarator
    : Y_TIMES cv-qualifiers-opt partial-ptr-declarator
    { $$ = MakeNewPointer( $2, $3, NULL ); }
    | Y_TIMES cv-qualifiers-opt
    { $$ = MakeNewPointer( $2, NULL, NULL ); }
    | Y_SCOPED_TIMES cv-qualifiers-opt partial-ptr-declarator
    { $$ = MakeNewPointer( $2, $3, $1 ); }
    | Y_SCOPED_TIMES cv-qualifiers-opt
    { $$ = MakeNewPointer( $2, NULL, $1 ); }
    | template-class-id Y_TEMPLATE_SCOPED_TIMES cv-qualifiers-opt partial-ptr-declarator
    { $$ = MakeNewPointer( $3, $4, $2 ); PTypeRelease( $1 ); }
    | template-class-id Y_TEMPLATE_SCOPED_TIMES cv-qualifiers-opt
    { $$ = MakeNewPointer( $3, NULL, $2 ); PTypeRelease( $1 ); }
    | Y_TEMPLATE_SCOPED_TIMES cv-qualifiers-opt partial-ptr-declarator
    { $$ = MakeNewPointer( $2, $3, $1 ); zapTemplateClassDeclSpec( state ); }
    | Y_TEMPLATE_SCOPED_TIMES cv-qualifiers-opt
    { $$ = MakeNewPointer( $2, NULL, $1 ); zapTemplateClassDeclSpec( state ); }
    ;

actual-new-declarator
    : Y_LEFT_BRACKET expression Y_RIGHT_BRACKET
    { $$ = MakeNewDynamicArray( $2 ); }
    | actual-new-declarator Y_LEFT_BRACKET constant-expression Y_RIGHT_BRACKET
    { $$ = AddArrayDeclarator( $1, $3 ); }
    ;

delete-expression
    : Y_DELETE cast-expression
    { $$ = setLocation( MakeDeleteExpr( NULL, CO_DELETE, $2 ), &yylp[1] ); }
    | Y_DELETE Y_LEFT_BRACKET delete-size-expression-opt Y_RIGHT_BRACKET cast-expression
    { $$ = setLocation( MakeDeleteExpr( NULL, CO_DELETE_ARRAY, $5 ), &yylp[1] ); }
    | Y_GLOBAL_DELETE cast-expression
    { $$ = setLocation( MakeDeleteExpr( $1, CO_DELETE_G, $2 ), &yylp[1] ); }
    | Y_GLOBAL_DELETE Y_LEFT_BRACKET delete-size-expression-opt Y_RIGHT_BRACKET cast-expression
    { $$ = setLocation( MakeDeleteExpr( $1, CO_DELETE_G_ARRAY, $5 ), &yylp[1] ); }
    ;

delete-size-expression-opt
    : /* nothing */
    | expression
    {
        PTreeDeleteSizeExpr( $1 );
    }
    ;

postfix-expression
    : primary-expression
    | function-like-cast-expression
    | postfix-expression Y_LEFT_BRACKET expression Y_RIGHT_BRACKET
    { $$ = setLocation( PTreeBinary( CO_INDEX, $1, $3 ), &yylp[2] ); }
    | postfix-expression Y_LEFT_PAREN expression-list-opt Y_RIGHT_PAREN
    { $$ = setLocation( PTreeBinary( CO_CALL, $1, $3 ), &yylp[2] ); }
    | member-selection-expression field-expression
    { $$ = PTreeReplaceRight( $1, $2 ); }
    | postfix-expression Y_PLUS_PLUS
    { $$ = setLocation( PTreeUnary( CO_POST_PLUS_PLUS, $1 ), &yylp[2] ); }
    | postfix-expression Y_MINUS_MINUS
    { $$ = setLocation( PTreeUnary( CO_POST_MINUS_MINUS, $1 ), &yylp[2] ); }
    | Y___SEGNAME Y_LEFT_PAREN strings Y_RIGHT_PAREN
    { $$ = setLocation( PTreeUnary( CO_SEGNAME, $3 ), &yylp[1] ); }
    | Y_DYNAMIC_CAST lt-special type-id Y_GT_SPECIAL Y_LEFT_PAREN expression Y_RIGHT_PAREN
    { $$ = setLocation( PTreeBinary( CO_DYNAMIC_CAST, $3, $6 ), &yylp[1] ); }
    | Y_STATIC_CAST lt-special type-id Y_GT_SPECIAL Y_LEFT_PAREN expression Y_RIGHT_PAREN
    { $$ = setLocation( PTreeBinary( CO_STATIC_CAST, $3, $6 ), &yylp[1] ); }
    | Y_REINTERPRET_CAST lt-special type-id Y_GT_SPECIAL Y_LEFT_PAREN expression Y_RIGHT_PAREN
    { $$ = setLocation( PTreeBinary( CO_REINTERPRET_CAST, $3, $6 ), &yylp[1] ); }
    | Y_CONST_CAST lt-special type-id Y_GT_SPECIAL Y_LEFT_PAREN expression Y_RIGHT_PAREN
    { $$ = setLocation( PTreeBinary( CO_CONST_CAST, $3, $6 ), &yylp[1] ); }
    | Y_TYPEID Y_LEFT_PAREN expression Y_RIGHT_PAREN
    { $$ = setLocation( PTreeUnary( CO_TYPEID_EXPR, $3 ), &yylp[1] ); }
    | Y_TYPEID Y_LEFT_PAREN type-id Y_RIGHT_PAREN
    { $$ = setLocation( PTreeUnary( CO_TYPEID_TYPE, $3 ), &yylp[1] ); }
    ;

member-selection-expression
    : postfix-expression Y_DOT
    { $$ = setLocation( PTreeBinary( CO_DOT, $1, NULL ), &yylp[2] ); }
    | postfix-expression Y_ARROW
    { $$ = setLocation( PTreeBinary( CO_ARROW, $1, NULL ), &yylp[2] ); }
    ;

function-like-cast-expression
    : simple-type-specifier Y_LEFT_PAREN expression-list-opt Y_RIGHT_PAREN %ambig 0 Y_LEFT_PAREN
    { $$ = setLocation( MakeFunctionLikeCast( $1, $3 ), &yylp[2] ); }
    | Y_TYPENAME Y_SCOPED_TYPE_NAME Y_LEFT_PAREN expression-list-opt Y_RIGHT_PAREN
    {
        $$ = setLocation( MakeFunctionLikeCast( sendType( $2 ), $4 ),
                          &yylp[2] );
    }
    | Y_TYPENAME template-class-id Y_TEMPLATE_SCOPED_TYPE_NAME Y_LEFT_PAREN expression-list-opt Y_RIGHT_PAREN
    {
        $$ = setLocation( MakeFunctionLikeCast( sendType( $3 ), $5 ),
                          &yylp[2] );
        PTypeRelease( $2 );
    }
    ;

primary-expression
    : literal
    | Y_THIS
    { $$ = setLocation( PTreeThis(), &yylp[1] ); }
    | Y_GLOBAL_ID
    { $$ = MakeGlobalId( $1 ); }
    | Y_GLOBAL_OPERATOR operator-function-type
    { $$ = MakeGlobalOperatorId( $1, $2 ); }
    | Y_LEFT_PAREN expression Y_RIGHT_PAREN
    { $$ = $2; }
    | id-expression
    ;

id-expression
    : Y_ID
    | operator-name
    | qualified-id-expression
    ;

make-id
    : Y_ID
    | Y_TYPE_NAME
    | Y_TEMPLATE_NAME
    | Y_NAMESPACE_NAME
    ;

class-name-id
    : Y_ID
    | Y_TYPE_NAME
    | Y_TEMPLATE_NAME
    | Y_NAMESPACE_NAME
    | Y_GLOBAL_TYPE_NAME
    | Y_GLOBAL_TEMPLATE_NAME
    | Y_SCOPED_TYPE_NAME
    | Y_SCOPED_TEMPLATE_NAME
    | Y_TEMPLATE_SCOPED_TYPE_NAME
    | Y_TEMPLATE_SCOPED_TEMPLATE_NAME
    ;

enum-name
    : Y_ID
    | Y_TYPE_NAME
    | Y_TEMPLATE_NAME
    | Y_NAMESPACE_NAME
    | Y_GLOBAL_TYPE_NAME
    | Y_SCOPED_TYPE_NAME
    | Y_TEMPLATE_SCOPED_TYPE_NAME
    ;

destructor-name
    : Y_TILDE make-id
    { $$ = setLocation( MakeDestructorId( $2 ), &yylp[1] ); }
    | Y_TILDE template-class-id
    { $$ = setLocation( MakeDestructorIdFromType( $2 ), &yylp[1] ); }
    ;

field-name
    : make-id
    | destructor-name
    | operator-name
    ;

field-expression
    : field-name
    | qualified-id-expression
    /* handles 'int::~int' cases (p. 280 ARM) */
    | basic-type-specifier Y_GLOBAL_TILDE basic-type-specifier
    { $$ = MakeScalarDestructor( $1, $2, $3 ); }
    ;

qualified-id-expression
    : Y_SCOPED_ID
    { $$ = MakeScopedId( $1 ); }
    | Y_SCOPED_TILDE make-id
    { $$ = MakeScopedDestructorId( $1, $2 ); }
    | Y_SCOPED_OPERATOR conversion-function-type
    {
        $$ = MakeScopedUserConversionId( $1, $2 );
        ScopeQualifyPop();
    }
    | Y_SCOPED_OPERATOR operator-function-type
    {
        $$ = MakeScopedOperatorId( $1, $2 );
        ScopeQualifyPop();
    }
    | template-class-id Y_TEMPLATE_SCOPED_ID
    { $$ = MakeScopedId( $2 ); PTypeRelease( $1 ); }
    | template-class-id Y_TEMPLATE_SCOPED_TILDE make-id
    { $$ = MakeScopedDestructorId( $2, $3 ); PTypeRelease( $1 ); }
    | template-class-id Y_TEMPLATE_SCOPED_OPERATOR conversion-function-type
    {
        $$ = MakeScopedUserConversionId( $2, $3 );
        ScopeQualifyPop();
        PTypeRelease( $1 );
    }
    | template-class-id Y_TEMPLATE_SCOPED_OPERATOR operator-function-type
    {
        $$ = MakeScopedOperatorId( $2, $3 );
        ScopeQualifyPop();
        PTypeRelease( $1 );
    }
    | Y_TEMPLATE_SCOPED_ID
    { $$ = MakeScopedId( $1 ); zapTemplateClassDeclSpec( state ); }
    | Y_TEMPLATE_SCOPED_TILDE make-id
    { $$ = MakeScopedDestructorId( $1, $2 ); zapTemplateClassDeclSpec( state ); }
    | Y_TEMPLATE_SCOPED_OPERATOR conversion-function-type
    {
        $$ = MakeScopedUserConversionId( $1, $2 );
        ScopeQualifyPop();
        zapTemplateClassDeclSpec( state );
    }
    | Y_TEMPLATE_SCOPED_OPERATOR operator-function-type
    {
        $$ = MakeScopedOperatorId( $1, $2 );
        ScopeQualifyPop();
        zapTemplateClassDeclSpec( state );
    }
    ;

operator-name
    : Y_OPERATOR conversion-function-type
    { $$ = setLocation( $2, &yylp[1] ); }
    | Y_OPERATOR operator-function-type
    { $$ = setLocation( MakeOperatorId( $2 ), &yylp[1] ); }
    ;

conversion-function-type
    : type-specifiers
    {
        $$ = MakeUserConversionId( $1, NULL );
        GStackPop( &(state->gstack) );
    }
    | type-specifiers conversion-function-ptr-declarator
    {
        $$ = MakeUserConversionId( $1, $2 );
        GStackPop( &(state->gstack) );
    }
    ;
    
conversion-function-ptr-declarator
    : ptr-operator
    { $$ = MakeAbstractDeclarator( $1 ); }
    | ptr-operator conversion-function-ptr-declarator
    { $$ = AddDeclarator( $2, $1 ); }
    ;

operator-function-type
    : Y_NEW
    { $$ = CO_NEW; }
    | Y_DELETE
    { $$ = CO_DELETE; }
    | Y_NEW Y_LEFT_BRACKET Y_RIGHT_BRACKET
    { $$ = CO_NEW_ARRAY; }
    | Y_DELETE Y_LEFT_BRACKET Y_RIGHT_BRACKET
    { $$ = CO_DELETE_ARRAY; }
    | Y_PLUS
    { $$ = CO_PLUS; }
    | Y_MINUS
    { $$ = CO_MINUS; }
    | Y_TIMES
    { $$ = CO_TIMES; }
    | Y_DIVIDE
    { $$ = CO_DIVIDE; }
    | Y_PERCENT
    { $$ = CO_PERCENT; }
    | Y_XOR
    { $$ = CO_XOR; }
    | Y_AND
    { $$ = CO_AND; }
    | Y_OR
    { $$ = CO_OR; }
    | Y_TILDE
    { $$ = CO_TILDE; }
    | Y_EXCLAMATION
    { $$ = CO_EXCLAMATION; }
    | Y_EQUAL
    { $$ = CO_EQUAL; }
    | Y_TIMES_EQUAL
    { $$ = CO_TIMES_EQUAL; }
    | Y_DIVIDE_EQUAL
    { $$ = CO_DIVIDE_EQUAL; }
    | Y_PERCENT_EQUAL
    { $$ = CO_PERCENT_EQUAL; }
    | Y_PLUS_EQUAL
    { $$ = CO_PLUS_EQUAL; }
    | Y_MINUS_EQUAL
    { $$ = CO_MINUS_EQUAL; }
    | Y_LSHIFT_EQUAL
    { $$ = CO_LSHIFT_EQUAL; }
    | Y_RSHIFT_EQUAL
    { $$ = CO_RSHIFT_EQUAL; }
    | Y_OR_EQUAL
    { $$ = CO_OR_EQUAL; }
    | Y_AND_EQUAL
    { $$ = CO_AND_EQUAL; }
    | Y_XOR_EQUAL
    { $$ = CO_XOR_EQUAL; }
    | Y_LSHIFT
    { $$ = CO_LSHIFT; }
    | Y_RSHIFT
    { $$ = CO_RSHIFT; }
    | Y_EQ
    { $$ = CO_EQ; }
    | Y_NE
    { $$ = CO_NE; }
    | Y_LE
    { $$ = CO_LE; }
    | Y_GE
    { $$ = CO_GE; }
    | Y_LT
    { $$ = CO_LT; }
    | Y_GT
    { $$ = CO_GT; }
    | Y_AND_AND
    { $$ = CO_AND_AND; }
    | Y_OR_OR
    { $$ = CO_OR_OR; }
    | Y_PLUS_PLUS
    { $$ = CO_PRE_PLUS_PLUS; }
    | Y_MINUS_MINUS
    { $$ = CO_PRE_MINUS_MINUS; }
    | Y_COMMA
    { $$ = CO_COMMA; }
    | Y_ARROW_STAR
    { $$ = CO_ARROW_STAR; }
    | Y_ARROW
    { $$ = CO_ARROW; }
    | Y_LEFT_PAREN Y_RIGHT_PAREN
    { $$ = CO_CALL; }
    | Y_LEFT_BRACKET Y_RIGHT_BRACKET
    { $$ = CO_INDEX; }
    | Y_SEG_OP
    { $$ = CO_SEG_OP; }
    ;

literal
    : Y_CONSTANT
    | Y_TRUE
    | Y_FALSE
    | strings
    ;

strings
    : Y_STRING
    | strings Y_STRING
    { $$ = PTreeStringLiteralConcat( $1, $2 ); }
    ;

/*** declaration syntax ***/
might-restart-declarations
    : start-restart-declarations
    { popRestartDecl( state ); }
    | start-restart-declarations declarations
    { popRestartDecl( state ); }
    ;
    
start-restart-declarations
    : /* nothing */
    { pushRestartDecl( state ); }
    ;
    
/* should only be referenced by might-restart-declarations */
declarations
    : declaration
    | declarations declaration
    ;

declaration
    : simple-declaration-before-semicolon Y_SEMI_COLON
    | function-definition
    | linkage-specification
    | template-declaration
    | explicit-specialization
    | template-directive
    | namespace-definition
    | Y_SEMI_COLON
    ;