plusplus.y

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

    
namespace-alias-definition
    : Y_NAMESPACE make-id Y_EQUAL raw-qualified-namespace-specifier
    { NameSpaceAlias( $2, $4 ); }
    ;
    
namespace-using-directive
    : Y_USING Y_NAMESPACE raw-qualified-namespace-specifier
    { NameSpaceUsingDirective( $3 ); }
    ;
    
namespace-using-declaration
    : Y_USING qualified-id-expression
    { NameSpaceUsingDeclId( $2 ); }
    | Y_USING Y_TYPE_NAME
    { NameSpaceUsingDeclType( sendType( $2 ) ); }
    | Y_USING Y_GLOBAL_TYPE_NAME
    { NameSpaceUsingDeclType( sendType( $2 ) ); }
    | Y_USING Y_SCOPED_TYPE_NAME
    { NameSpaceUsingDeclType( sendType( $2 ) ); }
    | Y_USING template-class-id Y_TEMPLATE_SCOPED_TYPE_NAME
    { NameSpaceUsingDeclType( sendType( $3 ) ); PTypeRelease( $2 ); }
    | Y_USING Y_GLOBAL_TEMPLATE_NAME
    { NameSpaceUsingDeclTemplateName( $2 ); }
    | Y_USING Y_SCOPED_TEMPLATE_NAME
    { NameSpaceUsingDeclTemplateName( $2 ); }
    | Y_USING Y_GLOBAL_ID
    { NameSpaceUsingDeclId( MakeGlobalId( $2 ) ); }
    | Y_USING Y_GLOBAL_OPERATOR operator-function-type
    { NameSpaceUsingDeclId( MakeGlobalOperatorId( $2, $3 ) ); }
    ;
    
raw-qualified-namespace-specifier
    : Y_SCOPED_ID
    | Y_SCOPED_TYPE_NAME
    | Y_SCOPED_TEMPLATE_NAME
    | Y_SCOPED_NAMESPACE_NAME
    | Y_GLOBAL_ID
    | Y_GLOBAL_TYPE_NAME
    | Y_GLOBAL_TEMPLATE_NAME
    | Y_GLOBAL_NAMESPACE_NAME
    | Y_ID
    | Y_TYPE_NAME
    | Y_TEMPLATE_NAME
    | Y_NAMESPACE_NAME
    ;
    
namespace-definition
    : namespace-key Y_LEFT_BRACE namespace-body Y_RIGHT_BRACE
    ;
    
namespace-key
    : Y_NAMESPACE
    { NameSpaceUnnamed( &yylp[1] ); }
    | Y_NAMESPACE make-id
    { NameSpaceNamed( $2 ); }
    ;
    
namespace-body
    : /* nothing */
    { NameSpaceClose(); }
    | might-restart-declarations
    { NameSpaceClose(); }
    ;

local-declaration
    : simple-declaration-before-semicolon Y_SEMI_COLON
    ;

access-declaration
    : qualified-id-expression
    { ClassAccessDeclaration( $1, &yylocation ); }
    | qualified-type-specifier
    { ClassAccessTypeDeclaration( $1, &yylocation ); }
    ;

static_assert-declaration
    : Y_STATIC_ASSERT Y_LEFT_PAREN constant-expression Y_COMMA strings Y_RIGHT_PAREN
    {
        /* see N1720 -- Proposal to Add Static Assertions to the Core
         * Language (Revision 3) */
        DbgAssert( $3->op == PT_INT_CONSTANT );
        DbgAssert( $5->op == PT_STRING_CONSTANT );

        if( $3->u.int_constant == 0 ) {
            CErr2p( ERR_STATIC_ASSERTION_FAILURE,
                    StringBytes( $5->u.string ) );
        }

        PTreeFreeSubtrees( $3 );
        PTreeFreeSubtrees( $5 );
    }
    ;

simple-declaration-before-semicolon
    : simple-declaration
    {
        if( t != Y_SEMI_COLON ) {
            SetErrLoc( &yylocation );
            CErr1( ERR_SYNTAX_MISSING_SEMICOLON );
            what = P_DIAGNOSED;
        }
    }
    ;

simple-declaration
    : decl-specifiers declarator-list
    {
        CheckDeclarationDSpec( state->gstack->u.dspec, GetCurrScope() );
        GStackPop( &(state->gstack) );
    }
    | no-declarator-declaration
    {
        CheckDeclarationDSpec( state->gstack->u.dspec, GetCurrScope() );
        GStackPop( &(state->gstack) );
    }
    | asm-declaration
    | namespace-alias-definition
    | namespace-using-directive
    | namespace-using-declaration
    | static_assert-declaration
    ;

no-declarator-declaration
    : decl-specifiers
    {
        $$ = CheckNoDeclarator( $1 );
        if( $$ == NULL ) {
            what = P_SYNTAX;
        }
    }
    ;

