Changes in src/AST/Decl.cpp [b230091:7edd5c1]

File:

• src/AST/Decl.cpp (modified) (4 diffs)

src/AST/Decl.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Thu May 9 10:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jan 12 16:54:55 2021
-// Update Count     : 23
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu May  5 12:10:00 2022
+// Update Count     : 24
 //
 
@@ -53 +53 @@
 // --- FunctionDecl
 
-FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name, 
+FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name,
         std::vector<ptr<TypeDecl>>&& forall,
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
@@ -74 +74 @@
         }
         this->type = ftype;
+}
+
+FunctionDecl::FunctionDecl( const CodeLocation & location, const std::string & name,
+        std::vector<ptr<TypeDecl>>&& forall, std::vector<ptr<DeclWithType>>&& assertions,
+        std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+        CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+: DeclWithType( location, name, storage, linkage, std::move(attrs), fs ),
+                params( std::move(params) ), returns( std::move(returns) ),
+                type_params( std::move( forall) ), assertions( std::move( assertions ) ),
+                type( nullptr ), stmts( stmts ) {
+        FunctionType * type = new FunctionType( (isVarArgs) ? VariableArgs : FixedArgs );
+        for ( auto & param : this->params ) {
+                type->params.emplace_back( param->get_type() );
+        }
+        for ( auto & ret : this->returns ) {
+                type->returns.emplace_back( ret->get_type() );
+        }
+        for ( auto & param : this->type_params ) {
+                type->forall.emplace_back( new TypeInstType( param ) );
+        }
+        for ( auto & assertion : this->assertions ) {
+                type->assertions.emplace_back(
+                        new VariableExpr( assertion->location, assertion ) );
+        }
+        this->type = type;
 }
 
@@ -136 +162 @@
 
         auto it = enumValues.find( enumerator->name );
+        
         if ( it != enumValues.end() ) {
-                value = it->second;
+                        
+                // Handle typed enum by casting the value in (C++) compiler
+                // if ( base ) { // A typed enum
+                //      if ( const BasicType * bt = dynamic_cast<const BasicType *>(base) ) {
+                //              switch( bt->kind ) {
+                //                      case BasicType::Kind::Bool:     value = (bool) it->second; break;
+                //                      case BasicType::Kind::Char: value = (char) it->second; break;
+                //                      case BasicType::Kind::SignedChar: value = (signed char) it->second; break;
+                //                      case BasicType::Kind::UnsignedChar: value = (unsigned char) it->second; break;
+                //                      case BasicType::Kind::ShortSignedInt: value = (short signed int) it->second; break;
+                //                      case BasicType::Kind::SignedInt: value = (signed int) it->second; break;
+                //                      case BasicType::Kind::UnsignedInt: value = (unsigned int) it->second; break;
+                //                      case BasicType::Kind::LongSignedInt: value = (long signed int) it->second; break;
+                //                      case BasicType::Kind::LongUnsignedInt: value = (long unsigned int) it->second; break;
+                //                      case BasicType::Kind::LongLongSignedInt: value = (long long signed int) it->second; break;
+                //                      case BasicType::Kind::LongLongUnsignedInt: value = (long long unsigned int) it->second; break; 
+                //                      // TODO: value should be able to handle long long unsigned int
+
+                //                      default:
+                //                      value = it->second;
+                //              }
+                //      }
+                // } else {
+                        value = it->second;
+                //}
+
                 return true;
         }