Changeset 843054c2 for src/Parser


Ignore:
Timestamp:
May 21, 2015, 9:44:51 PM (7 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, string, with_gc
Children:
76f2e97f
Parents:
a08ba92
Message:

licencing: seventh groups of files

Location:
src/Parser
Files:
20 moved

Legend:

Unmodified
Added
Removed
  • src/Parser/DeclarationNode.cc

    ra08ba92 r843054c2  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat May 16 12:38:20 2015
    13 // Update Count     : 4
     12// Last Modified On : Thu May 21 09:28:54 2015
     13// Update Count     : 13
    1414//
    1515
     
    751751                        newnode->type = ret;
    752752                        return newnode;
    753                 } else {
    754                         return 0;
    755                 }
    756         } else {
    757                 return 0;
    758         }
     753                } // if
     754        } // if
     755        return 0;
    759756}
    760757
     
    770767                                if ( decl ) {
    771768                                        *out++ = decl;
    772                                 }
    773                         }
     769                                } // if
     770                        } // if
    774771                        Declaration *decl = cur->build();
    775772                        if ( decl ) {
    776773                                *out++ = decl;
    777                         }
     774                        } // if
    778775                } catch( SemanticError &e ) {
    779776                        errors.append( e );
    780                 }
     777                } // try
    781778                cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
    782         }
     779        } // while
    783780        if ( ! errors.isEmpty() ) {
    784781                throw errors;
    785         }
     782        } // if
    786783}
    787784
     
    811808                                        UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
    812809                                        *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
    813                                 }
    814                         }
     810                                } // if
     811                        } // if
    815812                } catch( SemanticError &e ) {
    816813                        errors.append( e );
    817                 }
     814                } // try
    818815                cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
    819         }
     816        } // while
    820817        if ( ! errors.isEmpty() ) {
    821818                throw errors;
    822         }
     819        } // if
    823820}
    824821
     
    832829                } catch( SemanticError &e ) {
    833830                        errors.append( e );
    834                 }
     831                } // try
    835832                cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
    836         }
     833        } // while
    837834        if ( ! errors.isEmpty() ) {
    838835                throw errors;
    839         }
     836        } // if
    840837}
    841838
    842839Declaration *DeclarationNode::build() const {
    843 
    844         if ( ! type ) {
    845                 if ( buildInline() ) {
    846                         throw SemanticError( "invalid inline specification in declaration of ", this );
    847                 } else {
    848                         return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) );
    849                 }
    850         } else {
     840        if ( type ) {
    851841                Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildInline(), linkage, maybeBuild< Initializer >(initializer) );
    852842                return newDecl;
    853         }
    854         // we should never get here
    855         assert( false );
    856         return 0;
     843        } // if
     844        if ( ! buildInline() ) {
     845                return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) );
     846        } // if
     847        throw SemanticError( "invalid inline specification in declaration of ", this );
    857848}
    858849
     
    904895        for ( std::list< StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
    905896                assert( unsigned( *i ) < sizeof( scMap ) / sizeof( scMap[0] ) );
    906                 if ( *i == Inline ) continue;
    907                 if ( ret == Declaration::NoStorageClass ) {
    908                         ret = scMap[ *i ];
    909                 } else {
     897          if ( *i == Inline ) continue;
     898          if ( ret != Declaration::NoStorageClass ) {
    910899                        throw SemanticError( "invalid combination of storage classes in declaration of ", this );
    911900                }
     901                ret = scMap[ *i ];
    912902        }
    913903        return ret;
     
    916906bool DeclarationNode::buildInline() const {
    917907        std::list< StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), Inline );
    918         if ( first == storageClasses.end() ) {
    919                 return false;
    920         } else {
    921                 std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline );
    922                 if ( next == storageClasses.end() ) {
    923                         return true;
    924                 } else {
    925                         throw SemanticError( "duplicate inline specification in declaration of ", this );
    926                 }
    927         }
    928         // we should never get here
    929         return false;
     908  if ( first == storageClasses.end() ) return false;
     909        std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline );
     910  if ( next == storageClasses.end() ) return true;
     911        throw SemanticError( "duplicate inline specification in declaration of ", this );
    930912}
    931913
  • src/Parser/module.mk

    ra08ba92 r843054c2  
    88## module.mk --
    99##
    10 ## Author           : Peter A. Buhr
     10## Author           : Richard C. Bilson
    1111## Created On       : Sat May 16 15:29:09 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Sat May 16 15:29:50 2015
    14 ## Update Count     : 1
     13## Last Modified On : Thu May 21 21:17:07 2015
     14## Update Count     : 2
    1515###############################################################################
    1616
Note: See TracChangeset for help on using the changeset viewer.