source: src/Parser/ParseNode.h@ bbc9b64

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new with_gc
Last change on this file since bbc9b64 was 89d129c, checked in by Peter A. Buhr <pabuhr@…>, 9 years ago

Merge branch 'master' of plg2:software/cfa/cfa-cc
  • Property mode set to 100644
File size: 17.9 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// ParseNode.h --
8//
9// Author : Rodolfo G. Esteves
10// Created On : Sat May 16 13:28:16 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Fri Mar 17 15:42:18 2017
13// Update Count : 777
14//
15
16#ifndef PARSENODE_H
17#define PARSENODE_H
18
19#include <string>
20#include <list>
21#include <iterator>
22#include <memory>
23
24#include "Parser/LinkageSpec.h"
25#include "SynTree/Type.h"
26#include "SynTree/Expression.h"
27#include "SynTree/Statement.h"
28#include "SynTree/Label.h"
29#include "Common/utility.h"
30#include "Common/UniqueName.h"
31
32class StatementNode;
33class CompoundStmtNode;
34class DeclarationNode;
35class ExpressionNode;
36class InitializerNode;
37class Attribute;
38
39//##############################################################################
40
41extern char * yyfilename;
42extern int yylineno;
43
44class ParseNode {
45 public:
46 ParseNode() {};
47 virtual ~ParseNode() { delete next; delete name; };
48 virtual ParseNode * clone() const = 0;
49
50 ParseNode * get_next() const { return next; }
51 ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
52
53 ParseNode * get_last() {
54 ParseNode * current;
55 for ( current = this; current->get_next() != nullptr; current = current->get_next() );
56 return current;
57 }
58 ParseNode * set_last( ParseNode * newlast ) {
59 if ( newlast != nullptr ) get_last()->set_next( newlast );
60 return this;
61 }
62
63 virtual void print( std::ostream &os, int indent = 0 ) const {}
64 virtual void printList( std::ostream &os, int indent = 0 ) const {}
65
66 static int indent_by;
67
68 ParseNode * next = nullptr;
69 std::string * name = nullptr;
70 CodeLocation location = { yyfilename, yylineno };
71}; // ParseNode
72
73//##############################################################################
74
75class InitializerNode : public ParseNode {
76 public:
77 InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr );
78 InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
79 ~InitializerNode();
80 virtual InitializerNode * clone() const { assert( false ); return nullptr; }
81
82 ExpressionNode * get_expression() const { return expr; }
83
84 InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
85 ExpressionNode * get_designators() const { return designator; }
86
87 InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
88 bool get_maybeConstructed() const { return maybeConstructed; }
89
90 InitializerNode * next_init() const { return kids; }
91
92 void print( std::ostream &os, int indent = 0 ) const;
93 void printOneLine( std::ostream & ) const;
94
95 virtual Initializer * build() const;
96 private:
97 ExpressionNode * expr;
98 bool aggregate;
99 ExpressionNode * designator; // may be list
100 InitializerNode * kids;
101 bool maybeConstructed;
102}; // InitializerNode
103
104//##############################################################################
105
106class ExpressionNode final : public ParseNode {
107 public:
108 ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
109 ExpressionNode( const ExpressionNode &other );
110 virtual ~ExpressionNode() {}
111 virtual ExpressionNode * clone() const override { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
112
113 bool get_extension() const { return extension; }
114 ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
115
116 virtual void print( std::ostream &os, int indent = 0 ) const override {}
117 void printOneLine( std::ostream &os, int indent = 0 ) const {}
118
119 template<typename T>
120 bool isExpressionType() const {
121 return nullptr != dynamic_cast<T>(expr.get());
122 }
123
124 Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
125 private:
126 bool extension = false;
127 std::unique_ptr<Expression> expr;
128}; // ExpressionNode
129
130template< typename T >
131struct maybeBuild_t< Expression, T > {
132 static inline Expression * doit( const T * orig ) {
133 if ( orig ) {
134 Expression * p = orig->build();
135 p->set_extension( orig->get_extension() );
136 p->location = orig->location;
137 return p;
138 } else {
139 return nullptr;
140 } // if
141 }
142};
143
144enum class OperKinds {
145 // diadic
146 SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
147 BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
148 Assign, AtAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
149 Index, Range,
150 // monadic
151 UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
152 Ctor, Dtor,
153}; // OperKinds
154
155struct LabelNode {
156 std::list< Label > labels;
157};
158
159Expression * build_constantInteger( const std::string &str );
160Expression * build_constantFloat( const std::string &str );
161Expression * build_constantChar( const std::string &str );
162Expression * build_constantZeroOne( const std::string &str );
163ConstantExpr * build_constantStr( const std::string &str );
164Expression * build_field_name_FLOATINGconstant( const std::string & str );
165Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
166Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
167Expression * build_field_name_REALDECIMALconstant( const std::string & str );
168
169NameExpr * build_varref( const std::string * name, bool labelp = false );
170Expression * build_typevalue( DeclarationNode * decl );
171
172Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
173Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
174Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
175Expression * build_addressOf( ExpressionNode * expr_node );
176Expression * build_sizeOfexpr( ExpressionNode * expr_node );
177Expression * build_sizeOftype( DeclarationNode * decl_node );
178Expression * build_alignOfexpr( ExpressionNode * expr_node );
179Expression * build_alignOftype( DeclarationNode * decl_node );
180Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
181Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
182Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
183Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
184Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
185Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
186Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
187Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
188Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
189Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
190Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
191Expression * build_tuple( ExpressionNode * expr_node = nullptr );
192Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
193Expression * build_range( ExpressionNode * low, ExpressionNode * high );
194Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand );
195Expression * build_valexpr( StatementNode * s );
196Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
197
198//##############################################################################
199
200struct TypeData;
201
202class DeclarationNode : public ParseNode {
203 public:
204 enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
205 enum ComplexType { Complex, Imaginary, NoComplexType };
206 enum Signedness { Signed, Unsigned, NoSignedness };
207 enum Length { Short, Long, LongLong, NoLength };
208 enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate };
209 enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
210 enum BuiltinType { Valist, Zero, One, NoBuiltinType };
211
212 static const char * basicTypeNames[];
213 static const char * complexTypeNames[];
214 static const char * signednessNames[];
215 static const char * lengthNames[];
216 static const char * aggregateNames[];
217 static const char * typeClassNames[];
218 static const char * builtinTypeNames[];
219
220 static DeclarationNode * newStorageClass( Type::StorageClasses );
221 static DeclarationNode * newFuncSpecifier( Type::FuncSpecifiers );
222 static DeclarationNode * newTypeQualifier( Type::Qualifiers );
223 static DeclarationNode * newBasicType( BasicType );
224 static DeclarationNode * newComplexType( ComplexType );
225 static DeclarationNode * newSignedNess( Signedness );
226 static DeclarationNode * newLength( Length );
227 static DeclarationNode * newBuiltinType( BuiltinType );
228 static DeclarationNode * newForall( DeclarationNode * );
229 static DeclarationNode * newFromTypedef( std::string * );
230 static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
231 static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
232 static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
233 static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
234 static DeclarationNode * newName( std::string * );
235 static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
236 static DeclarationNode * newTypeParam( TypeClass, std::string * );
237 static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
238 static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
239 static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
240 static DeclarationNode * newPointer( DeclarationNode * qualifiers );
241 static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
242 static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
243 static DeclarationNode * newBitfield( ExpressionNode * size );
244 static DeclarationNode * newTuple( DeclarationNode * members );
245 static DeclarationNode * newTypeof( ExpressionNode * expr );
246 static DeclarationNode * newAttr( std::string *, ExpressionNode * expr ); // @ attributes
247 static DeclarationNode * newAttr( std::string *, DeclarationNode * type ); // @ attributes
248 static DeclarationNode * newAttribute( std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
249 static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
250
251 DeclarationNode();
252 ~DeclarationNode();
253 DeclarationNode * clone() const override;
254
255 DeclarationNode * addQualifiers( DeclarationNode * );
256 void checkQualifiers( const TypeData *, const TypeData * );
257 void checkSpecifiers( DeclarationNode * );
258 DeclarationNode * copySpecifiers( DeclarationNode * );
259 DeclarationNode * addType( DeclarationNode * );
260 DeclarationNode * addTypedef();
261 DeclarationNode * addAssertions( DeclarationNode * );
262 DeclarationNode * addName( std::string * );
263 DeclarationNode * addAsmName( DeclarationNode * );
264 DeclarationNode * addBitfield( ExpressionNode * size );
265 DeclarationNode * addVarArgs();
266 DeclarationNode * addFunctionBody( StatementNode * body );
267 DeclarationNode * addOldDeclList( DeclarationNode * list );
268 DeclarationNode * setBase( TypeData * newType );
269 DeclarationNode * copyAttribute( DeclarationNode * attr );
270 DeclarationNode * addPointer( DeclarationNode * qualifiers );
271 DeclarationNode * addArray( DeclarationNode * array );
272 DeclarationNode * addNewPointer( DeclarationNode * pointer );
273 DeclarationNode * addNewArray( DeclarationNode * array );
274 DeclarationNode * addParamList( DeclarationNode * list );
275 DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
276 DeclarationNode * addInitializer( InitializerNode * init );
277
278 DeclarationNode * cloneType( std::string * newName );
279 DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
280
281 DeclarationNode * appendList( DeclarationNode * node ) {
282 return (DeclarationNode *)set_last( node );
283 }
284
285 virtual void print( std::ostream &os, int indent = 0 ) const override;
286 virtual void printList( std::ostream &os, int indent = 0 ) const override;
287
288 Declaration * build() const;
289 Type * buildType() const;
290
291 bool get_hasEllipsis() const;
292 LinkageSpec::Spec get_linkage() const { return linkage; }
293 DeclarationNode * extractAggregate() const;
294 bool has_enumeratorValue() const { return (bool)enumeratorValue; }
295 ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
296
297 bool get_extension() const { return extension; }
298 DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
299 public:
300 struct Variable_t {
301// const std::string * name;
302 DeclarationNode::TypeClass tyClass;
303 DeclarationNode * assertions;
304 };
305 Variable_t variable;
306
307 struct Attr_t {
308// const std::string * name;
309 ExpressionNode * expr;
310 DeclarationNode * type;
311 };
312 Attr_t attr;
313
314 BuiltinType builtin;
315
316 TypeData * type;
317
318 Type::FuncSpecifiers funcSpecs;
319 Type::StorageClasses storageClasses;
320
321 ExpressionNode * bitfieldWidth;
322 std::unique_ptr<ExpressionNode> enumeratorValue;
323 bool hasEllipsis;
324 LinkageSpec::Spec linkage;
325 ConstantExpr *asmName;
326 std::list< Attribute * > attributes;
327 InitializerNode * initializer;
328 bool extension = false;
329 std::string error;
330 StatementNode * asmStmt;
331
332 static UniqueName anonymous;
333}; // DeclarationNode
334
335Type * buildType( TypeData * type );
336
337static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
338 Type * ret = orig ? orig->buildType() : nullptr;
339 delete orig;
340 return ret;
341}
342
343//##############################################################################
344
345class StatementNode final : public ParseNode {
346 public:
347 StatementNode() { stmt = nullptr; }
348 StatementNode( Statement * stmt ) : stmt( stmt ) {}
349 StatementNode( DeclarationNode * decl );
350 virtual ~StatementNode() {}
351
352 virtual StatementNode * clone() const final { assert( false ); return nullptr; }
353 Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
354
355 virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
356 stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
357 delete attr;
358 delete name;
359 return this;
360 }
361
362 virtual StatementNode * append_last_case( StatementNode * );
363
364 virtual void print( std::ostream &os, int indent = 0 ) const override {}
365 virtual void printList( std::ostream &os, int indent = 0 ) const override {}
366 private:
367 std::unique_ptr<Statement> stmt;
368}; // StatementNode
369
370Statement * build_expr( ExpressionNode * ctl );
371
372struct ForCtl {
373 ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
374 init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
375 ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
376 init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
377
378 StatementNode * init;
379 ExpressionNode * condition;
380 ExpressionNode * change;
381};
382
383Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
384Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
385Statement * build_case( ExpressionNode * ctl );
386Statement * build_default();
387Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
388Statement * build_for( ForCtl * forctl, StatementNode * stmt );
389Statement * build_branch( BranchStmt::Type kind );
390Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
391Statement * build_computedgoto( ExpressionNode * ctl );
392Statement * build_return( ExpressionNode * ctl );
393Statement * build_throw( ExpressionNode * ctl );
394Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
395Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
396Statement * build_finally( StatementNode * stmt );
397Statement * build_compound( StatementNode * first );
398Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
399
400//##############################################################################
401
402template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
403void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
404 SemanticError errors;
405 std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
406 const NodeType * cur = firstNode;
407
408 while ( cur ) {
409 try {
410 SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
411 if ( result ) {
412 result->location = cur->location;
413 * out++ = result;
414 } // if
415 } catch( SemanticError &e ) {
416 e.set_location( cur->location );
417 errors.append( e );
418 } // try
419 cur = dynamic_cast< NodeType * >( cur->get_next() );
420 } // while
421 if ( ! errors.isEmpty() ) {
422 throw errors;
423 } // if
424}
425
426// in DeclarationNode.cc
427void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
428void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
429void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
430
431template< typename SynTreeType, typename NodeType >
432void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
433 buildList( firstNode, outputList );
434 delete firstNode;
435}
436
437// in ParseNode.cc
438std::ostream & operator<<( std::ostream & out, const ParseNode * node );
439
440#endif // PARSENODE_H
441
442// Local Variables: //
443// tab-width: 4 //
444// mode: c++ //
445// compile-command: "make install" //
446// End: //
Note: See TracBrowser for help on using the repository browser.