source: src/SymTab/FixFunction.cc @ e116db3

ADTast-experimentalpthread-emulation
Last change on this file since e116db3 was 1931bb01, checked in by Andrew Beach <ajbeach@…>, 2 years ago

Converted 'Validate A' to the new AST. There some utility changes as well.

  • Property mode set to 100644
File size: 6.2 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// FixFunction.cc --
8//
9// Author           : Richard C. Bilson
10// Created On       : Sun May 17 16:19:49 2015
11// Last Modified By : Andrew Beach
12// Last Modified On : Tue Jul 12 14:28:00 2022
13// Update Count     : 7
14//
15
16#include "FixFunction.h"
17
18#include <list>                   // for list
19
20#include "AST/Decl.hpp"
21#include "AST/Pass.hpp"
22#include "AST/Type.hpp"
23#include "Common/utility.h"       // for maybeClone, copy
24#include "SynTree/Declaration.h"  // for FunctionDecl, ObjectDecl, Declarati...
25#include "SynTree/Expression.h"   // for Expression
26#include "SynTree/Type.h"         // for ArrayType, PointerType, Type, Basic...
27
28namespace SymTab {
29        class FixFunction_old : public WithShortCircuiting {
30                typedef Mutator Parent;
31          public:
32                FixFunction_old() : isVoid( false ) {}
33
34                void premutate(FunctionDecl *functionDecl);
35                DeclarationWithType* postmutate(FunctionDecl *functionDecl);
36
37                Type * postmutate(ArrayType * arrayType);
38
39                void premutate(ArrayType * arrayType);
40                void premutate(VoidType * voidType);
41                void premutate(BasicType * basicType);
42                void premutate(PointerType * pointerType);
43                void premutate(StructInstType * aggregateUseType);
44                void premutate(UnionInstType * aggregateUseType);
45                void premutate(EnumInstType * aggregateUseType);
46                void premutate(TraitInstType * aggregateUseType);
47                void premutate(TypeInstType * aggregateUseType);
48                void premutate(TupleType * tupleType);
49                void premutate(VarArgsType * varArgsType);
50                void premutate(ZeroType * zeroType);
51                void premutate(OneType * oneType);
52
53                bool isVoid;
54        };
55
56        DeclarationWithType * FixFunction_old::postmutate(FunctionDecl *functionDecl) {
57                // can't delete function type because it may contain assertions, so transfer ownership to new object
58                ObjectDecl *pointer = new ObjectDecl( functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, new PointerType( Type::Qualifiers(), functionDecl->type ), nullptr, functionDecl->attributes );
59                pointer->location = functionDecl->location;
60                functionDecl->attributes.clear();
61                functionDecl->type = nullptr;
62                delete functionDecl;
63                return pointer;
64        }
65
66        // xxx - this passes on void[], e.g.
67        //   void foo(void [10]);
68        // does not cause an error
69
70        Type * FixFunction_old::postmutate(ArrayType *arrayType) {
71                // need to recursively mutate the base type in order for multi-dimensional arrays to work.
72                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic );
73                pointerType->location = arrayType->location;
74                arrayType->base = nullptr;
75                arrayType->dimension = nullptr;
76                delete arrayType;
77                return pointerType;
78        }
79
80        void FixFunction_old::premutate(VoidType *) {
81                isVoid = true;
82        }
83
84        void FixFunction_old::premutate(FunctionDecl *) { visit_children = false; }
85        void FixFunction_old::premutate(ArrayType *) { visit_children = false; }
86        void FixFunction_old::premutate(BasicType *) { visit_children = false; }
87        void FixFunction_old::premutate(PointerType *) { visit_children = false; }
88        void FixFunction_old::premutate(StructInstType *) { visit_children = false; }
89        void FixFunction_old::premutate(UnionInstType *) { visit_children = false; }
90        void FixFunction_old::premutate(EnumInstType *) { visit_children = false; }
91        void FixFunction_old::premutate(TraitInstType *) { visit_children = false; }
92        void FixFunction_old::premutate(TypeInstType *) { visit_children = false; }
93        void FixFunction_old::premutate(TupleType *) { visit_children = false; }
94        void FixFunction_old::premutate(VarArgsType *) { visit_children = false; }
95        void FixFunction_old::premutate(ZeroType *) { visit_children = false; }
96        void FixFunction_old::premutate(OneType *) { visit_children = false; }
97
98        bool fixFunction( DeclarationWithType *& dwt ) {
99                PassVisitor<FixFunction_old> fixer;
100                dwt = dwt->acceptMutator( fixer );
101                return fixer.pass.isVoid;
102        }
103
104namespace {
105        struct FixFunction_new final : public ast::WithShortCircuiting {
106                bool isVoid = false;
107
108                void previsit( const ast::FunctionDecl * ) { visit_children = false; }
109
110                const ast::DeclWithType * postvisit( const ast::FunctionDecl * func ) {
111                        return new ast::ObjectDecl{ 
112                                func->location, func->name, new ast::PointerType{ func->type }, nullptr, 
113                                func->storage, func->linkage, nullptr, copy( func->attributes ) };
114                }
115
116                void previsit( const ast::ArrayType * ) { visit_children = false; }
117
118                const ast::Type * postvisit( const ast::ArrayType * array ) {
119                        return new ast::PointerType{ 
120                                array->base, array->dimension, array->isVarLen, array->isStatic, 
121                                array->qualifiers };
122                }
123
124                void previsit( const ast::FunctionType * ) { visit_children = false; }
125
126                const ast::Type * postvisit( const ast::FunctionType * type ) {
127                        return new ast::PointerType( type );
128                }
129
130                void previsit( const ast::VoidType * ) { isVoid = true; }
131
132                void previsit( const ast::BasicType * ) { visit_children = false; }
133                void previsit( const ast::PointerType * ) { visit_children = false; }
134                void previsit( const ast::StructInstType * ) { visit_children = false; }
135                void previsit( const ast::UnionInstType * ) { visit_children = false; }
136                void previsit( const ast::EnumInstType * ) { visit_children = false; }
137                void previsit( const ast::TraitInstType * ) { visit_children = false; }
138                void previsit( const ast::TypeInstType * ) { visit_children = false; }
139                void previsit( const ast::TupleType * ) { visit_children = false; }
140                void previsit( const ast::VarArgsType * ) { visit_children = false; }
141                void previsit( const ast::ZeroType * ) { visit_children = false; }
142                void previsit( const ast::OneType * ) { visit_children = false; }
143        };
144} // anonymous namespace
145
146const ast::DeclWithType * fixFunction( const ast::DeclWithType * dwt, bool & isVoid ) {
147        ast::Pass< FixFunction_new > fixer;
148        dwt = dwt->accept( fixer );
149        isVoid |= fixer.core.isVoid;
150        return dwt;
151}
152
153const ast::Type * fixFunction( const ast::Type * type, bool & isVoid ) {
154        ast::Pass< FixFunction_new > fixer;
155        type = type->accept( fixer );
156        isVoid |= fixer.core.isVoid;
157        return type;
158}
159
160} // namespace SymTab
161
162// Local Variables: //
163// tab-width: 4 //
164// mode: c++ //
165// compile-command: "make install" //
166// End: //
Note: See TracBrowser for help on using the repository browser.