source: src/AST/Type.cpp @ 361bf01

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

remove ParameterizedType? and put content into FunctionType?

  • 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// 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 FunctionType::initWithSub(
97        const FunctionType & o, Pass< ForallSubstitutor > & sub
98) {
99        forall = sub.core( o.forall );
100}
101
102// --- FunctionType
103
104
105FunctionType::FunctionType( const FunctionType & o )
106: Type( 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
127std::vector<readonly<Decl>> BaseInstType::lookup( const std::string& name ) const {
128        assertf( aggr(), "Must have aggregate to perform lookup" );
129
130        std::vector<readonly<Decl>> found;
131        for ( const Decl * decl : aggr()->members ) {
132                if ( decl->name == name ) { found.emplace_back( decl ); }
133        }
134        return found;
135}
136
137// --- SueInstType (StructInstType, UnionInstType, EnumInstType)
138
139template<typename decl_t>
140SueInstType<decl_t>::SueInstType(
141        const decl_t * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
142: BaseInstType( b->name, q, move(as) ), base( b ) {}
143
144template<typename decl_t>
145SueInstType<decl_t>::SueInstType(
146        const base_type * b, std::vector<ptr<Expr>> && params,
147        CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
148: BaseInstType( b->name, std::move(params), q, std::move(as) ), base( b ) {}
149
150template<typename decl_t>
151bool SueInstType<decl_t>::isComplete() const {
152        return base ? base->body : false;
153}
154
155template class SueInstType<StructDecl>;
156template class SueInstType<UnionDecl>;
157template class SueInstType<EnumDecl>;
158
159// --- TraitInstType
160
161TraitInstType::TraitInstType(
162        const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
163: BaseInstType( b->name, q, move(as) ), base( b ) {}
164
165void TypeInstType::set_base( const TypeDecl * b ) {
166        base = b;
167        kind = b->kind;
168}
169
170bool TypeInstType::isComplete() const { return base->sized; }
171
172// --- TupleType
173
174TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
175: Type( q ), types( move(ts) ), members() {
176        // This constructor is awkward. `TupleType` needs to contain objects so that members can be
177        // named, but members without initializer nodes end up getting constructors, which breaks
178        // things. This happens because the object decls have to be visited so that their types are
179        // kept in sync with the types listed here. Ultimately, the types listed here should perhaps
180        // be eliminated and replaced with a list-view over members. The temporary solution is to
181        // make a `ListInit` with `maybeConstructed = false`, so when the object is visited it is not
182        // constructed. Potential better solutions include:
183        //   a) Separate `TupleType` from its declarations, into `TupleDecl` and `Tuple{Inst?}Type`,
184        //      similar to the aggregate types.
185        //   b) Separate initializer nodes better, e.g. add a `MaybeConstructed` node that is replaced
186        //      by `genInit`, rather than the current boolean flag.
187        members.reserve( types.size() );
188        for ( const Type * ty : types ) {
189                members.emplace_back( new ObjectDecl{
190                        CodeLocation{}, "", ty, new ListInit( CodeLocation{}, {}, {}, NoConstruct ),
191                        Storage::Classes{}, Linkage::Cforall } );
192        }
193}
194
195bool isUnboundType(const Type * type) {
196        if (auto typeInst = dynamic_cast<const TypeInstType *>(type)) {
197                // xxx - look for a type name produced by renameTyVars.
198
199                // TODO: once TypeInstType representation is updated, it should properly check
200                // if the context id is filled. this is a temporary hack for now
201                return isUnboundType(typeInst->name);
202        }
203        return false;
204}
205
206bool isUnboundType(const std::string & tname) {
207        // xxx - look for a type name produced by renameTyVars.
208
209        // TODO: once TypeInstType representation is updated, it should properly check
210        // if the context id is filled. this is a temporary hack for now
211        if (std::count(tname.begin(), tname.end(), '_') >= 3) {
212                return true;
213        }
214        return false;
215}
216
217}
218
219// Local Variables: //
220// tab-width: 4 //
221// mode: c++ //
222// compile-command: "make install" //
223// End: //
Note: See TracBrowser for help on using the repository browser.