Changeset 862658a

Timestamp:

Jan 11, 2023, 1:43:30 PM (15 months ago)

Author:

caparsons <caparson@…>

Branches:

ADT, ast-experimental, master

Children:

42b739d7

Parents:

b49310f (diff), 8fcf921 (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

Files:

• CodeGen/CodeGenerator.cc (modified) (1 diff)
• CodeGen/GenType.cc (modified) (1 diff)
• SymTab/Mangler.cc (modified) (5 diffs)

src/CodeGen/CodeGenerator.cc

@@ -283 +283 @@
                                 assert( obj );
                                 output << "static ";
-                                output << genType(enumDecl->base, "", options) << " const ";
-                                output << mangleName( obj ) << " ";
+                                output << genType(enumDecl->base, mangleName( obj ), options);
                                 output << " = ";
                                 output << "(" << genType(enumDecl->base, "", options) << ")";

src/CodeGen/GenType.cc

@@ -255 +255 @@
         void GenType::postvisit( EnumInstType * enumInst ) {
                 if ( enumInst->baseEnum && enumInst->baseEnum->base ) {
-                        typeString = genType(enumInst->baseEnum->base, "", options) + typeString;
+                        typeString = genType(enumInst->baseEnum->base, typeString, options);
                 } else {
                         typeString = enumInst->name + " " + typeString;

src/SymTab/Mangler.cc

@@ -439 +439 @@
                   private:
                         void mangleDecl( const ast::DeclWithType *declaration );
-                        void mangleRef( const ast::BaseInstType *refType, std::string prefix );
+                        void mangleRef( const ast::BaseInstType *refType, const std::string & prefix );
 
                         void printQualifiers( const ast::Type *type );
@@ -535 +535 @@
                 }
 
-                __attribute__((unused))
-                inline std::vector< ast::ptr< ast::Type > > getTypes( const std::vector< ast::ptr< ast::DeclWithType > > & decls ) {
-                        std::vector< ast::ptr< ast::Type > > ret;
-                        std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
-                                                        std::mem_fun( &ast::DeclWithType::get_type ) );
-                        return ret;
-                }
-
                 void Mangler_new::postvisit( const ast::FunctionType * functionType ) {
                         printQualifiers( functionType );
@@ -558 +550 @@
                 }
 
-                void Mangler_new::mangleRef( const ast::BaseInstType * refType, std::string prefix ) {
+                void Mangler_new::mangleRef(
+                                const ast::BaseInstType * refType, const std::string & prefix ) {
                         printQualifiers( refType );
 
                         mangleName += prefix + std::to_string( refType->name.length() ) + refType->name;
 
-                        if ( mangleGenericParams ) {
-                                if ( ! refType->params.empty() ) {
-                                        mangleName += "_";
-                                        for ( const ast::Expr * param : refType->params ) {
-                                                auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
-                                                assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
-                                                maybeAccept( paramType->type.get(), *visitor );
-                                        }
-                                        mangleName += "_";
+                        if ( mangleGenericParams && ! refType->params.empty() ) {
+                                mangleName += "_";
+                                for ( const ast::Expr * param : refType->params ) {
+                                        auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
+                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
+                                        maybeAccept( paramType->type.get(), *visitor );
                                 }
+                                mangleName += "_";
                         }
                 }
@@ -656 +647 @@
                 }
 
+                // For debugging:
                 __attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
                         for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
@@ -665 +657 @@
                         // skip if not including qualifiers
                         if ( typeMode ) return;
-                        if ( auto ptype = dynamic_cast< const ast::FunctionType * >(type) ) {
-                                if ( ! ptype->forall.empty() ) {
-                                        std::list< std::string > assertionNames;
-                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
-                                        mangleName += Encoding::forall;
-                                        for ( auto & decl : ptype->forall ) {
-                                                switch ( decl->kind ) {
-                                                  case ast::TypeDecl::Kind::Dtype:
-                                                        dcount++;
-                                                        break;
-                                                  case ast::TypeDecl::Kind::Ftype:
-                                                        fcount++;
-                                                        break;
-                                                  case ast::TypeDecl::Kind::Ttype:
-                                                        vcount++;
-                                                        break;
-                                                  default:
-                                                        assertf( false, "unimplemented kind for type variable %s", SymTab::Mangler::Encoding::typeVariables[decl->kind].c_str() );
-                                                } // switch
-                                                varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
-                                        } // for
-                                        for ( auto & assert : ptype->assertions ) {
-                                                assertionNames.push_back( ast::Pass<Mangler_new>::read(
-                                                        assert->var.get(),
-                                                        mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums ) );
-                                                acount++;
-                                        } // for
-                                        mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
-                                        for(const auto & a : assertionNames) mangleName += a;
-//                                      std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
-                                        mangleName += "_";
-                                } // if
+                        auto funcType = dynamic_cast<const ast::FunctionType *>( type );
+                        if ( funcType && !funcType->forall.empty() ) {
+                                std::list< std::string > assertionNames;
+                                int dcount = 0, fcount = 0, vcount = 0, acount = 0;
+                                mangleName += Encoding::forall;
+                                for ( auto & decl : funcType->forall ) {
+                                        switch ( decl->kind ) {
+                                        case ast::TypeDecl::Dtype:
+                                                dcount++;
+                                                break;
+                                        case ast::TypeDecl::Ftype:
+                                                fcount++;
+                                                break;
+                                        case ast::TypeDecl::Ttype:
+                                                vcount++;
+                                                break;
+                                        default:
+                                                assertf( false, "unimplemented kind for type variable %s", SymTab::Mangler::Encoding::typeVariables[decl->kind].c_str() );
+                                        } // switch
+                                        varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
+                                } // for
+                                for ( auto & assert : funcType->assertions ) {
+                                        assertionNames.push_back( ast::Pass<Mangler_new>::read(
+                                                assert->var.get(),
+                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums ) );
+                                        acount++;
+                                } // for
+                                mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
+                                for ( const auto & a : assertionNames ) mangleName += a;
+                                mangleName += "_";
                         } // if
                         if ( ! inFunctionType ) {