Changeset b067d9b for src/CodeGen

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

773db65, 9421f3d8

Parents:

7951100 (diff), 8364209 (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

Location:

src/CodeGen

Files:

• CodeGenerator.cc (modified) (39 diffs)
• CodeGenerator.h (modified) (5 diffs)
• GenType.cc (modified) (19 diffs)
• GenType.h (modified) (2 diffs)
• Options.h (added)
• module.mk (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat May  5 09:08:32 2018
-// Update Count     : 494
+// Last Modified On : Sat Oct 19 19:30:38 2019
+// Update Count     : 506
 //
 #include "CodeGenerator.h"
@@ -83 +83 @@
         void CodeGenerator::updateLocation( CodeLocation const & to ) {
                 // skip if linemarks shouldn't appear or if codelocation is unset
-                if ( !lineMarks || to.isUnset() ) return;
+                if ( !options.lineMarks || to.isUnset() ) return;
 
                 if ( currentLocation.followedBy( to, 0 ) ) {
@@ -116 +116 @@
         }
 
-        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks, bool printExprTypes ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ), printExprTypes( printExprTypes ), endl( *this ) {}
+        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks, bool printExprTypes ) : indent( 0, CodeGenerator::tabsize ), output( os ), printLabels( *this ), options( pretty, genC, lineMarks, printExprTypes ), endl( *this ) {}
+        CodeGenerator::CodeGenerator( std::ostream & os, const Options &options ) : indent( 0, CodeGenerator::tabsize ), output( os ), printLabels( *this ), options(options), endl( *this ) {}
 
         string CodeGenerator::mangleName( DeclarationWithType * decl ) {
                 // GCC builtins should always be printed unmangled
-                if ( pretty || decl->linkage.is_gcc_builtin ) return decl->name;
+                if ( options.pretty || decl->linkage.is_gcc_builtin ) return decl->name;
                 if ( decl->mangleName != "" ) {
                         // need to incorporate scope level in order to differentiate names for destructors
@@ -133 +134 @@
                 output << "__attribute__ ((";
                 for ( list< Attribute * >::iterator attr( attributes.begin() );; ) {
-                        output << (*attr)->get_name();
-                        if ( ! (*attr)->get_parameters().empty() ) {
+                        output << (*attr)->name;
+                        if ( ! (*attr)->parameters.empty() ) {
                                 output << "(";
-                                genCommaList( (*attr)->get_parameters().begin(), (*attr)->get_parameters().end() );
+                                genCommaList( (*attr)->parameters.begin(), (*attr)->parameters.end() );
                                 output << ")";
                         } // if
@@ -164 +165 @@
                 previsit( (BaseSyntaxNode *)node );
                 GuardAction( [this, node](){
-                        if ( printExprTypes ) {
-                                output << " /* " << genType( node->result, "", pretty, genC ) << " */ ";
+                        if ( options.printExprTypes && node->result ) {
+                                output << " /* " << genType( node->result, "", options ) << " */ ";
                         }
                 } );
@@ -173 +174 @@
         void CodeGenerator::postvisit( FunctionDecl * functionDecl ) {
                 // deleted decls should never be used, so don't print them
-                if ( functionDecl->isDeleted && genC ) return;
+                if ( functionDecl->isDeleted && options.genC ) return;
                 extension( functionDecl );
                 genAttributes( functionDecl->get_attributes() );
@@ -180 +181 @@
                 functionDecl->get_funcSpec().print( output );
 
-                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), pretty, genC );
+                Options subOptions = options;
+                subOptions.anonymousUnused = functionDecl->has_body();
+                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), subOptions );
 
                 asmName( functionDecl );
@@ -194 +197 @@
         void CodeGenerator::postvisit( ObjectDecl * objectDecl ) {
                 // deleted decls should never be used, so don't print them
-                if ( objectDecl->isDeleted && genC ) return;
-                if (objectDecl->get_name().empty() && genC ) {
+                if ( objectDecl->isDeleted && options.genC ) return;
+
+                // gcc allows an empty declarator (no name) for bit-fields and C states: 6.7.2.1 Structure and union specifiers,
+                // point 4, page 113: If the (bit field) value is zero, the declaration shall have no declarator.  For anything
+                // else, the anonymous name refers to the anonymous object for plan9 inheritance.
+                if ( objectDecl->get_name().empty() && options.genC && ! objectDecl->get_bitfieldWidth() ) {
                         // only generate an anonymous name when generating C code, otherwise it clutters the output too much
                         static UniqueName name = { "__anonymous_object" };
                         objectDecl->set_name( name.newName() );
+                        // Stops unused parameter warnings.
+                        if ( options.anonymousUnused ) {
+                                objectDecl->attributes.push_back( new Attribute( "unused" ) );
+                        }
                 }
 
@@ -205 +216 @@
 
                 handleStorageClass( objectDecl );
-                output << genType( objectDecl->get_type(), mangleName( objectDecl ), pretty, genC );
+                output << genType( objectDecl->get_type(), mangleName( objectDecl ), options.pretty, options.genC );
 
                 asmName( objectDecl );
@@ -224 +235 @@
 
         void CodeGenerator::handleAggregate( AggregateDecl * aggDecl, const std::string & kind ) {
-                if( ! aggDecl->get_parameters().empty() && ! genC ) {
+                if( ! aggDecl->parameters.empty() && ! options.genC ) {
                         // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
                         output << "forall(";
-                        genCommaList( aggDecl->get_parameters().begin(), aggDecl->get_parameters().end() );
+                        genCommaList( aggDecl->parameters.begin(), aggDecl->parameters.end() );
                         output << ")" << endl;
                         output << indent;
@@ -233 +244 @@
 
                 output << kind;
-                genAttributes( aggDecl->get_attributes() );
-                output << aggDecl->get_name();
+                genAttributes( aggDecl->attributes );
+                output << aggDecl->name;
 
                 if ( aggDecl->has_body() ) {
-                        std::list< Declaration * > & memb = aggDecl->get_members();
+                        std::list< Declaration * > & memb = aggDecl->members;
                         output << " {" << endl;
 
@@ -294 +305 @@
 
         void CodeGenerator::postvisit( TraitDecl * traitDecl ) {
-                assertf( ! genC, "TraitDecls should not reach code generation." );
+                assertf( ! options.genC, "TraitDecls should not reach code generation." );
                 extension( traitDecl );
                 handleAggregate( traitDecl, "trait " );
@@ -300 +311 @@
 
         void CodeGenerator::postvisit( TypedefDecl * typeDecl ) {
-                assertf( ! genC, "Typedefs are removed and substituted in earlier passes." );
+                assertf( ! options.genC, "Typedefs are removed and substituted in earlier passes." );
                 output << "typedef ";
-                output << genType( typeDecl->get_base(), typeDecl->get_name(), pretty, genC ) << endl;
+                output << genType( typeDecl->get_base(), typeDecl->get_name(), options ) << endl;
         }
 
         void CodeGenerator::postvisit( TypeDecl * typeDecl ) {
-                assertf( ! genC, "TypeDecls should not reach code generation." );
+                assertf( ! options.genC, "TypeDecls should not reach code generation." );
                 output << typeDecl->genTypeString() << " " << typeDecl->name;
                 if ( typeDecl->sized ) {
@@ -371 +382 @@
 
         void CodeGenerator::postvisit( ConstructorInit * init ){
-                assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
+                assertf( ! options.genC, "ConstructorInit nodes should not reach code generation." );
                 // pseudo-output for constructor/destructor pairs
                 output << "<ctorinit>{" << endl << ++indent << "ctor: ";
@@ -507 +518 @@
                                         } else {
                                                 // no constructors with 0 or more than 2 parameters
-                                                assertf( ! genC, "UntypedExpr constructor/destructor with 0 or more than 2 parameters." );
+                                                assertf( ! options.genC, "UntypedExpr constructor/destructor with 0 or more than 2 parameters." );
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
@@ -604 +615 @@
                         // an lvalue cast, this has been taken out.
                         output << "(";
-                        output << genType( castExpr->get_result(), "", pretty, genC );
+                        output << genType( castExpr->get_result(), "", options );
                         output << ")";
                 } // if
@@ -612 +623 @@
 
         void CodeGenerator::postvisit( KeywordCastExpr * castExpr ) {
-                assertf( ! genC, "KeywordCast should not reach code generation." );
+                assertf( ! options.genC, "KeywordCast should not reach code generation." );
                 extension( castExpr );
                 output << "((" << castExpr->targetString() << " &)";
@@ -620 +631 @@
 
         void CodeGenerator::postvisit( VirtualCastExpr * castExpr ) {
-                assertf( ! genC, "VirtualCastExpr should not reach code generation." );
+                assertf( ! options.genC, "VirtualCastExpr should not reach code generation." );
                 extension( castExpr );
                 output << "(virtual ";
@@ -628 +639 @@
 
         void CodeGenerator::postvisit( UntypedMemberExpr * memberExpr ) {
-                assertf( ! genC, "UntypedMemberExpr should not reach code generation." );
+                assertf( ! options.genC, "UntypedMemberExpr should not reach code generation." );
                 extension( memberExpr );
                 memberExpr->get_aggregate()->accept( *visitor );
@@ -661 +672 @@
                 output << "sizeof(";
                 if ( sizeofExpr->get_isType() ) {
-                        output << genType( sizeofExpr->get_type(), "", pretty, genC );
+                        output << genType( sizeofExpr->get_type(), "", options );
                 } else {
                         sizeofExpr->get_expr()->accept( *visitor );
@@ -673 +684 @@
                 output << "__alignof__(";
                 if ( alignofExpr->get_isType() ) {
-                        output << genType( alignofExpr->get_type(), "", pretty, genC );
+                        output << genType( alignofExpr->get_type(), "", options );
                 } else {
                         alignofExpr->get_expr()->accept( *visitor );
@@ -681 +692 @@
 
         void CodeGenerator::postvisit( UntypedOffsetofExpr * offsetofExpr ) {
-                assertf( ! genC, "UntypedOffsetofExpr should not reach code generation." );
+                assertf( ! options.genC, "UntypedOffsetofExpr should not reach code generation." );
                 output << "offsetof(";
-                output << genType( offsetofExpr->get_type(), "", pretty, genC );
+                output << genType( offsetofExpr->get_type(), "", options );
                 output << ", " << offsetofExpr->get_member();
                 output << ")";
@@ -691 +702 @@
                 // use GCC builtin
                 output << "__builtin_offsetof(";
-                output << genType( offsetofExpr->get_type(), "", pretty, genC );
+                output << genType( offsetofExpr->get_type(), "", options );
                 output << ", " << mangleName( offsetofExpr->get_member() );
                 output << ")";
@@ -697 +708 @@
 
         void CodeGenerator::postvisit( OffsetPackExpr * offsetPackExpr ) {
-                assertf( ! genC, "OffsetPackExpr should not reach code generation." );
-                output << "__CFA_offsetpack(" << genType( offsetPackExpr->get_type(), "", pretty, genC ) << ")";
+                assertf( ! options.genC, "OffsetPackExpr should not reach code generation." );
+                output << "__CFA_offsetpack(" << genType( offsetPackExpr->get_type(), "", options ) << ")";
         }
 
@@ -728 +739 @@
                 extension( commaExpr );
                 output << "(";
-                if ( genC ) {
+                if ( options.genC ) {
                         // arg1 of a CommaExpr is never used, so it can be safely cast to void to reduce gcc warnings.
                         commaExpr->set_arg1( new CastExpr( commaExpr->get_arg1() ) );
@@ -739 +750 @@
 
         void CodeGenerator::postvisit( TupleAssignExpr * tupleExpr ) {
-                assertf( ! genC, "TupleAssignExpr should not reach code generation." );
+                assertf( ! options.genC, "TupleAssignExpr should not reach code generation." );
                 tupleExpr->stmtExpr->accept( *visitor );
         }
 
         void CodeGenerator::postvisit( UntypedTupleExpr * tupleExpr ) {
-                assertf( ! genC, "UntypedTupleExpr should not reach code generation." );
+                assertf( ! options.genC, "UntypedTupleExpr should not reach code generation." );
                 extension( tupleExpr );
                 output << "[";
@@ -752 +763 @@
 
         void CodeGenerator::postvisit( TupleExpr * tupleExpr ) {
-                assertf( ! genC, "TupleExpr should not reach code generation." );
+                assertf( ! options.genC, "TupleExpr should not reach code generation." );
                 extension( tupleExpr );
                 output << "[";
@@ -760 +771 @@
 
         void CodeGenerator::postvisit( TupleIndexExpr * tupleExpr ) {
-                assertf( ! genC, "TupleIndexExpr should not reach code generation." );
+                assertf( ! options.genC, "TupleIndexExpr should not reach code generation." );
                 extension( tupleExpr );
                 tupleExpr->get_tuple()->accept( *visitor );
@@ -767 +778 @@
 
         void CodeGenerator::postvisit( TypeExpr * typeExpr ) {
-                // if ( genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
-                // assertf( ! genC, "TypeExpr should not reach code generation." );
-                if ( ! genC ) {
-                        output<< genType( typeExpr->get_type(), "", pretty, genC );
+                // if ( options.genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
+                // assertf( ! options.genC, "TypeExpr should not reach code generation." );
+                if ( ! options.genC ) {
+                        output << genType( typeExpr->get_type(), "", options );
                 }
         }
@@ -788 +799 @@
         void CodeGenerator::postvisit( CompoundLiteralExpr *compLitExpr ) {
                 assert( compLitExpr->get_result() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
-                output << "(" << genType( compLitExpr->get_result(), "", pretty, genC ) << ")";
+                output << "(" << genType( compLitExpr->get_result(), "", options ) << ")";
                 compLitExpr->get_initializer()->accept( *visitor );
         }
 
         void CodeGenerator::postvisit( UniqueExpr * unqExpr ) {
-                assertf( ! genC, "Unique expressions should not reach code generation." );
+                assertf( ! options.genC, "Unique expressions should not reach code generation." );
                 output << "unq<" << unqExpr->get_id() << ">{ ";
                 unqExpr->get_expr()->accept( *visitor );
@@ -829 +840 @@
 
         void CodeGenerator::postvisit( ConstructorExpr * expr ) {
-                assertf( ! genC, "Unique expressions should not reach code generation." );
+                assertf( ! options.genC, "Unique expressions should not reach code generation." );
                 expr->callExpr->accept( *visitor );
         }
 
         void CodeGenerator::postvisit( DeletedExpr * expr ) {
-                assertf( ! genC, "Deleted expressions should not reach code generation." );
+                assertf( ! options.genC, "Deleted expressions should not reach code generation." );
                 expr->expr->accept( *visitor );
         }
 
+        void CodeGenerator::postvisit( DefaultArgExpr * arg ) {
+                assertf( ! options.genC, "Default argument expressions should not reach code generation." );
+                arg->expr->accept( *visitor );
+        }
+
         void CodeGenerator::postvisit( GenericExpr * expr ) {
-                assertf( ! genC, "C11 _Generic expressions should not reach code generation." );
+                assertf( ! options.genC, "C11 _Generic expressions should not reach code generation." );
                 output << "_Generic(";
                 expr->control->accept( *visitor );
@@ -849 +865 @@
                                 output << "default: ";
                         } else {
-                                output << genType( assoc.type, "", pretty, genC ) << ": ";
+                                output << genType( assoc.type, "", options ) << ": ";
                         }
                         assoc.expr->accept( *visitor );
@@ -884 +900 @@
         void CodeGenerator::postvisit( ExprStmt * exprStmt ) {
                 assert( exprStmt );
-                if ( genC ) {
+                if ( options.genC ) {
                         // cast the top-level expression to void to reduce gcc warnings.
                         exprStmt->set_expr( new CastExpr( exprStmt->get_expr() ) );
@@ -994 +1010 @@
                   case BranchStmt::FallThrough:
                   case BranchStmt::FallThroughDefault:
-                        assertf( ! genC, "fallthru should not reach code generation." );
+                        assertf( ! options.genC, "fallthru should not reach code generation." );
                   output << "fallthru";
                         break;
                 } // switch
                 // print branch target for labelled break/continue/fallthru in debug mode
-                if ( ! genC && branchStmt->get_type() != BranchStmt::Goto ) {
+                if ( ! options.genC && branchStmt->get_type() != BranchStmt::Goto ) {
                         if ( ! branchStmt->get_target().empty() ) {
                                 output << " " << branchStmt->get_target();
@@ -1016 +1032 @@
 
         void CodeGenerator::postvisit( ThrowStmt * throwStmt ) {
-                assertf( ! genC, "Throw statements should not reach code generation." );
+                assertf( ! options.genC, "Throw statements should not reach code generation." );
 
                 output << ((throwStmt->get_kind() == ThrowStmt::Terminate) ?
@@ -1031 +1047 @@
         }
         void CodeGenerator::postvisit( CatchStmt * stmt ) {
-                assertf( ! genC, "Catch statements should not reach code generation." );
+                assertf( ! options.genC, "Catch statements should not reach code generation." );
 
                 output << ((stmt->get_kind() == CatchStmt::Terminate) ?
@@ -1048 +1064 @@
 
         void CodeGenerator::postvisit( WaitForStmt * stmt ) {
-                assertf( ! genC, "Waitfor statements should not reach code generation." );
+                assertf( ! options.genC, "Waitfor statements should not reach code generation." );
 
                 bool first = true;
@@ -1094 +1110 @@
 
         void CodeGenerator::postvisit( WithStmt * with ) {
-                if ( ! genC ) {
+                if ( ! options.genC ) {
                         output << "with ( ";
                         genCommaList( with->exprs.begin(), with->exprs.end() );
@@ -1160 +1176 @@
 
         void CodeGenerator::postvisit( ImplicitCtorDtorStmt * stmt ) {
-                assertf( ! genC, "ImplicitCtorDtorStmts should not reach code generation." );
+                assertf( ! options.genC, "ImplicitCtorDtorStmts should not reach code generation." );
                 stmt->callStmt->accept( *visitor );
         }

src/CodeGen/CodeGenerator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Aug 18 15:40:00 2017
-// Update Count     : 56
+// Last Modified On : Tue Apr 30 12:01:00 2019
+// Update Count     : 57
 //
 
@@ -20 +20 @@
 #include <string>                 // for string
 
+#include "CodeGen/Options.h"      // for Options
 #include "Common/Indenter.h"      // for Indenter
 #include "Common/PassVisitor.h"   // for PassVisitor
@@ -31 +32 @@
 
                 CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false, bool lineMarks = false, bool printExprTypes = false );
+                CodeGenerator( std::ostream &os, const Options &options );
 
                 //*** Turn off visit_children for all nodes
@@ -94 +96 @@
                 void postvisit( ConstructorExpr * );
                 void postvisit( DeletedExpr * );
+                void postvisit( DefaultArgExpr * );
                 void postvisit( GenericExpr * );
 
@@ -143 +146 @@
                 std::ostream & output;
                 LabelPrinter printLabels;
-                bool pretty = false;  // pretty print
-                bool genC = false;    // true if output has to be C code
-                bool lineMarks = false;
-                bool printExprTypes = false;
+                Options options;
         public:
                 LineEnder endl;

src/CodeGen/GenType.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 17 09:02:28 2017
-// Update Count     : 22
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed May  1 15:24:00 2019
+// Update Count     : 23
 //
 #include "GenType.h"
@@ -27 +27 @@
 namespace CodeGen {
         struct GenType : public WithVisitorRef<GenType>, public WithShortCircuiting {
-                GenType( const std::string &typeString, bool pretty = false, bool genC = false, bool lineMarks = false );
-                std::string get_typeString() const { return typeString; }
-                void set_typeString( const std::string &newValue ) { typeString = newValue; }
+                std::string typeString;
+                GenType( const std::string &typeString, const Options &options );
 
                 void previsit( BaseSyntaxNode * );
@@ -48 +47 @@
                 void postvisit( ZeroType * zeroType );
                 void postvisit( OneType * oneType );
+                void postvisit( GlobalScopeType * globalType );
                 void postvisit( TraitInstType * inst );
                 void postvisit( TypeofType * typeof );
+                void postvisit( QualifiedType * qualType );
 
           private:
@@ -56 +57 @@
                 void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
 
-                std::string typeString;
-                bool pretty = false; // pretty print
-                bool genC = false;   // generating C code?
-                bool lineMarks = false;
+                Options options;
         };
 
+        std::string genType( Type *type, const std::string &baseString, const Options &options ) {
+                PassVisitor<GenType> gt( baseString, options );
+                std::ostringstream os;
+
+                if ( ! type->get_attributes().empty() ) {
+                        PassVisitor<CodeGenerator> cg( os, options );
+                        cg.pass.genAttributes( type->get_attributes() );
+                } // if
+
+                type->accept( gt );
+                return os.str() + gt.pass.typeString;
+        }
+
         std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) {
-                PassVisitor<GenType> gt( baseString, pretty, genC, lineMarks );
-                std::ostringstream os;
-
-                if ( ! type->get_attributes().empty() ) {
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
-                        cg.pass.genAttributes( type->get_attributes() );
-                } // if
-
-                type->accept( gt );
-                return os.str() + gt.pass.get_typeString();
-        }
-
-  std::string genPrettyType( Type * type, const std::string & baseString ) {
-        return genType( type, baseString, true, false );
-  }
-
-        GenType::GenType( const std::string &typeString, bool pretty, bool genC, bool lineMarks ) : typeString( typeString ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
+                return genType( type, baseString, Options(pretty, genC, lineMarks, false ) );
+        }
+
+        std::string genPrettyType( Type * type, const std::string & baseString ) {
+                return genType( type, baseString, true, false );
+        }
+
+        GenType::GenType( const std::string &typeString, const Options &options ) : typeString( typeString ), options( options ) {}
 
         // *** BaseSyntaxNode
@@ -133 +135 @@
                 } // if
                 if ( dimension != 0 ) {
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        PassVisitor<CodeGenerator> cg( os, options );
                         dimension->accept( cg );
                 } else if ( isVarLen ) {
@@ -167 +169 @@
         void GenType::postvisit( ReferenceType * refType ) {
                 assert( refType->base != 0);
-                assertf( ! genC, "Reference types should not reach code generation." );
+                assertf( ! options.genC, "Reference types should not reach code generation." );
                 handleQualifiers( refType );
                 typeString = "&" + typeString;
@@ -195 +197 @@
                         } // if
                 } else {
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        PassVisitor<CodeGenerator> cg( os, options );
                         os << "(" ;
 
@@ -215 +217 @@
 
                 // add forall
-                if( ! funcType->forall.empty() && ! genC ) {
+                if( ! funcType->forall.empty() && ! options.genC ) {
                         // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
                         std::ostringstream os;
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        PassVisitor<CodeGenerator> cg( os, options );
                         os << "forall(";
                         cg.pass.genCommaList( funcType->forall.begin(), funcType->forall.end() );
@@ -229 +231 @@
                 if ( ! refType->parameters.empty() ) {
                         std::ostringstream os;
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        PassVisitor<CodeGenerator> cg( os, options );
                         os << "(";
                         cg.pass.genCommaList( refType->parameters.begin(), refType->parameters.end() );
@@ -240 +242 @@
         void GenType::postvisit( StructInstType * structInst )  {
                 typeString = structInst->name + handleGeneric( structInst ) + " " + typeString;
-                if ( genC ) typeString = "struct " + typeString;
+                if ( options.genC ) typeString = "struct " + typeString;
                 handleQualifiers( structInst );
         }
@@ -246 +248 @@
         void GenType::postvisit( UnionInstType * unionInst ) {
                 typeString = unionInst->name + handleGeneric( unionInst ) + " " + typeString;
-                if ( genC ) typeString = "union " + typeString;
+                if ( options.genC ) typeString = "union " + typeString;
                 handleQualifiers( unionInst );
         }
@@ -252 +254 @@
         void GenType::postvisit( EnumInstType * enumInst ) {
                 typeString = enumInst->name + " " + typeString;
-                if ( genC ) typeString = "enum " + typeString;
+                if ( options.genC ) typeString = "enum " + typeString;
                 handleQualifiers( enumInst );
         }
@@ -262 +264 @@
 
         void GenType::postvisit( TupleType * tupleType ) {
-                assertf( ! genC, "Tuple types should not reach code generation." );
+                assertf( ! options.genC, "Tuple types should not reach code generation." );
                 unsigned int i = 0;
                 std::ostringstream os;
@@ -268 +270 @@
                 for ( Type * t : *tupleType ) {
                         i++;
-                        os << genType( t, "", pretty, genC, lineMarks ) << (i == tupleType->size() ? "" : ", ");
+                        os << genType( t, "", options ) << (i == tupleType->size() ? "" : ", ");
                 }
                 os << "] ";
@@ -281 +283 @@
         void GenType::postvisit( ZeroType * zeroType ) {
                 // ideally these wouldn't hit codegen at all, but should be safe to make them ints
-                typeString = (pretty ? "zero_t " : "long int ") + typeString;
+                typeString = (options.pretty ? "zero_t " : "long int ") + typeString;
                 handleQualifiers( zeroType );
         }
@@ -287 +289 @@
         void GenType::postvisit( OneType * oneType ) {
                 // ideally these wouldn't hit codegen at all, but should be safe to make them ints
-                typeString = (pretty ? "one_t " : "long int ") + typeString;
+                typeString = (options.pretty ? "one_t " : "long int ") + typeString;
                 handleQualifiers( oneType );
         }
 
+        void GenType::postvisit( GlobalScopeType * globalType ) {
+                assertf( ! options.genC, "Global scope type should not reach code generation." );
+                handleQualifiers( globalType );
+        }
+
         void GenType::postvisit( TraitInstType * inst ) {
-                assertf( ! genC, "Trait types should not reach code generation." );
+                assertf( ! options.genC, "Trait types should not reach code generation." );
                 typeString = inst->name + " " + typeString;
                 handleQualifiers( inst );
@@ -299 +306 @@
         void GenType::postvisit( TypeofType * typeof ) {
                 std::ostringstream os;
-                PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                PassVisitor<CodeGenerator> cg( os, options );
                 os << "typeof(";
                 typeof->expr->accept( cg );
@@ -307 +314 @@
         }
 
+        void GenType::postvisit( QualifiedType * qualType ) {
+                assertf( ! options.genC, "Qualified types should not reach code generation." );
+                std::ostringstream os;
+                os << genType( qualType->parent, "", options ) << "." << genType( qualType->child, "", options ) << typeString;
+                typeString = os.str();
+                handleQualifiers( qualType );
+        }
+
         void GenType::handleQualifiers( Type * type ) {
                 if ( type->get_const() ) {
@@ -320 +335 @@
                         typeString = "_Atomic " + typeString;
                 } // if
-                if ( type->get_lvalue() && ! genC ) {
-                        // when not generating C code, print lvalue for debugging.
-                        typeString = "lvalue " + typeString;
-                }
         }
 } // namespace CodeGen

src/CodeGen/GenType.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 22:17:23 2017
-// Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr 30 11:47:00 2019
+// Update Count     : 3
 //
 
@@ -18 +18 @@
 #include <string>  // for string
 
+#include "CodeGen/Options.h" // for Options
+
 class Type;
 
 namespace CodeGen {
+        std::string genType( Type *type, const std::string &baseString, const Options &options );
         std::string genType( Type *type, const std::string &baseString, bool pretty = false, bool genC = false, bool lineMarks = false );
   std::string genPrettyType( Type * type, const std::string & baseString );

src/CodeGen/module.mk

@@ -18 +18 @@
 #       ArgTweak/Mutate.cc
 
-SRC +=  CodeGen/Generate.cc \
+SRC_CODEGEN = \
         CodeGen/CodeGenerator.cc \
+        CodeGen/FixMain.cc \
         CodeGen/GenType.cc \
-        CodeGen/FixNames.cc \
-        CodeGen/FixMain.cc \
         CodeGen/OperatorTable.cc
+
+
+SRC += $(SRC_CODEGEN) CodeGen/Generate.cc CodeGen/FixNames.cc
+SRCDEMANGLE += $(SRC_CODEGEN)