decl-specifiers
    : non-type-decl-specifiers type-specifier maybe-type-decl-specifiers
    {
        $1 = PTypeCombine( $1, $2 );
        $$ = PTypeCombine( $1, $3 );
        $$ = PTypeDone( $$, t == Y_SEMI_COLON );
        pushUserDeclSpec( state, $$ );
    }
    | non-type-decl-specifiers type-specifier
    {
        $$ = PTypeCombine( $1, $2 );
        $$ = PTypeDone( $$, t == Y_SEMI_COLON );
        pushUserDeclSpec( state, $$ );
    }
    |                          type-specifier maybe-type-decl-specifiers
    {
        $$ = PTypeCombine( $1, $2 );
        $$ = PTypeDone( $$, t == Y_SEMI_COLON );
        pushUserDeclSpec( state, $$ );
    }
    |                          type-specifier
    {
        $$ = PTypeDone( $1, t == Y_SEMI_COLON );
        pushUserDeclSpec( state, $$ );
    }
    | non-type-decl-specifiers
    {
        $$ = PTypeDone( $1, t == Y_SEMI_COLON );
        pushUserDeclSpec( state, $$ );
    }
    ;

non-type-decl-specifiers
    : non-type-decl-specifier
    | non-type-decl-specifiers non-type-decl-specifier
    { $$ = PTypeCombine( $1, $2 ); }
    ;

maybe-type-decl-specifiers
    : non-type-decl-specifier
    | basic-type-specifier
    | maybe-type-decl-specifiers non-type-decl-specifier
    { $$ = PTypeCombine( $1, $2 ); }
    | maybe-type-decl-specifiers basic-type-specifier
    { $$ = PTypeCombine( $1, $2 ); }
    ;

non-type-decl-specifier
    : storage-class-specifier
    | function-specifier
    | cv-qualifier
    | ms-specific-declspec
    ;
    
ms-specific-declspec
    : Y___DECLSPEC Y_LEFT_PAREN                 Y_RIGHT_PAREN
    { $$ = PTypeMSDeclSpec( NULL, NULL ); }
    | Y___DECLSPEC Y_LEFT_PAREN ms-declspec-seq Y_RIGHT_PAREN
    { $$ = $3; }
    ;
    
ms-declspec-seq
    : make-id
    { $$ = PTypeMSDeclSpec( NULL, $1 ); }
    | pragma-modifier
    { $$ = PTypeMSDeclSpecModifier( NULL, $1 ); }
    | ms-declspec-seq make-id
    { $$ = PTypeMSDeclSpec( $1, $2 ); }
    | ms-declspec-seq pragma-modifier
    { $$ = PTypeMSDeclSpecModifier( $1, $2 ); }
    ;

storage-class-specifier
    : Y_AUTO
    { $$ = PTypeStgClass( STG_AUTO ); }
    | Y_REGISTER
    { $$ = PTypeStgClass( STG_REGISTER ); }
    | Y_EXTERN
    { $$ = PTypeStgClass( STG_EXTERN ); }
    | Y_STATIC
    { $$ = PTypeStgClass( STG_STATIC ); }
    | Y_TYPEDEF
    { $$ = PTypeStgClass( STG_TYPEDEF ); }
    | Y_MUTABLE
    { $$ = PTypeStgClass( STG_MUTABLE ); }
    | Y_EXTERN linkage-id
    { $$ = PTypeLinkage(); }
    ;

function-specifier
    : Y_INLINE
    { $$ = PTypeSpecifier( STY_INLINE ); }
    | Y___INLINE
    { $$ = PTypeSpecifier( STY_INLINE ); }
    | Y_VIRTUAL
    { $$ = PTypeSpecifier( STY_VIRTUAL ); }
    | Y_FRIEND
    { $$ = PTypeSpecifier( STY_FRIEND ); }
    | Y_EXPLICIT
    { $$ = PTypeSpecifier( STY_EXPLICIT ); }
    ;

type-specifier
    : simple-type-specifier %prec Y_FAVOUR_REDUCE_SPECIAL %ambig 0 Y_LEFT_PAREN
    | class-specifier
    | enum-specifier
    | typeof-specifier
    | typename-specifier
    ;

typeof-specifier
    : Y___TYPEOF Y_LEFT_PAREN expression Y_RIGHT_PAREN
    { $$ = PTypeExpr( $3 ); }
    | Y___TYPEOF Y_LEFT_PAREN type-id Y_RIGHT_PAREN
    { $$ = PTypeTypeid( $3 ); }
    ;

type-specifiers
    : decl-specifiers
    {
        $$ = CheckTypeSpecifier( $1 );
        if( $$ == NULL ) {
            what = P_SYNTAX;
        }
    }
    ;

cv-qualifier
    : Y_CONST
    { $$ = PTypeSpecifier( STY_CONST ); }
    | Y_VOLATILE
    { $$ = PTypeSpecifier( STY_VOLATILE ); }
    | Y___UNALIGNED
    { $$ = PTypeSpecifier( STY_UNALIGNED ); }
    ;

