Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/DeclarationNode.cc

    r43c89a7 ra7c90d4  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 23 22:21:06 2017
    13 // Update Count     : 775
     12// Last Modified On : Tue Mar  7 08:02:09 2017
     13// Update Count     : 936
    1414//
    1515
    … …  
    1919#include <algorithm>
    2020#include <cassert>
     21#include <strings.h>                                                                    // ffs
    2122
    2223#include "TypeData.h"
    … …  
    3233
    3334// These must remain in the same order as the corresponding DeclarationNode enumerations.
    34 const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };
    35 const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };
    36 const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };
    37 const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };
    38 const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };
    39 const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };
    40 const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" };
    41 const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };
    42 const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
     35const char * DeclarationNode::storageClassNames[] = { "extern", "static", "auto", "register", "_Thread_local", "NoStorageClassNames" };
     36const char * DeclarationNode::funcSpecifierNames[] = { "inline", "fortran", "_Noreturn", "NoFunctionSpecifierNames" };
     37const char * DeclarationNode::typeQualifierNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic", "NoTypeQualifierNames" };
     38const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" };
     39const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
     40const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
     41const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };
     42const char * DeclarationNode::aggregateNames[] = { "struct", "union", "context", "NoAggregateNames" };
     43const char * DeclarationNode::typeClassNames[] = { "otype", "dtype", "ftype", "NoTypeClassNames" };
     44const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "NoBuiltinTypeNames" };
    4345
    4446UniqueName DeclarationNode::anonymous( "__anonymous" );
    … …  
    4850DeclarationNode::DeclarationNode() :
    4951                type( nullptr ),
    50                 storageClass( NoStorageClass ),
    5152                bitfieldWidth( nullptr ),
    52                 isInline( false ),
    53                 isNoreturn( false ),
    5453                hasEllipsis( false ),
    5554                linkage( ::linkage ),
    … …  
    9089
    9190        newnode->type = maybeClone( type );
    92         newnode->storageClass = storageClass;
     91        newnode->storageClasses = storageClasses;
    9392        newnode->bitfieldWidth = maybeClone( bitfieldWidth );
    94         newnode->isInline = isInline;
    95         newnode->isNoreturn = isNoreturn;
     93        newnode->funcSpecs = funcSpecs;
    9694        newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) );
    9795        newnode->hasEllipsis = hasEllipsis;
    … …  
    118116}
    119117
     118void DeclarationNode::print_StorageClass( std::ostream & output, StorageClasses storageClasses ) {
     119        if ( storageClasses.any() ) {                                                           // function specifiers?
     120                for ( unsigned int i = 0; i < DeclarationNode::NoStorageClass; i += 1 ) {
     121                        if ( storageClasses[i] ) {
     122                                output << DeclarationNode::storageClassNames[i] << ' ';
     123                        } // if
     124                } // for
     125        } // if
     126} // print_StorageClass
     127
     128void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpecifiers funcSpec ) {
     129        if ( funcSpec.any() ) {                                                         // function specifiers?
     130                for ( unsigned int i = 0; i < DeclarationNode::NoFuncSpecifier; i += 1 ) {
     131                        if ( funcSpec[i] ) {
     132                                output << DeclarationNode::funcSpecifierNames[i] << ' ';
     133                        } // if
     134                } // for
     135        } // if
     136} // print_FuncSpec
     137
    120138void DeclarationNode::print( std::ostream &os, int indent ) const {
    121139        os << string( indent, ' ' );
    … …  
    130148        } // if
    131149
    132         if ( storageClass != NoStorageClass ) os << DeclarationNode::storageName[storageClass] << ' ';
    133         if ( isInline ) os << DeclarationNode::storageName[Inline] << ' ';
    134         if ( isNoreturn ) os << DeclarationNode::storageName[Noreturn] << ' ';
     150        print_StorageClass( os, storageClasses );
     151        print_FuncSpec( os, funcSpecs );
     152
    135153        if ( type ) {
    136154                type->print( os, indent );
    … …  
    183201} // DeclarationNode::newFunction
    184202
    185 DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) {
     203
     204DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
     205        DeclarationNode * newnode = new DeclarationNode;
     206        newnode->storageClasses[ sc ] = true;
     207        return newnode;
     208} // DeclarationNode::newStorageClass
     209
     210DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifier fs ) {
     211        DeclarationNode * newnode = new DeclarationNode;
     212        newnode->funcSpecs[ fs ] = true;
     213        return newnode;
     214} // DeclarationNode::newFuncSpecifier
     215
     216DeclarationNode * DeclarationNode::newTypeQualifier( TypeQualifier tq ) {
    186217        DeclarationNode * newnode = new DeclarationNode;
    187218        newnode->type = new TypeData();
    188         newnode->type->qualifiers[ q ] = 1;
     219        newnode->type->typeQualifiers[ tq ] = true;
    189220        return newnode;
    190221} // DeclarationNode::newQualifier
     222
     223DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
     224        DeclarationNode * newnode = new DeclarationNode;
     225        newnode->type = new TypeData( TypeData::Basic );
     226        newnode->type->basictype = bt;
     227        return newnode;
     228} // DeclarationNode::newBasicType
     229
     230DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
     231        DeclarationNode * newnode = new DeclarationNode;
     232        newnode->type = new TypeData( TypeData::Basic );
     233        newnode->type->complextype = ct;
     234        return newnode;
     235} // DeclarationNode::newComplexType
     236
     237DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
     238        DeclarationNode * newnode = new DeclarationNode;
     239        newnode->type = new TypeData( TypeData::Basic );
     240        newnode->type->signedness = sn;
     241        return newnode;
     242} // DeclarationNode::newSignedNess
     243
     244DeclarationNode * DeclarationNode::newLength( Length lnth ) {
     245        DeclarationNode * newnode = new DeclarationNode;
     246        newnode->type = new TypeData( TypeData::Basic );
     247        newnode->type->length = lnth;
     248        return newnode;
     249} // DeclarationNode::newLength
    191250
    192251DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) {
    … …  
    196255        return newnode;
    197256} // DeclarationNode::newForall
    198 
    199 DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
    200         DeclarationNode * newnode = new DeclarationNode;
    201         newnode->storageClass = sc;
    202         return newnode;
    203 } // DeclarationNode::newStorageClass
    204 
    205 DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
    206         DeclarationNode * newnode = new DeclarationNode;
    207         newnode->type = new TypeData( TypeData::Basic );
    208         newnode->type->basictype = bt;
    209         return newnode;
    210 } // DeclarationNode::newBasicType
    211 
    212 DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
    213         DeclarationNode * newnode = new DeclarationNode;
    214         newnode->type = new TypeData( TypeData::Basic );
    215         newnode->type->complextype = ct;
    216         return newnode;
    217 } // DeclarationNode::newComplexType
    218 
    219 DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
    220         DeclarationNode * newnode = new DeclarationNode;
    221         newnode->type = new TypeData( TypeData::Basic );
    222         newnode->type->signedness = sn;
    223         return newnode;
    224 } // DeclarationNode::newSignedNess
    225 
    226 DeclarationNode * DeclarationNode::newLength( Length lnth ) {
    227         DeclarationNode * newnode = new DeclarationNode;
    228         newnode->type = new TypeData( TypeData::Basic );
    229         newnode->type->length = lnth;
    230         return newnode;
    231 } // DeclarationNode::newLength
    232257
    233258DeclarationNode * DeclarationNode::newFromTypedef( string * name ) {
    … …  
    428453
    429454void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
    430         TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
     455        const TypeData::TypeQualifiers qsrc = src->typeQualifiers, qdst = dst->typeQualifiers; // optimization
    431456
    432457        if ( (qsrc & qdst).any() ) {                                            // common qualifier ?
    433                 for ( int i = 0; i < NoQualifier; i += 1 ) {    // find common qualifiers
     458                for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find common qualifiers
    434459                        if ( qsrc[i] && qdst[i] ) {
    435                                 appendError( error, string( "duplicate " ) + DeclarationNode::qualifierName[i] );
     460                                appendError( error, string( "duplicate " ) + DeclarationNode::typeQualifierNames[i] );
    436461                        } // if
    437462                } // for
    438         } // if
     463        } // for
    439464} // DeclarationNode::checkQualifiers
    440465
    441 void DeclarationNode::checkStorageClasses( DeclarationNode * q ) {
    442         if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) {
    443                 if ( storageClass == q->storageClass ) {                // duplicate qualifier
    444                         appendError( error, string( "duplicate " ) + storageName[ storageClass ] );
    445                 } else {                                                                                // only one storage class
    446                         appendError( error, string( "conflicting " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ] );
    447                         q->storageClass = storageClass;                         // FIX ERROR, prevent assertions from triggering
    448                 } // if
    449         } // if
    450         appendError( error, q->error );
    451 } // DeclarationNode::checkStorageClasses
    452 
    453 DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) {
    454         isInline = isInline || q->isInline;
    455         isNoreturn = isNoreturn || q->isNoreturn;
    456         // do not overwrite an existing value with NoStorageClass
    457         if ( q->storageClass != NoStorageClass ) {
    458                 assert( storageClass == NoStorageClass || storageClass == q->storageClass );
    459                 storageClass = q->storageClass;
    460         } // if
     466void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
     467        if ( (funcSpecs & src->funcSpecs).any() ) {                     // common specifier ?
     468                for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find common specifier
     469                        if ( funcSpecs[i] && src->funcSpecs[i] ) {
     470                                appendError( error, string( "duplicate " ) + DeclarationNode::funcSpecifierNames[i] );
     471                        } // if
     472                } // for
     473        } // if
     474
     475        if ( storageClasses != 0 && src->storageClasses != 0 ) { // any reason to check ?
     476                if ( (storageClasses & src->storageClasses).any() ) { // duplicates ?
     477                        for ( unsigned int i = 0; i < NoStorageClass; i += 1 ) { // find duplicates
     478                                if ( storageClasses[i] && src->storageClasses[i] ) {
     479                                        appendError( error, string( "duplicate " ) + storageClassNames[i] );
     480                                } // if
     481                        } // for
     482                        // src is the new item being added and has a single bit
     483                } else if ( ! src->storageClasses[ Threadlocal ] ) { // conflict ?
     484                        appendError( error, string( "conflicting " ) + storageClassNames[ffs( storageClasses.to_ulong() ) - 1] +
     485                                                 " & " + storageClassNames[ffs( src->storageClasses.to_ulong() ) - 1] );
     486                        src->storageClasses.reset();                            // FIX to preserve invariant of one basic storage specifier
     487                } // if
     488        } // if
     489
     490        appendError( error, src->error );
     491} // DeclarationNode::checkSpecifiers
     492
     493DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) {
     494        funcSpecs = funcSpecs | q->funcSpecs;
     495        storageClasses = storageClasses | q->storageClasses;
    461496
    462497        for ( Attribute *attr: reverseIterate( q->attributes ) ) {
    … …  
    464499        } // for
    465500        return this;
    466 } // DeclarationNode::copyStorageClasses
     501} // DeclarationNode::copySpecifiers
    467502
    468503static void addQualifiersToType( TypeData *&src, TypeData * dst ) {
    … …  
    481516                src = nullptr;
    482517        } else {
    483                 dst->qualifiers |= src->qualifiers;
     518                dst->typeQualifiers |= src->typeQualifiers;
    484519        } // if
    485520} // addQualifiersToType
    … …  
    488523        if ( ! q ) { delete q; return this; }
    489524
    490         checkStorageClasses( q );
    491         copyStorageClasses( q );
     525        checkSpecifiers( q );
     526        copySpecifiers( q );
    492527
    493528        if ( ! q->type ) {
    … …  
    518553        } // if
    519554
    520         checkQualifiers( q->type, type );
     555        checkQualifiers( type, q->type );
    521556        addQualifiersToType( q->type, type );
    522557
    … …  
    539574                switch ( dst->kind ) {
    540575                  case TypeData::Unknown:
    541                         src->qualifiers |= dst->qualifiers;
     576                        src->typeQualifiers |= dst->typeQualifiers;
    542577                        dst = src;
    543578                        src = nullptr;
    544579                        break;
    545580                  case TypeData::Basic:
    546                         dst->qualifiers |= src->qualifiers;
     581                        dst->typeQualifiers |= src->typeQualifiers;
    547582                        if ( src->kind != TypeData::Unknown ) {
    548583                                assert( src->kind == TypeData::Basic );
    … …  
    551586                                        dst->basictype = src->basictype;
    552587                                } else if ( src->basictype != DeclarationNode::NoBasicType )
    553                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
     588                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: ", src );
    554589
    555590                                if ( dst->complextype == DeclarationNode::NoComplexType ) {
    556591                                        dst->complextype = src->complextype;
    557592                                } else if ( src->complextype != DeclarationNode::NoComplexType )
    558                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
     593                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: ", src );
    559594
    560595                                if ( dst->signedness == DeclarationNode::NoSignedness ) {
    561596                                        dst->signedness = src->signedness;
    562597                                } else if ( src->signedness != DeclarationNode::NoSignedness )
    563                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
     598                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: ", src );
    564599
    565600                                if ( dst->length == DeclarationNode::NoLength ) {
    … …  
    568603                                        dst->length = DeclarationNode::LongLong;
    569604                                } else if ( src->length != DeclarationNode::NoLength )
    570                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
     605                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: ", src );
    571606                        } // if
    572607                        break;
    … …  
    580615                                        dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
    581616                                } // if
    582                                 dst->base->qualifiers |= src->qualifiers;
     617                                dst->base->typeQualifiers |= src->typeQualifiers;
    583618                                src = nullptr;
    584619                                break;
    … …  
    599634DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) {
    600635        if ( o ) {
    601                 checkStorageClasses( o );
    602                 copyStorageClasses( o );
     636                checkSpecifiers( o );
     637                copySpecifiers( o );
    603638                if ( o->type ) {
    604639                        if ( ! type ) {
    … …  
    612647                                                type->aggInst.hoistType = o->type->enumeration.body;
    613648                                        } // if
    614                                         type->qualifiers |= o->type->qualifiers;
     649                                        type->typeQualifiers |= o->type->typeQualifiers;
    615650                                } else {
    616651                                        type = o->type;
    … …  
    768803                                        p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
    769804                                } // if
    770                                 p->type->base->qualifiers |= type->qualifiers;
     805                                p->type->base->typeQualifiers |= type->typeQualifiers;
    771806                                break;
    772807
    … …  
    805840                                        lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
    806841                                } // if
    807                                 lastArray->base->qualifiers |= type->qualifiers;
     842                                lastArray->base->typeQualifiers |= type->typeQualifiers;
    808843                                break;
    809844                          default:
    … …  
    854889        DeclarationNode * newnode = new DeclarationNode;
    855890        newnode->type = maybeClone( type );
    856         assert( storageClass == NoStorageClass );
    857         newnode->copyStorageClasses( this );
     891        newnode->copySpecifiers( this );
    858892        assert( newName );
    859893        newnode->name = newName;
    … …  
    864898        if ( ! o ) return nullptr;
    865899
    866         o->copyStorageClasses( this );
     900        o->copySpecifiers( this );
    867901        if ( type ) {
    868902                TypeData * srcType = type;
    … …  
    956990                                } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
    957991                                        StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
    958                                         auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
     992                                        auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
    959993                                        obj->location = cur->location;
    960994                                        * out++ = obj;
    … …  
    962996                                } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
    963997                                        UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
    964                                         auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
     998                                        auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
    965999                                        obj->location = cur->location;
    9661000                                        * out++ = obj;
    … …  
    10051039        } // if
    10061040
    1007 //      if ( variable.name ) {
    10081041        if ( variable.tyClass != NoTypeClass ) {
    10091042                static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype };
    10101043                assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." );
    10111044                assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
    1012 //              TypeDecl * ret = new TypeDecl( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
    1013                 TypeDecl * ret = new TypeDecl( *name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
     1045                TypeDecl * ret = new TypeDecl( *name, DeclarationNode::StorageClasses(), nullptr, kindMap[ variable.tyClass ] );
    10141046                buildList( variable.assertions, ret->get_assertions() );
    10151047                return ret;
    … …  
    10171049
    10181050        if ( type ) {
    1019                 return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
    1020         } // if
    1021 
    1022         if ( ! isInline && ! isNoreturn ) {
    1023                 assertf( name, "ObjectDecl are assumed to have names\n" );
    1024                 return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
    1025         } // if
    1026 
    1027         throw SemanticError( "invalid function specifier ", this );
     1051                // Function specifiers can only appear on a function definition/declaration.
     1052                //
     1053                //    inline _Noreturn int f();                 // allowed
     1054                //    inline _Noreturn int g( int i );  // allowed
     1055                //    inline _Noreturn int i;                   // disallowed
     1056                if ( type->kind != TypeData::Function && funcSpecs.any() ) {
     1057                        throw SemanticError( "invalid function specifier for ", this );
     1058                } // if
     1059                return buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
     1060        } // if
     1061
     1062        // SUE's cannot have function specifiers, either
     1063        //
     1064        //    inlne _Noreturn struct S { ... };         // disallowed
     1065        //    inlne _Noreturn enum   E { ... };         // disallowed
     1066        if ( funcSpecs.any() ) {
     1067                throw SemanticError( "invalid function specifier for ", this );
     1068        } // if
     1069        assertf( name, "ObjectDecl must a have name\n" );
     1070        return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
    10281071}
    10291072
    … …  
    10321075
    10331076        if ( attr.expr ) {
    1034 //              return new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() );
    10351077                return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes );
    10361078        } else if ( attr.type ) {
    1037 //              return new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() );
    10381079                return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes );
    10391080        } // if
Note: See TracChangeset for help on using the changeset viewer.