Changeset 4bda2cf for src/SymTab

Timestamp:

Feb 9, 2018, 10:06:16 AM (7 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, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

b8a52f5

Parents:

ff878b7

git-author:

Rob Schluntz <rschlunt@…> (02/08/18 16:25:33)

git-committer:

Rob Schluntz <rschlunt@…> (02/09/18 10:06:16)

Message:

Refactor FixFunction?, add error for void foo(void, ...)

Location:

src/SymTab

Files:

• FixFunction.cc (modified) (2 diffs)
• FixFunction.h (modified) (1 diff)
• Validate.cc (modified) (3 diffs)

src/SymTab/FixFunction.cc

@@ -36 +36 @@
         }
 
+        // xxx - this passes on void[], e.g.
+        //   void foo(void [10]);
+        // does not cause an error
+
         Type * FixFunction::postmutate(ArrayType *arrayType) {
                 // need to recursively mutate the base type in order for multi-dimensional arrays to work.
@@ -62 +66 @@
         void FixFunction::premutate(ZeroType *) { visit_children = false; }
         void FixFunction::premutate(OneType *) { visit_children = false; }
+
+        bool fixFunction( DeclarationWithType *& dwt ) {
+                PassVisitor<FixFunction> fixer;
+                dwt = dwt->acceptMutator( fixer );
+                return fixer.pass.isVoid;
+        }
 } // namespace SymTab
 

src/SymTab/FixFunction.h

@@ -47 +47 @@
                 bool isVoid;
         };
+
+        bool fixFunction( DeclarationWithType *& );
 } // namespace SymTab
 

src/SymTab/Validate.cc

@@ -351 +351 @@
         namespace {
                 template< typename DWTList >
-                void fixFunctionList( DWTList & dwts, FunctionType * func ) {
-                        // the only case in which "void" is valid is where it is the only one in the list; then it should be removed
-                        // entirely. other fix ups are handled by the FixFunction class
-                        typedef typename DWTList::iterator DWTIterator;
-                        DWTIterator begin( dwts.begin() ), end( dwts.end() );
-                        if ( begin == end ) return;
-                        PassVisitor<FixFunction> fixer;
-                        DWTIterator i = begin;
-                        *i = (*i)->acceptMutator( fixer );
-                        if ( fixer.pass.isVoid ) {
-                                DWTIterator j = i;
-                                ++i;
-                                delete *j;
-                                dwts.erase( j );
-                                if ( i != end ) {
-                                        throw SemanticError( "invalid type void in function type ", func );
-                                } // if
-                        } else {
-                                ++i;
-                                for ( ; i != end; ++i ) {
-                                        PassVisitor<FixFunction> fixer;
-                                        *i = (*i)->acceptMutator( fixer );
-                                        if ( fixer.pass.isVoid ) {
-                                                throw SemanticError( "invalid type void in function type ", func );
-                                        } // if
-                                } // for
-                        } // if
+                void fixFunctionList( DWTList & dwts, bool isVarArgs, FunctionType * func ) {
+                        auto nvals = dwts.size();
+                        bool containsVoid = false;
+                        for ( auto & dwt : dwts ) {
+                                // fix each DWT and record whether a void was found
+                                containsVoid |= fixFunction( dwt );
+                        }
+
+                        // the only case in which "void" is valid is where it is the only one in the list
+                        if ( containsVoid && ( nvals > 1 || isVarArgs ) ) {
+                                throw SemanticError( "invalid type void in function type ", func );
+                        }
+
+                        // one void is the only thing in the list; remove it.
+                        if ( containsVoid ) {
+                                delete dwts.front();
+                                dwts.clear();
+                        }
                 }
         }
@@ -383 +374 @@
         void EnumAndPointerDecay::previsit( FunctionType *func ) {
                 // Fix up parameters and return types
-                fixFunctionList( func->get_parameters(), func );
-                fixFunctionList( func->get_returnVals(), func );
+                fixFunctionList( func->parameters, func->isVarArgs, func );
+                fixFunctionList( func->returnVals, false, func );
         }
 
@@ -626 +617 @@
                         // apply FixFunction to every assertion to check for invalid void type
                         for ( DeclarationWithType *& assertion : type->assertions ) {
-                                PassVisitor<FixFunction> fixer;
-                                assertion = assertion->acceptMutator( fixer );
-                                if ( fixer.pass.isVoid ) {
+                                bool isVoid = fixFunction( assertion );
+                                if ( isVoid ) {
                                         throw SemanticError( "invalid type void in assertion of function ", node );
                                 } // if