simple-type-specifier
    : qualified-type-specifier
    | basic-type-specifier
    ;

basic-type-specifier
    : Y_CHAR
    { $$ = PTypeScalar( STM_CHAR ); }
    | Y_BOOL
    { $$ = PTypeScalar( STM_BOOL ); }
    | Y_SHORT
    { $$ = PTypeScalar( STM_SHORT ); }
    | Y_INT
    { $$ = PTypeScalar( STM_INT ); }
    | Y_LONG
    { $$ = PTypeScalar( STM_LONG ); }
    | Y_SIGNED
    { $$ = PTypeScalar( STM_SIGNED ); }
    | Y_UNSIGNED
    { $$ = PTypeScalar( STM_UNSIGNED ); }
    | Y_FLOAT
    { $$ = PTypeScalar( STM_FLOAT ); }
    | Y_DOUBLE
    { $$ = PTypeScalar( STM_DOUBLE ); }
    | Y_VOID
    { $$ = PTypeScalar( STM_VOID ); }
    | Y___SEGMENT
    { $$ = PTypeScalar( STM_SEGMENT ); }
    | Y___INT64
    { $$ = PTypeScalar( STM_INT64 ); }
    ;

qualified-type-specifier
    : Y_TYPE_NAME
    { $$ = sendType( $1 ); }
    | Y_SCOPED_TYPE_NAME
    { $$ = sendType( $1 ); }
    | template-class-id Y_TEMPLATE_SCOPED_TYPE_NAME
    { $$ = sendType( $2 ); PTypeRelease( $1 ); }
    | Y_GLOBAL_TYPE_NAME
    { $$ = sendType( $1 ); }
    | template-class-id
    ;

qualified-class-specifier
    : qualified-class-type
    {
        if( $$ == NULL ) {
            what = P_SYNTAX;
        }
    }
    ;

qualified-class-type
    : Y_TYPE_NAME
    { $$ = sendClass( $1 ); }
    | Y_GLOBAL_TYPE_NAME
    { $$ = sendClass( $1 ); }
    | Y_SCOPED_TYPE_NAME
    { $$ = sendClass( $1 ); }
    | template-class-id Y_TEMPLATE_SCOPED_TYPE_NAME
    { $$ = sendClass( $2 ); PTypeRelease( $1 ); }
    | template-class-id
    ;

typename-specifier
    : Y_TYPENAME Y_SCOPED_TYPE_NAME
    { $$ = sendType( $2 ); }
    | Y_TYPENAME template-class-id Y_TEMPLATE_SCOPED_TYPE_NAME
    { $$ = sendType( $3 ); PTypeRelease( $2 ); }
    ;

enum-specifier
    : enum-key enum-start enumerator-list Y_COMMA Y_RIGHT_BRACE
    {
        $$ = MakeEnumType( &(state->gstack->u.enumdata) );
        GStackPop( &(state->gstack) );
    }
    | enum-key enum-start enumerator-list         Y_RIGHT_BRACE
    {
        $$ = MakeEnumType( &(state->gstack->u.enumdata) );
        GStackPop( &(state->gstack) );
    }
    | enum-key enum-start                         Y_RIGHT_BRACE
    {
        $$ = MakeEnumType( &(state->gstack->u.enumdata) );
        GStackPop( &(state->gstack) );
    }
    | Y_ENUM enum-name
    {
        ENUM_DATA edata;
        InitEnumState( &edata, $2 );
        $$ = EnumReference( &edata );
    }
    ;

enum-start
    : Y_LEFT_BRACE
    { EnumDefine( &(state->gstack->u.enumdata) ); }
    ;

enum-key
    : Y_ENUM make-id
    {
        GStackPush( &(state->gstack), GS_ENUM_DATA );
        InitEnumState( &(state->gstack->u.enumdata), $2 );
    }
    | Y_ENUM
    {
        GStackPush( &(state->gstack), GS_ENUM_DATA );
        InitEnumState( &(state->gstack->u.enumdata), NULL );
    }
    ;

enumerator-list
    : enumerator
    | enumerator-list Y_COMMA enumerator
    ;

enumerator
    : make-id
    {
        MakeEnumMember( &(state->gstack->u.enumdata), $1, NULL );
    }
    | make-id Y_EQUAL constant-expression
    {
        MakeEnumMember( &(state->gstack->u.enumdata), $1, $3 );
    }
    ;

asm-declaration
    : Y_ASM Y_LEFT_PAREN asm-id Y_RIGHT_PAREN
    ;

asm-id
    : strings
    {
        StringTrash( $1->u.string );
        PTreeFree( $1 );
        CErr1( WARN_ASM_IGNORED );
    }
    ;

linkage-specification
    : Y_EXTERN linkage-id start-linkage-block linkage-body Y_RIGHT_BRACE
    { LinkagePop(); }
    ;
    
linkage-body
    : /* nothing */
    | might-restart-declarations
    ;