Ignore:
Timestamp:
Mar 17, 2017, 1:36:27 PM (7 years ago)
Author:
Thierry Delisle <tdelisle@…>
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:
31ce3d6
Parents:
b32ada31 (diff), 946bcca (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/DeclarationNode.cc

    rb32ada31 r7c70089  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 16 09:10:57 2017
    13 // Update Count     : 1007
     12// Last Modified On : Fri Mar 17 08:46:05 2017
     13// Update Count     : 1017
    1414//
    1515
    … …  
    1919#include <algorithm>
    2020#include <cassert>
    21 #include <strings.h>                                                                    // ffs
    2221
    2322#include "TypeData.h"
    … …  
    243242
    244243DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
     244        assert( name );
    245245        DeclarationNode * newnode = new DeclarationNode;
    246246        newnode->type = new TypeData( TypeData::Aggregate );
    247247        newnode->type->aggregate.kind = kind;
    248         if ( name ) {
    249                 newnode->type->aggregate.name = name;
    250         } else {                                                                                        // anonymous aggregate ?
    251                 newnode->type->aggregate.name = new string( anonymous.newName() );
    252         } // if
     248        newnode->type->aggregate.name = name;
    253249        newnode->type->aggregate.actuals = actuals;
    254250        newnode->type->aggregate.fields = fields;
    … …  
    258254
    259255DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants, bool body ) {
     256        assert( name );
    260257        DeclarationNode * newnode = new DeclarationNode;
    261258        newnode->type = new TypeData( TypeData::Enum );
    262         if ( name ) {
    263                 newnode->type->enumeration.name = name;
    264         } else {                                                                                        // anonymous aggregate ?
    265                 newnode->type->enumeration.name = new string( anonymous.newName() );
    266         } // if
     259        newnode->type->enumeration.name = name;
    267260        newnode->type->enumeration.constants = constants;
    268261        newnode->type->enumeration.body = body;
    … …  
    436429        const Type::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
    437430
    438         if ( (qsrc.val & qdst.val) != 0 ) {                                     // duplicates ?
     431        if ( (qsrc & qdst).any() ) {                                            // duplicates ?
    439432                for ( unsigned int i = 0; i < Type::NumTypeQualifier; i += 1 ) { // find duplicates
    440433                        if ( qsrc[i] && qdst[i] ) {
    441                                 appendError( error, string( "duplicate " ) + Type::Qualifiers::Names[i] );
     434                                appendError( error, string( "duplicate " ) + Type::QualifiersNames[i] );
    442435                        } // if
    443436                } // for
    … …  
    446439
    447440void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
    448         if ( (funcSpecs.val & src->funcSpecs.val) != 0 ) {      // duplicates ?
     441        if ( (funcSpecs & src->funcSpecs).any() ) {                     // duplicates ?
    449442                for ( unsigned int i = 0; i < Type::NumFuncSpecifier; i += 1 ) { // find duplicates
    450443                        if ( funcSpecs[i] && src->funcSpecs[i] ) {
    451                                 appendError( error, string( "duplicate " ) + Type::FuncSpecifiers::Names[i] );
     444                                appendError( error, string( "duplicate " ) + Type::FuncSpecifiersNames[i] );
    452445                        } // if
    453446                } // for
    … …  
    455448
    456449        if ( storageClasses.any() && src->storageClasses.any() ) { // any reason to check ?
    457                 if ( (storageClasses.val & src->storageClasses.val ) != 0 ) { // duplicates ?
     450                if ( (storageClasses & src->storageClasses ).any() ) { // duplicates ?
    458451                        for ( unsigned int i = 0; i < Type::NumStorageClass; i += 1 ) { // find duplicates
    459452                                if ( storageClasses[i] && src->storageClasses[i] ) {
    460                                         appendError( error, string( "duplicate " ) + Type::StorageClasses::Names[i] );
     453                                        appendError( error, string( "duplicate " ) + Type::StorageClassesNames[i] );
    461454                                } // if
    462455                        } // for
    463456                        // src is the new item being added and has a single bit
    464457                } else if ( ! src->storageClasses.is_threadlocal ) { // conflict ?
    465                         appendError( error, string( "conflicting " ) + Type::StorageClasses::Names[ffs( storageClasses.val ) - 1] +
    466                                                  " & " + Type::StorageClasses::Names[ffs( src->storageClasses.val ) - 1] );
    467                         src->storageClasses.val = 0;                            // FIX to preserve invariant of one basic storage specifier
     458                        appendError( error, string( "conflicting " ) + Type::StorageClassesNames[storageClasses.ffs()] +
     459                                                 " & " + Type::StorageClassesNames[src->storageClasses.ffs()] );
     460                        src->storageClasses.reset();                            // FIX to preserve invariant of one basic storage specifier
    468461                } // if
    469462        } // if
    … …  
    473466
    474467DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) {
    475         funcSpecs.val |= q->funcSpecs.val;
    476         storageClasses.val |= q->storageClasses.val;
     468        funcSpecs |= q->funcSpecs;
     469        storageClasses |= q->storageClasses;
    477470
    478471        for ( Attribute *attr: reverseIterate( q->attributes ) ) {
    … …  
    497490                src = nullptr;
    498491        } else {
    499                 dst->qualifiers += src->qualifiers;
     492                dst->qualifiers |= src->qualifiers;
    500493        } // if
    501494} // addQualifiersToType
    … …  
    555548                switch ( dst->kind ) {
    556549                  case TypeData::Unknown:
    557                         src->qualifiers += dst->qualifiers;
     550                        src->qualifiers |= dst->qualifiers;
    558551                        dst = src;
    559552                        src = nullptr;
    560553                        break;
    561554                  case TypeData::Basic:
    562                         dst->qualifiers += src->qualifiers;
     555                        dst->qualifiers |= src->qualifiers;
    563556                        if ( src->kind != TypeData::Unknown ) {
    564557                                assert( src->kind == TypeData::Basic );
    … …  
    596589                                        dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
    597590                                } // if
    598                                 dst->base->qualifiers += src->qualifiers;
     591                                dst->base->qualifiers |= src->qualifiers;
    599592                                src = nullptr;
    600593                                break;
    … …  
    628621                                                type->aggInst.hoistType = o->type->enumeration.body;
    629622                                        } // if
    630                                         type->qualifiers += o->type->qualifiers;
     623                                        type->qualifiers |= o->type->qualifiers;
    631624                                } else {
    632625                                        type = o->type;
    … …  
    784777                                        p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
    785778                                } // if
    786                                 p->type->base->qualifiers += type->qualifiers;
     779                                p->type->base->qualifiers |= type->qualifiers;
    787780                                break;
    788781
    … …  
    821814                                lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
    822815                        } // if
    823                         lastArray->base->qualifiers += type->qualifiers;
     816                        lastArray->base->qualifiers |= type->qualifiers;
    824817                        break;
    825818                  default:
Note: See TracChangeset for help on using the changeset viewer.