source: src/AST/Type.cpp @ 954c954

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since 954c954 was 954c954, checked in by Fangren Yu <f37yu@…>, 15 months ago

Move function argument and return variable declarations from FunctionType? to FunctionDecl?

  • Property mode set to 100644
File size: 6.0 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// Type.cpp --
8//
9// Author           : Aaron B. Moss
10// Created On       : Mon May 13 15:00:00 2019
11// Last Modified By : Andrew Beach
12// Last Modified On : Thu Jul 23 14:16:00 2020
13// Update Count     : 5
14//
15
16#include "Type.hpp"
17
18#include <cassert>
19#include <utility>               // for move
20#include <vector>
21
22#include "Decl.hpp"
23#include "ForallSubstitutor.hpp" // for substituteForall
24#include "Init.hpp"
25#include "Common/utility.h"      // for copy, move
26#include "InitTweak/InitTweak.h" // for getPointerBase
27#include "Tuples/Tuples.h"       // for isTtype
28
29namespace ast {
30
31const Type * Type::getComponent( unsigned i ) const {
32        assertf( size() == 1 && i == 0, "Type::getComponent was called with size %d and index %d\n", size(), i );
33        return this;
34}
35
36const Type * Type::stripDeclarator() const {
37        const Type * t;
38        const Type * a;
39        for ( t = this; (a = InitTweak::getPointerBase( t )); t = a );
40        return t;
41}
42
43const Type * Type::stripReferences() const {
44        const Type * t;
45        const ReferenceType * r;
46        for ( t = this; (r = dynamic_cast<const ReferenceType *>(t) ); t = r->base );
47        return t;
48}
49
50// --- BasicType
51
52// GENERATED START, DO NOT EDIT
53// GENERATED BY BasicTypes-gen.cc
54const char * BasicType::typeNames[] = {
55        "_Bool",
56        "char",
57        "signed char",
58        "unsigned char",
59        "signed short int",
60        "unsigned short int",
61        "signed int",
62        "unsigned int",
63        "signed long int",
64        "unsigned long int",
65        "signed long long int",
66        "unsigned long long int",
67        "__int128",
68        "unsigned __int128",
69        "_Float16",
70        "_Float16 _Complex",
71        "_Float32",
72        "_Float32 _Complex",
73        "float",
74        "float _Complex",
75        "_Float32x",
76        "_Float32x _Complex",
77        "_Float64",
78        "_Float64 _Complex",
79        "double",
80        "double _Complex",
81        "_Float64x",
82        "_Float64x _Complex",
83        "__float80",
84        "_Float128",
85        "_Float128 _Complex",
86        "__float128",
87        "long double",
88        "long double _Complex",
89        "_Float128x",
90        "_Float128x _Complex",
91};
92// GENERATED END
93
94// --- ParameterizedType
95
96void ParameterizedType::initWithSub(
97        const ParameterizedType & o, Pass< ForallSubstitutor > & sub
98) {
99        forall = sub.core( o.forall );
100}
101
102// --- FunctionType
103
104
105FunctionType::FunctionType( const FunctionType & o )
106: ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(),
107  isVarArgs( o.isVarArgs ) {
108        Pass< ForallSubstitutor > sub;
109        initWithSub( o, sub );           // initialize substitution map
110        returns = sub.core( o.returns ); // apply to return and parameter types
111        params = sub.core( o.params );
112}
113
114namespace {
115        bool containsTtype( const std::vector<ptr<Type>> & l ) {
116                if ( ! l.empty() ) {
117                        return Tuples::isTtype( l.back() );
118                }
119                return false;
120        }
121}
122
123bool FunctionType::isTtype() const {
124        return containsTtype( returns ) || containsTtype( params );
125}
126
127// --- BaseInstType
128
129void BaseInstType::initWithSub( const BaseInstType & o, Pass< ForallSubstitutor > & sub ) {
130        ParameterizedType::initWithSub( o, sub ); // initialize substitution
131        params = sub.core( o.params );            // apply to parameters
132}
133
134BaseInstType::BaseInstType( const BaseInstType & o )
135: ParameterizedType( o.qualifiers, copy( o.attributes ) ), params(), name( o.name ), 
136  hoistType( o.hoistType ) {
137        Pass< ForallSubstitutor > sub;
138        initWithSub( o, sub );
139}
140
141std::vector<readonly<Decl>> BaseInstType::lookup( const std::string& name ) const {
142        assertf( aggr(), "Must have aggregate to perform lookup" );
143
144        std::vector<readonly<Decl>> found;
145        for ( const Decl * decl : aggr()->members ) {
146                if ( decl->name == name ) { found.emplace_back( decl ); }
147        }
148        return found;
149}
150
151// --- SueInstType (StructInstType, UnionInstType, EnumInstType)
152
153template<typename decl_t>
154SueInstType<decl_t>::SueInstType(
155        const decl_t * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
156: BaseInstType( b->name, q, move(as) ), base( b ) {}
157
158template<typename decl_t>
159bool SueInstType<decl_t>::isComplete() const {
160        return base ? base->body : false;
161}
162
163template class SueInstType<StructDecl>;
164template class SueInstType<UnionDecl>;
165template class SueInstType<EnumDecl>;
166
167// --- TraitInstType
168
169TraitInstType::TraitInstType(
170        const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
171: BaseInstType( b->name, q, move(as) ), base( b ) {}
172
173// --- TypeInstType
174
175TypeInstType::TypeInstType( const TypeInstType & o )
176: BaseInstType( o.name, o.qualifiers, copy( o.attributes ) ), base(), kind( o.kind ) {
177        Pass< ForallSubstitutor > sub;
178        initWithSub( o, sub );      // initialize substitution
179        base = sub.core( o.base );  // apply to base type
180}
181
182void TypeInstType::set_base( const TypeDecl * b ) {
183        base = b;
184        kind = b->kind;
185}
186
187bool TypeInstType::isComplete() const { return base->sized; }
188
189// --- TupleType
190
191TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
192: Type( q ), types( move(ts) ), members() {
193        // This constructor is awkward. `TupleType` needs to contain objects so that members can be
194        // named, but members without initializer nodes end up getting constructors, which breaks
195        // things. This happens because the object decls have to be visited so that their types are
196        // kept in sync with the types listed here. Ultimately, the types listed here should perhaps
197        // be eliminated and replaced with a list-view over members. The temporary solution is to
198        // make a `ListInit` with `maybeConstructed = false`, so when the object is visited it is not
199        // constructed. Potential better solutions include:
200        //   a) Separate `TupleType` from its declarations, into `TupleDecl` and `Tuple{Inst?}Type`,
201        //      similar to the aggregate types.
202        //   b) Separate initializer nodes better, e.g. add a `MaybeConstructed` node that is replaced
203        //      by `genInit`, rather than the current boolean flag.
204        members.reserve( types.size() );
205        for ( const Type * ty : types ) {
206                members.emplace_back( new ObjectDecl{
207                        CodeLocation{}, "", ty, new ListInit( CodeLocation{}, {}, {}, MaybeConstruct ),
208                        Storage::Classes{}, Linkage::Cforall } );
209        }
210}
211
212}
213
214// Local Variables: //
215// tab-width: 4 //
216// mode: c++ //
217// compile-command: "make install" //
218// End: //
Note: See TracBrowser for help on using the repository browser.