source: src/ResolvExpr/AdjustExprType.cc @ 7030dab

arm-ehjacob/cs343-translationnew-astnew-ast-unique-expr
Last change on this file since 7030dab was 7030dab, checked in by Thierry Delisle <tdelisle@…>, 19 months ago

Merge branch 'master' into new-ast

  • Property mode set to 100644
File size: 6.1 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// AdjustExprType_old.cc --
8//
9// Author           : Richard C. Bilson
10// Created On       : Sat May 16 23:41:42 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Wed Dec 11 21:43:56 2019
13// Update Count     : 6
14//
15
16#include "AST/Node.hpp"
17#include "AST/Pass.hpp"
18#include "AST/SymbolTable.hpp"
19#include "AST/Type.hpp"
20#include "AST/TypeEnvironment.hpp"
21#include "Common/PassVisitor.h"
22#include "SymTab/Indexer.h"       // for Indexer
23#include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Kind::Ftype
24#include "SynTree/Mutator.h"      // for Mutator
25#include "SynTree/Type.h"         // for PointerType, TypeInstType, Type
26#include "TypeEnvironment.h"      // for EqvClass, TypeEnvironment
27
28namespace ResolvExpr {
29
30namespace {
31        class AdjustExprType_old final : public WithShortCircuiting {
32                public:
33                AdjustExprType_old( const TypeEnvironment & env, const SymTab::Indexer & indexer );
34                void premutate( VoidType * ) { visit_children = false; }
35                void premutate( BasicType * ) { visit_children = false; }
36                void premutate( PointerType * ) { visit_children = false; }
37                void premutate( ArrayType * ) { visit_children = false; }
38                void premutate( FunctionType * ) { visit_children = false; }
39                void premutate( StructInstType * ) { visit_children = false; }
40                void premutate( UnionInstType * ) { visit_children = false; }
41                void premutate( EnumInstType * ) { visit_children = false; }
42                void premutate( TraitInstType * ) { visit_children = false; }
43                void premutate( TypeInstType * ) { visit_children = false; }
44                void premutate( TupleType * ) { visit_children = false; }
45                void premutate( VarArgsType * ) { visit_children = false; }
46                void premutate( ZeroType * ) { visit_children = false; }
47                void premutate( OneType * ) { visit_children = false; }
48
49                Type * postmutate( ArrayType * arrayType );
50                Type * postmutate( FunctionType * functionType );
51                Type * postmutate( TypeInstType * aggregateUseType );
52
53                private:
54                const TypeEnvironment & env;
55                const SymTab::Indexer & indexer;
56        };
57
58        AdjustExprType_old::AdjustExprType_old( const TypeEnvironment &env, const SymTab::Indexer &indexer )
59                : env( env ), indexer( indexer ) {
60        }
61
62        Type * AdjustExprType_old::postmutate( ArrayType * arrayType ) {
63                PointerType * pointerType = new PointerType{ arrayType->get_qualifiers(), arrayType->base };
64                arrayType->base = nullptr;
65                delete arrayType;
66                return pointerType;
67        }
68
69        Type * AdjustExprType_old::postmutate( FunctionType * functionType ) {
70                return new PointerType{ Type::Qualifiers(), functionType };
71        }
72
73        Type * AdjustExprType_old::postmutate( TypeInstType * typeInst ) {
74                if ( const EqvClass * eqvClass = env.lookup( typeInst->get_name() ) ) {
75                        if ( eqvClass->data.kind == TypeDecl::Ftype ) {
76                                return new PointerType{ Type::Qualifiers(), typeInst };
77                        }
78                } else if ( const NamedTypeDecl * ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
79                        if ( const TypeDecl * tyDecl = dynamic_cast< const TypeDecl * >( ntDecl ) ) {
80                                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
81                                        return new PointerType{ Type::Qualifiers(), typeInst };
82                                } // if
83                        } // if
84                } // if
85                return typeInst;
86        }
87} // anonymous namespace
88
89void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
90        PassVisitor<AdjustExprType_old> adjuster( env, indexer );
91        Type * newType = type->acceptMutator( adjuster );
92        type = newType;
93}
94
95void adjustExprType( Type *& type ) {
96        TypeEnvironment env;
97        SymTab::Indexer indexer;
98        adjustExprType( type, env, indexer );
99}
100
101namespace {
102        class AdjustExprType_new final : public ast::WithShortCircuiting {
103                const ast::SymbolTable & symtab;
104        public:
105                const ast::TypeEnvironment & tenv;
106
107                AdjustExprType_new( const ast::TypeEnvironment & e, const ast::SymbolTable & syms )
108                : symtab( syms ), tenv( e ) {}
109
110                void previsit( const ast::VoidType * ) { visit_children = false; }
111                void previsit( const ast::BasicType * ) { visit_children = false; }
112                void previsit( const ast::PointerType * ) { visit_children = false; }
113                void previsit( const ast::ArrayType * ) { visit_children = false; }
114                void previsit( const ast::FunctionType * ) { visit_children = false; }
115                void previsit( const ast::StructInstType * ) { visit_children = false; }
116                void previsit( const ast::UnionInstType * ) { visit_children = false; }
117                void previsit( const ast::EnumInstType * ) { visit_children = false; }
118                void previsit( const ast::TraitInstType * ) { visit_children = false; }
119                void previsit( const ast::TypeInstType * ) { visit_children = false; }
120                void previsit( const ast::TupleType * ) { visit_children = false; }
121                void previsit( const ast::VarArgsType * ) { visit_children = false; }
122                void previsit( const ast::ZeroType * ) { visit_children = false; }
123                void previsit( const ast::OneType * ) { visit_children = false; }
124
125                const ast::Type * postvisit( const ast::ArrayType * at ) {
126                        return new ast::PointerType{ at->base, at->qualifiers };
127                }
128
129                const ast::Type * postvisit( const ast::FunctionType * ft ) {
130                        return new ast::PointerType{ ft };
131                }
132
133                const ast::Type * postvisit( const ast::TypeInstType * inst ) {
134                        // replace known function-type-variables with pointer-to-function
135                        if ( const ast::EqvClass * eqvClass = tenv.lookup( inst->name ) ) {
136                                if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
137                                        return new ast::PointerType{ inst };
138                                }
139                        } else if ( const ast::NamedTypeDecl * ntDecl = symtab.lookupType( inst->name ) ) {
140                                if ( auto tyDecl = dynamic_cast< const ast::TypeDecl * >( ntDecl ) ) {
141                                        if ( tyDecl->kind == ast::TypeDecl::Ftype ) {
142                                                return new ast::PointerType{ inst };
143                                        }
144                                }
145                        }
146                        return inst;
147                }
148        };
149} // anonymous namespace
150
151const ast::Type * adjustExprType(
152        const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab
153) {
154        ast::Pass<AdjustExprType_new> adjuster{ env, symtab };
155        return type->accept( adjuster );
156}
157
158} // namespace ResolvExpr
159
160// Local Variables: //
161// tab-width: 4 //
162// mode: c++ //
163// compile-command: "make install" //
164// End: //
Note: See TracBrowser for help on using the repository browser.