Changes in src/SymTab/FixFunction.cc [0bd3faf:b2ecd48]

File:

• src/SymTab/FixFunction.cc (modified) (3 diffs)

src/SymTab/FixFunction.cc

@@ -22 +22 @@
 #include "AST/Type.hpp"
 #include "Common/utility.h"       // for copy
+#include "SynTree/Declaration.h"  // for FunctionDecl, ObjectDecl, Declarati...
+#include "SynTree/Expression.h"   // for Expression
+#include "SynTree/Type.h"         // for ArrayType, PointerType, Type, Basic...
 
 namespace SymTab {
+        class FixFunction_old : public WithShortCircuiting {
+                typedef Mutator Parent;
+          public:
+                FixFunction_old() : isVoid( false ) {}
+
+                void premutate(FunctionDecl *functionDecl);
+                DeclarationWithType* postmutate(FunctionDecl *functionDecl);
+
+                Type * postmutate(ArrayType * arrayType);
+
+                void premutate(ArrayType * arrayType);
+                void premutate(VoidType * voidType);
+                void premutate(BasicType * basicType);
+                void premutate(PointerType * pointerType);
+                void premutate(StructInstType * aggregateUseType);
+                void premutate(UnionInstType * aggregateUseType);
+                void premutate(EnumInstType * aggregateUseType);
+                void premutate(TraitInstType * aggregateUseType);
+                void premutate(TypeInstType * aggregateUseType);
+                void premutate(TupleType * tupleType);
+                void premutate(VarArgsType * varArgsType);
+                void premutate(ZeroType * zeroType);
+                void premutate(OneType * oneType);
+
+                bool isVoid;
+        };
+
+        DeclarationWithType * FixFunction_old::postmutate(FunctionDecl *functionDecl) {
+                // can't delete function type because it may contain assertions, so transfer ownership to new object
+                ObjectDecl *pointer = new ObjectDecl( functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, new PointerType( Type::Qualifiers(), functionDecl->type ), nullptr, functionDecl->attributes );
+                pointer->location = functionDecl->location;
+                functionDecl->attributes.clear();
+                functionDecl->type = nullptr;
+                delete functionDecl;
+                return pointer;
+        }
+
+        // xxx - this passes on void[], e.g.
+        //   void foo(void [10]);
+        // does not cause an error
+
+        Type * FixFunction_old::postmutate(ArrayType *arrayType) {
+                // need to recursively mutate the base type in order for multi-dimensional arrays to work.
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic );
+                pointerType->location = arrayType->location;
+                arrayType->base = nullptr;
+                arrayType->dimension = nullptr;
+                delete arrayType;
+                return pointerType;
+        }
+
+        void FixFunction_old::premutate(VoidType *) {
+                isVoid = true;
+        }
+
+        void FixFunction_old::premutate(FunctionDecl *) { visit_children = false; }
+        void FixFunction_old::premutate(ArrayType *) { visit_children = false; }
+        void FixFunction_old::premutate(BasicType *) { visit_children = false; }
+        void FixFunction_old::premutate(PointerType *) { visit_children = false; }
+        void FixFunction_old::premutate(StructInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(UnionInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(EnumInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(TraitInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(TypeInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(TupleType *) { visit_children = false; }
+        void FixFunction_old::premutate(VarArgsType *) { visit_children = false; }
+        void FixFunction_old::premutate(ZeroType *) { visit_children = false; }
+        void FixFunction_old::premutate(OneType *) { visit_children = false; }
+
+        bool fixFunction( DeclarationWithType *& dwt ) {
+                PassVisitor<FixFunction_old> fixer;
+                dwt = dwt->acceptMutator( fixer );
+                return fixer.pass.isVoid;
+        }
 
 namespace {
-        struct FixFunction final : public ast::WithShortCircuiting {
+        struct FixFunction_new final : public ast::WithShortCircuiting {
                 bool isVoid = false;
 
@@ -70 +147 @@
 
 const ast::DeclWithType * fixFunction( const ast::DeclWithType * dwt, bool & isVoid ) {
-        ast::Pass< FixFunction > fixer;
+        ast::Pass< FixFunction_new > fixer;
         dwt = dwt->accept( fixer );
         isVoid |= fixer.core.isVoid;
@@ -77 +154 @@
 
 const ast::Type * fixFunction( const ast::Type * type, bool & isVoid ) {
-        ast::Pass< FixFunction > fixer;
+        ast::Pass< FixFunction_new > fixer;
         type = type->accept( fixer );
         isVoid |= fixer.core.isVoid;