Changeset d28524a for src

Timestamp:

Jun 23, 2022, 1:41:39 PM (4 years ago)

Author:

caparsons <caparson@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

3322180, a6cfb4d, fd365da

Parents:

4e83bb7 (diff), 9dad5b3 (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:

• AST/Pass.impl.hpp (modified) (1 diff)
• Common/ResolvProtoDump.cpp (modified) (1 diff)
• GenPoly/GenPoly.cc (modified) (1 diff)
• InitTweak/GenInit.cc (modified) (1 diff)
• Parser/lex.ll (modified) (1 diff)
• Parser/parser.yy (modified) (6 diffs)
• ResolvExpr/CurrentObject.cc (modified) (1 diff)
• SymTab/Mangler.cc (modified) (1 diff)
• SymTab/ValidateType.cc (modified) (1 diff)
• SynTree/Type.h (modified) (2 diffs)

src/AST/Pass.impl.hpp

@@ -648 +648 @@
         if ( __visit_children() ) {
                 // unlike structs, traits, and unions, enums inject their members into the global scope
+                maybe_accept( node, &EnumDecl::base );
                 maybe_accept( node, &EnumDecl::params     );
                 maybe_accept( node, &EnumDecl::members    );

src/Common/ResolvProtoDump.cpp

@@ -227 +227 @@
         }
 
-        void previsit( const ast::EnumInstType * enumInst) {
+        void previsit( const ast::EnumInstType * ) {
                 // TODO: Add the meaningful text representation of typed enum
                 ss << (int)ast::BasicType::SignedInt;

src/GenPoly/GenPoly.cc

@@ -64 +64 @@
                 }
 
-                __attribute__((ununsed))
+                __attribute__((unused))
                 bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
                         for (auto &param : params) {

src/InitTweak/GenInit.cc

@@ -642 +642 @@
 
 ast::ConstructorInit * genCtorInit( const CodeLocation & loc, const ast::ObjectDecl * objDecl ) {
-        // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor for each 
+        // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor for each
         // constructable object
         InitExpander_new srcParam{ objDecl->init }, nullParam{ (const ast::Init *)nullptr };
         ast::ptr< ast::Expr > dstParam = new ast::VariableExpr(loc, objDecl);
-        
-        ast::ptr< ast::Stmt > ctor = SymTab::genImplicitCall( 
+
+        ast::ptr< ast::Stmt > ctor = SymTab::genImplicitCall(
                 srcParam, dstParam, loc, "?{}", objDecl );
-        ast::ptr< ast::Stmt > dtor = SymTab::genImplicitCall( 
-                nullParam, dstParam, loc, "^?{}", objDecl, 
+        ast::ptr< ast::Stmt > dtor = SymTab::genImplicitCall(
+                nullParam, dstParam, loc, "^?{}", objDecl,
                 SymTab::LoopBackward );
-        
+
         // check that either both ctor and dtor are present, or neither
         assert( (bool)ctor == (bool)dtor );
 
         if ( ctor ) {
-                // need to remember init expression, in case no ctors exist. If ctor does exist, want to 
+                // need to remember init expression, in case no ctors exist. If ctor does exist, want to
                 // use ctor expression instead of init.
-                ctor.strict_as< ast::ImplicitCtorDtorStmt >(); 
+                ctor.strict_as< ast::ImplicitCtorDtorStmt >();
                 dtor.strict_as< ast::ImplicitCtorDtorStmt >();
 

src/Parser/lex.ll

@@ -82 +82 @@
 // Stop warning due to incorrectly generated flex code.
 #pragma GCC diagnostic ignored "-Wsign-compare"
+
+// lex uses __null in a boolean context, it's fine.
+#pragma GCC diagnostic ignored "-Wnull-conversion"
 %}
 

src/Parser/parser.yy

@@ -56 +56 @@
 
 #include "SynTree/Attribute.h"     // for Attribute
+
+// lex uses __null in a boolean context, it's fine.
+#pragma GCC diagnostic ignored "-Wparentheses-equality"
 
 extern DeclarationNode * parseTree;
@@ -1240 +1243 @@
                 {
                         $$ = new StatementNode( build_while( new CondCtl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) );
-                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
                 }
         | WHILE '(' conditional_declaration ')' statement       %prec THEN
@@ -1251 +1254 @@
                 {
                         $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) );
-                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
                 }
         | DO statement WHILE '(' comma_expression ')' ';'
@@ -1262 +1265 @@
                 {
                         $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) );
-                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
                 }
         | FOR '(' for_control_expression_list ')' statement     %prec THEN
@@ -2394 +2397 @@
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
                 {
-                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) 
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 )
                         { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 
@@ -2841 +2844 @@
                         linkage = LinkageSpec::update( yylloc, linkage, $2 );
                 }
-          up external_definition down 
+          up external_definition down
                 {
                         linkage = linkageStack.top();

src/ResolvExpr/CurrentObject.cc

@@ -73 +73 @@
                 virtual void setPosition( std::list< Expression * > & designators ) = 0;
 
-                /// retrieve the list of possible Type/Designaton pairs for the current position in the currect object
+                /// retrieve the list of possible Type/Designation pairs for the current position in the currect object
                 virtual std::list<InitAlternative> operator*() const = 0;
 

src/SymTab/Mangler.cc

@@ -537 +537 @@
                 }
 
+                __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;

src/SymTab/ValidateType.cc

@@ -222 +222 @@
         // visit enum members first so that the types of self-referencing members are updated properly
         // Replace the enum base; right now it works only for StructEnum
-        if ( enumDecl->base && dynamic_cast<TypeInstType*>(enumDecl->base) ) {
-                std::string baseName = static_cast<TypeInstType*>(enumDecl->base)->name;
-                const StructDecl * st = local_indexer->lookupStruct( baseName );
-                if ( st ) {
-                        enumDecl->base = new StructInstType(Type::Qualifiers(),const_cast<StructDecl *>(st)); // Just linking in the node
+        if ( enumDecl->base ) {
+                if ( const TypeInstType * base = dynamic_cast< TypeInstType * >(enumDecl->base) ) {
+                        if ( const StructDecl * decl = local_indexer->lookupStruct( base->name ) ) {
+                                enumDecl->base = new StructInstType( Type::Qualifiers(), const_cast< StructDecl * >( decl ) ); // Just linking in the node
+                        }
+                } else if ( const PointerType * ptr = dynamic_cast< PointerType * >(enumDecl->base) ) {
+                        if ( const TypeInstType * ptrBase = dynamic_cast< TypeInstType * >( ptr->base ) ) {
+                                if ( const StructDecl * decl = local_indexer->lookupStruct( ptrBase->name ) ) {
+                                        enumDecl->base = new PointerType( Type::Qualifiers(),
+                                                new StructInstType( Type::Qualifiers(), const_cast< StructDecl * >( decl ) ) );
+                                }
+                        }
                 }
         }
+        
         if ( enumDecl->body ) {
                 ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->name );

src/SynTree/Type.h

@@ -274 +274 @@
 class PointerType : public Type {
   public:
-        Type *base;
+        Type * base;
 
         // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
@@ -516 +516 @@
         typedef ReferenceToType Parent;
   public:
-        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
-        // where the union used in this type is actually defined
+        // this decl is not "owned" by the enum inst; it is merely a pointer to elsewhere in the tree,
+        // where the enum used in this type is actually defined
         EnumDecl *baseEnum = nullptr;