Changeset 0b3b2ae for src/SymTab

Timestamp:

Jun 22, 2018, 3:43:19 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

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, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

ed34540

Parents:

c194661

git-author:

Rob Schluntz <rschlunt@…> (06/22/18 14:48:30)

git-committer:

Rob Schluntz <rschlunt@…> (06/22/18 15:43:19)

Message:

Minor code cleanup

File:

• src/SymTab/Validate.cc (modified) (13 diffs)

src/SymTab/Validate.cc

@@ -379 +379 @@
         void EnumAndPointerDecay::previsit( EnumDecl *enumDecl ) {
                 // Set the type of each member of the enumeration to be EnumConstant
-                for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
+                for ( std::list< Declaration * >::iterator i = enumDecl->members.begin(); i != enumDecl->members.end(); ++i ) {
                         ObjectDecl * obj = dynamic_cast< ObjectDecl * >( *i );
                         assert( obj );
-                        obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) );
+                        obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->name ) );
                 } // for
         }
@@ -539 +539 @@
                         SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
                 } // if
-                if ( traitDecl->get_parameters().size() != traitInst->get_parameters().size() ) {
+                if ( traitDecl->parameters.size() != traitInst->parameters.size() ) {
                         SemanticError( traitInst, "incorrect number of trait parameters: " );
                 } // if
@@ -715 +715 @@
                 if ( eliminator.pass.typedefNames.count( "size_t" ) ) {
                         // grab and remember declaration of size_t
-                        SizeType = eliminator.pass.typedefNames["size_t"].first->get_base()->clone();
+                        SizeType = eliminator.pass.typedefNames["size_t"].first->base->clone();
                 } else {
                         // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
@@ -727 +727 @@
                 // instances of typedef types will come here. If it is an instance
                 // of a typdef type, link the instance to its actual type.
-                TypedefMap::const_iterator def = typedefNames.find( typeInst->get_name() );
+                TypedefMap::const_iterator def = typedefNames.find( typeInst->name );
                 if ( def != typedefNames.end() ) {
                         Type *ret = def->second.first->base->clone();
@@ -744 +744 @@
                                         SemanticError( typeInst->location, "Cannot apply type parameters to base type of " + typeInst->name );
                                 }
-                                rtt->get_parameters().clear();
+                                rtt->parameters.clear();
                                 cloneAll( typeInst->parameters, rtt->parameters );
                                 mutateAll( rtt->parameters, *visitor );  // recursively fix typedefs on parameters
@@ -751 +751 @@
                         return ret;
                 } else {
-                        TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->get_name() );
+                        TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->name );
                         assertf( base != typedeclNames.end(), "Cannot find typedecl name %s", typeInst->name.c_str() );
                         typeInst->set_baseType( base->second );
@@ -773 +773 @@
 
         Declaration *EliminateTypedef::postmutate( TypedefDecl * tyDecl ) {
-                if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) {
+                if ( typedefNames.count( tyDecl->name ) == 1 && typedefNames[ tyDecl->name ].second == scopeLevel ) {
                         // typedef to the same name from the same scope
                         // must be from the same type
 
-                        Type * t1 = tyDecl->get_base();
-                        Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base();
+                        Type * t1 = tyDecl->base;
+                        Type * t2 = typedefNames[ tyDecl->name ].first->base;
                         if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) {
                                 SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
@@ -790 +790 @@
                         }
                 } else {
-                        typedefNames[ tyDecl->get_name() ] = std::make_pair( TypedefDeclPtr( tyDecl ), scopeLevel );
+                        typedefNames[ tyDecl->name ] = std::make_pair( TypedefDeclPtr( tyDecl ), scopeLevel );
                 } // if
 
@@ -802 +802 @@
                 // Note, qualifiers on the typedef are superfluous for the forward declaration.
 
-                Type *designatorType = tyDecl->get_base()->stripDeclarator();
+                Type *designatorType = tyDecl->base->stripDeclarator();
                 if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( designatorType ) ) {
-                        return new StructDecl( aggDecl->get_name(), DeclarationNode::Struct, noAttributes, tyDecl->get_linkage() );
+                        return new StructDecl( aggDecl->name, DeclarationNode::Struct, noAttributes, tyDecl->linkage );
                 } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( designatorType ) ) {
-                        return new UnionDecl( aggDecl->get_name(), noAttributes, tyDecl->get_linkage() );
+                        return new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage );
                 } else if ( EnumInstType *enumDecl = dynamic_cast< EnumInstType * >( designatorType ) ) {
-                        return new EnumDecl( enumDecl->get_name(), noAttributes, tyDecl->get_linkage() );
+                        return new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage );
                 } else {
                         return tyDecl->clone();
@@ -815 +815 @@
 
         void EliminateTypedef::premutate( TypeDecl * typeDecl ) {
-                TypedefMap::iterator i = typedefNames.find( typeDecl->get_name() );
+                TypedefMap::iterator i = typedefNames.find( typeDecl->name );
                 if ( i != typedefNames.end() ) {
                         typedefNames.erase( i ) ;
                 } // if
 
-                typedeclNames[ typeDecl->get_name() ] = typeDecl;
+                typedeclNames[ typeDecl->name ] = typeDecl;
         }
 
@@ -832 +832 @@
 
         DeclarationWithType *EliminateTypedef::postmutate( ObjectDecl * objDecl ) {
-                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->get_type() ) ) { // function type?
+                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->type ) ) { // function type?
                         // replace the current object declaration with a function declaration
-                        FunctionDecl * newDecl = new FunctionDecl( objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() );
-                        objDecl->get_attributes().clear();
+                        FunctionDecl * newDecl = new FunctionDecl( objDecl->name, objDecl->get_storageClasses(), objDecl->linkage, funtype, 0, objDecl->attributes, objDecl->get_funcSpec() );
+                        objDecl->attributes.clear();
                         objDecl->set_type( nullptr );
                         delete objDecl;
@@ -857 +857 @@
                 filter( compoundStmt->kids, [](Statement * stmt) {
                         if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
-                                if ( dynamic_cast< TypedefDecl * >( declStmt->get_decl() ) ) {
+                                if ( dynamic_cast< TypedefDecl * >( declStmt->decl ) ) {
                                         return true;
                                 } // if
@@ -1051 +1051 @@
 
         void ArrayLength::previsit( ObjectDecl * objDecl ) {
-                if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->type ) ) {
                         if ( at->get_dimension() ) return;
-                        if ( ListInit * init = dynamic_cast< ListInit * >( objDecl->get_init() ) ) {
-                                at->set_dimension( new ConstantExpr( Constant::from_ulong( init->get_initializers().size() ) ) );
+                        if ( ListInit * init = dynamic_cast< ListInit * >( objDecl->init ) ) {
+                                at->set_dimension( new ConstantExpr( Constant::from_ulong( init->initializers.size() ) ) );
                         }
                 }