Ignore:
Timestamp:
Mar 14, 2017, 11:29:34 AM (7 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
4da6a6c, e496303
Parents:
68ac32e
Message:

change type of function specifier and storage class to bit fields

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/DeclarationNode.cc

    r68ac32e r08d5507b  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 17:28:56 2017
    13 // Update Count     : 937
     12// Last Modified On : Tue Mar 14 10:19:38 2017
     13// Update Count     : 964
    1414//
    1515
     
    9090        newnode->type = maybeClone( type );
    9191        newnode->storageClasses = storageClasses;
     92        newnode->funcSpecs = funcSpecs;
    9293        newnode->bitfieldWidth = maybeClone( bitfieldWidth );
    93         newnode->funcSpecs = funcSpecs;
    9494        newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) );
    9595        newnode->hasEllipsis = hasEllipsis;
     
    117117
    118118void DeclarationNode::print_StorageClass( std::ostream & output, StorageClasses storageClasses ) {
    119         if ( storageClasses.any() ) {                                                           // function specifiers?
     119        if ( storageClasses.val != 0 ) {                                        // storage classes ?
    120120                for ( unsigned int i = 0; i < DeclarationNode::NoStorageClass; i += 1 ) {
    121121                        if ( storageClasses[i] ) {
     
    127127
    128128void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpecifiers funcSpec ) {
    129         if ( funcSpec.any() ) {                                                         // function specifiers?
     129        if ( funcSpec.val != 0 ) {                                                      // function specifiers ?
    130130                for ( unsigned int i = 0; i < DeclarationNode::NoFuncSpecifier; i += 1 ) {
    131131                        if ( funcSpec[i] ) {
     
    202202
    203203
    204 DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
    205         DeclarationNode * newnode = new DeclarationNode;
    206         newnode->storageClasses[ sc ] = true;
     204DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClasses sc ) {
     205        DeclarationNode * newnode = new DeclarationNode;
     206        newnode->storageClasses = sc;
    207207        return newnode;
    208208} // DeclarationNode::newStorageClass
    209209
    210 DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifier fs ) {
    211         DeclarationNode * newnode = new DeclarationNode;
    212         newnode->funcSpecs[ fs ] = true;
     210DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifiers fs ) {
     211        DeclarationNode * newnode = new DeclarationNode;
     212        newnode->funcSpecs = fs;
    213213        return newnode;
    214214} // DeclarationNode::newFuncSpecifier
     
    459459        const TypeData::TypeQualifiers qsrc = src->typeQualifiers, qdst = dst->typeQualifiers; // optimization
    460460
    461         if ( (qsrc & qdst).any() ) {                                            // common qualifier ?
    462                 for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find common qualifiers
     461        if ( (qsrc & qdst).any() ) {                                            // duplicates ?
     462                for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find duplicates
    463463                        if ( qsrc[i] && qdst[i] ) {
    464464                                appendError( error, string( "duplicate " ) + DeclarationNode::typeQualifierNames[i] );
     
    469469
    470470void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
    471         if ( (funcSpecs & src->funcSpecs).any() ) {                     // common specifier ?
    472                 for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find common specifier
     471        if ( (funcSpecs.val & src->funcSpecs.val) != 0 ) {                // duplicates ?
     472                for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find duplicates
    473473                        if ( funcSpecs[i] && src->funcSpecs[i] ) {
    474474                                appendError( error, string( "duplicate " ) + DeclarationNode::funcSpecifierNames[i] );
     
    477477        } // if
    478478
    479         if ( storageClasses != 0 && src->storageClasses != 0 ) { // any reason to check ?
    480                 if ( (storageClasses & src->storageClasses).any() ) { // duplicates ?
     479        if ( storageClasses.val != 0 && src->storageClasses.val != 0 ) { // any reason to check ?
     480                if ( (storageClasses.val & src->storageClasses.val ) != 0 ) { // duplicates ?
    481481                        for ( unsigned int i = 0; i < NoStorageClass; i += 1 ) { // find duplicates
    482482                                if ( storageClasses[i] && src->storageClasses[i] ) {
     
    485485                        } // for
    486486                        // src is the new item being added and has a single bit
    487                 } else if ( ! src->storageClasses[ Threadlocal ] ) { // conflict ?
    488                         appendError( error, string( "conflicting " ) + storageClassNames[ffs( storageClasses.to_ulong() ) - 1] +
    489                                                  " & " + storageClassNames[ffs( src->storageClasses.to_ulong() ) - 1] );
    490                         src->storageClasses.reset();                            // FIX to preserve invariant of one basic storage specifier
     487                } else if ( ! src->storageClasses.is_threadlocal ) { // conflict ?
     488                        appendError( error, string( "conflicting " ) + storageClassNames[ffs( storageClasses.val ) - 1] +
     489                                                 " & " + storageClassNames[ffs( src->storageClasses.val ) - 1] );
     490                        src->storageClasses.val = 0;                            // FIX to preserve invariant of one basic storage specifier
    491491                } // if
    492492        } // if
     
    496496
    497497DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) {
    498         funcSpecs = funcSpecs | q->funcSpecs;
    499         storageClasses = storageClasses | q->storageClasses;
     498        funcSpecs.val = funcSpecs.val | q->funcSpecs.val;
     499        storageClasses.val = storageClasses.val | q->storageClasses.val;
    500500
    501501        for ( Attribute *attr: reverseIterate( q->attributes ) ) {
     
    10581058                //    inline _Noreturn int g( int i );  // allowed
    10591059                //    inline _Noreturn int i;                   // disallowed
    1060                 if ( type->kind != TypeData::Function && funcSpecs.any() ) {
     1060                if ( type->kind != TypeData::Function && funcSpecs.val != 0 ) {
    10611061                        throw SemanticError( "invalid function specifier for ", this );
    10621062                } // if
     
    10681068        //    inlne _Noreturn struct S { ... };         // disallowed
    10691069        //    inlne _Noreturn enum   E { ... };         // disallowed
    1070         if ( funcSpecs.any() ) {
     1070        if ( funcSpecs.val != 0 ) {
    10711071                throw SemanticError( "invalid function specifier for ", this );
    10721072        } // if
Note: See TracChangeset for help on using the changeset viewer.