source: src/Parser/DeclarationNode.cc@ b8cb388

Last change on this file since b8cb388 was 67467a3, checked in by Andrew Beach <ajbeach@…>, 19 months ago

Fused TypeData::Enum and TypeData::Aggregate, an enumeration is a kind of aggregate after all. There will always be some unused fields in Aggregate_t (but less in TypeData overall) but the code is almost always simpler.
  • Property mode set to 100644
File size: 33.5 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// DeclarationNode.cc --
8//
9// Author : Rodolfo G. Esteves
10// Created On : Sat May 16 12:34:05 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Fri Feb 23 18:25:57 2024
13// Update Count : 1533
14//
15
16#include "DeclarationNode.h"
17
18#include <cassert> // for assert, assertf, strict_dynamic_cast
19#include <iterator> // for back_insert_iterator
20#include <list> // for list
21#include <memory> // for unique_ptr
22#include <ostream> // for operator<<, ostream, basic_ostream
23#include <string> // for string, operator+, allocator, char...
24
25#include "AST/Attribute.hpp" // for Attribute
26#include "AST/Copy.hpp" // for shallowCopy
27#include "AST/Decl.hpp" // for Decl
28#include "AST/Expr.hpp" // for Expr
29#include "AST/Print.hpp" // for print
30#include "AST/Stmt.hpp" // for AsmStmt, DirectiveStmt
31#include "AST/StorageClasses.hpp" // for Storage::Class
32#include "AST/Type.hpp" // for Type
33#include "Common/CodeLocation.h" // for CodeLocation
34#include "Common/Iterate.hpp" // for reverseIterate
35#include "Common/SemanticError.h" // for SemanticError
36#include "Common/UniqueName.h" // for UniqueName
37#include "Common/utility.h" // for copy, spliceBegin
38#include "Parser/ExpressionNode.h" // for ExpressionNode
39#include "Parser/InitializerNode.h"// for InitializerNode
40#include "Parser/StatementNode.h" // for StatementNode
41#include "TypeData.h" // for TypeData, TypeData::Aggregate_t
42#include "TypedefTable.h" // for TypedefTable
43
44extern TypedefTable typedefTable;
45
46using namespace std;
47
48UniqueName DeclarationNode::anonymous( "__anonymous" );
49
50extern ast::Linkage::Spec linkage; // defined in parser.yy
51
52DeclarationNode::DeclarationNode() :
53 linkage( ::linkage ) {
54
55// variable.name = nullptr;
56 variable.tyClass = ast::TypeDecl::NUMBER_OF_KINDS;
57 variable.assertions = nullptr;
58 variable.initializer = nullptr;
59
60 assert.condition = nullptr;
61 assert.message = nullptr;
62}
63
64DeclarationNode::~DeclarationNode() {
65 delete name;
66
67// delete variable.name;
68 delete variable.assertions;
69 delete variable.initializer;
70
71// delete type;
72 delete bitfieldWidth;
73
74 delete asmStmt;
75 // asmName, no delete, passed to next stage
76 delete initializer;
77
78 delete assert.condition;
79 delete assert.message;
80}
81
82DeclarationNode * DeclarationNode::clone() const {
83 DeclarationNode * newnode = new DeclarationNode;
84 newnode->next = maybeCopy( next );
85 newnode->name = name ? new string( *name ) : nullptr;
86
87 newnode->type = maybeCopy( type );
88 newnode->inLine = inLine;
89 newnode->storageClasses = storageClasses;
90 newnode->funcSpecs = funcSpecs;
91 newnode->bitfieldWidth = maybeCopy( bitfieldWidth );
92 newnode->enumeratorValue.reset( maybeCopy( enumeratorValue.get() ) );
93 newnode->hasEllipsis = hasEllipsis;
94 newnode->linkage = linkage;
95 newnode->asmName = maybeCopy( asmName );
96 newnode->attributes = attributes;
97 newnode->initializer = maybeCopy( initializer );
98 newnode->extension = extension;
99 newnode->asmStmt = maybeCopy( asmStmt );
100 newnode->error = error;
101
102// newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr;
103 newnode->variable.tyClass = variable.tyClass;
104 newnode->variable.assertions = maybeCopy( variable.assertions );
105 newnode->variable.initializer = maybeCopy( variable.initializer );
106
107 newnode->assert.condition = maybeCopy( assert.condition );
108 newnode->assert.message = maybeCopy( assert.message );
109 return newnode;
110} // DeclarationNode::clone
111
112void DeclarationNode::print( std::ostream & os, int indent ) const {
113 os << string( indent, ' ' );
114 if ( name ) {
115 os << *name << ": ";
116 } // if
117
118 if ( linkage != ast::Linkage::Cforall ) {
119 os << ast::Linkage::name( linkage ) << " ";
120 } // if
121
122 ast::print( os, storageClasses );
123 ast::print( os, funcSpecs );
124
125 if ( type ) {
126 type->print( os, indent );
127 } else {
128 os << "untyped entity ";
129 } // if
130
131 if ( bitfieldWidth ) {
132 os << endl << string( indent + 2, ' ' ) << "with bitfield width ";
133 bitfieldWidth->printOneLine( os );
134 } // if
135
136 if ( initializer ) {
137 os << endl << string( indent + 2, ' ' ) << "with initializer ";
138 initializer->printOneLine( os );
139 os << " maybe constructed? " << initializer->get_maybeConstructed();
140 } // if
141
142 if ( ! attributes.empty() ) {
143 os << string( indent + 2, ' ' ) << "with attributes" << endl;
144 for ( ast::ptr<ast::Attribute> const & attr : reverseIterate( attributes ) ) {
145 os << string( indent + 4, ' ' );
146 ast::print( os, attr, indent + 2 );
147 } // for
148 } // if
149
150 os << endl;
151}
152
153void DeclarationNode::printList( std::ostream & os, int indent ) const {
154 ParseList::printList( os, indent );
155 if ( hasEllipsis ) {
156 os << string( indent, ' ' ) << "and a variable number of other arguments" << endl;
157 } // if
158}
159
160DeclarationNode * DeclarationNode::newFromTypeData( TypeData * type ) {
161 DeclarationNode * newnode = new DeclarationNode;
162 newnode->type = type;
163 return newnode;
164} // DeclarationNode::newFromTypeData
165
166DeclarationNode * DeclarationNode::newStorageClass( ast::Storage::Classes sc ) {
167 DeclarationNode * newnode = new DeclarationNode;
168 newnode->storageClasses = sc;
169 return newnode;
170} // DeclarationNode::newStorageClass
171
172DeclarationNode * DeclarationNode::newFuncSpecifier( ast::Function::Specs fs ) {
173 DeclarationNode * newnode = new DeclarationNode;
174 newnode->funcSpecs = fs;
175 return newnode;
176} // DeclarationNode::newFuncSpecifier
177
178DeclarationNode * DeclarationNode::newAggregate( ast::AggregateDecl::Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
179 DeclarationNode * newnode = new DeclarationNode;
180 newnode->type = new TypeData( TypeData::Aggregate );
181 newnode->type->aggregate.kind = kind;
182 newnode->type->aggregate.anon = name == nullptr;
183 newnode->type->aggregate.name = newnode->type->aggregate.anon ? new string( DeclarationNode::anonymous.newName() ) : name;
184 newnode->type->aggregate.actuals = actuals;
185 newnode->type->aggregate.fields = fields;
186 newnode->type->aggregate.body = body;
187 return newnode;
188} // DeclarationNode::newAggregate
189
190DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base, EnumHiding hiding ) {
191 DeclarationNode * newnode = newAggregate( ast::AggregateDecl::Enum, name, nullptr, constants, body );
192 newnode->type->aggregate.typed = typed;
193 newnode->type->aggregate.hiding = hiding;
194 if ( base ) {
195 assert( typed );
196 assert( base->type );
197 newnode->type->base = base->type;
198 base->type = nullptr;
199 delete base;
200 } // if
201
202 return newnode;
203} // DeclarationNode::newEnum
204
205DeclarationNode * DeclarationNode::newName( const string * name ) {
206 DeclarationNode * newnode = new DeclarationNode;
207 assert( ! newnode->name );
208 newnode->name = name;
209 return newnode;
210} // DeclarationNode::newName
211
212DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) {
213 DeclarationNode * newnode = newName( name );
214 newnode->enumeratorValue.reset( constant );
215 return newnode;
216} // DeclarationNode::newEnumConstant
217
218DeclarationNode * DeclarationNode::newEnumValueGeneric( const string * name, InitializerNode * init ) {
219 if ( nullptr == init ) {
220 return newName( name );
221 } else if ( init->get_expression() ) {
222 return newEnumConstant( name, init->get_expression() );
223 } else {
224 DeclarationNode * newnode = newName( name );
225 newnode->initializer = init;
226 return newnode;
227 } // if
228} // DeclarationNode::newEnumValueGeneric
229
230DeclarationNode * DeclarationNode::newEnumInLine( const string name ) {
231 DeclarationNode * newnode = newName( new std::string(name) );
232 newnode->enumInLine = true;
233 return newnode;
234}
235
236DeclarationNode * DeclarationNode::newTypeParam( ast::TypeDecl::Kind tc, const string * name ) {
237 DeclarationNode * newnode = newName( name );
238 newnode->type = nullptr;
239 newnode->variable.tyClass = tc;
240 newnode->variable.assertions = nullptr;
241 return newnode;
242} // DeclarationNode::newTypeParam
243
244DeclarationNode * DeclarationNode::newTrait( const string * name, DeclarationNode * params, DeclarationNode * asserts ) {
245 DeclarationNode * newnode = new DeclarationNode;
246 newnode->type = new TypeData( TypeData::Aggregate );
247 newnode->type->aggregate.name = name;
248 newnode->type->aggregate.kind = ast::AggregateDecl::Trait;
249 newnode->type->aggregate.params = params;
250 newnode->type->aggregate.fields = asserts;
251 return newnode;
252} // DeclarationNode::newTrait
253
254DeclarationNode * DeclarationNode::newTraitUse( const string * name, ExpressionNode * params ) {
255 DeclarationNode * newnode = new DeclarationNode;
256 newnode->type = new TypeData( TypeData::AggregateInst );
257 newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate );
258 newnode->type->aggInst.aggregate->aggregate.kind = ast::AggregateDecl::Trait;
259 newnode->type->aggInst.aggregate->aggregate.name = name;
260 newnode->type->aggInst.params = params;
261 return newnode;
262} // DeclarationNode::newTraitUse
263
264DeclarationNode * DeclarationNode::newTypeDecl( const string * name, DeclarationNode * typeParams ) {
265 DeclarationNode * newnode = newName( name );
266 newnode->type = new TypeData( TypeData::Symbolic );
267 newnode->type->symbolic.isTypedef = false;
268 newnode->type->symbolic.params = typeParams;
269 return newnode;
270} // DeclarationNode::newTypeDecl
271
272DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers, OperKinds kind ) {
273 DeclarationNode * newnode = new DeclarationNode;
274 newnode->type = new TypeData( kind == OperKinds::PointTo ? TypeData::Pointer : TypeData::Reference );
275 if ( kind == OperKinds::And ) {
276 // T && is parsed as 'And' operator rather than two references => add a second reference type
277 TypeData * td = new TypeData( TypeData::Reference );
278 td->base = newnode->type;
279 newnode->type = td;
280 }
281 if ( qualifiers ) {
282 return newnode->addQualifiers( qualifiers );
283 } else {
284 return newnode;
285 } // if
286} // DeclarationNode::newPointer
287
288DeclarationNode * DeclarationNode::newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic ) {
289 DeclarationNode * newnode = new DeclarationNode;
290 newnode->type = new TypeData( TypeData::Array );
291 newnode->type->array.dimension = size;
292 newnode->type->array.isStatic = isStatic;
293 newnode->type->array.isVarLen = size && !size->isExpressionType<ast::ConstantExpr *>();
294 return newnode->addQualifiers( qualifiers );
295} // DeclarationNode::newArray
296
297DeclarationNode * DeclarationNode::newVarArray( DeclarationNode * qualifiers ) {
298 DeclarationNode * newnode = new DeclarationNode;
299 newnode->type = new TypeData( TypeData::Array );
300 newnode->type->array.dimension = nullptr;
301 newnode->type->array.isStatic = false;
302 newnode->type->array.isVarLen = true;
303 return newnode->addQualifiers( qualifiers );
304}
305
306DeclarationNode * DeclarationNode::newBitfield( ExpressionNode * size ) {
307 DeclarationNode * newnode = new DeclarationNode;
308 newnode->bitfieldWidth = size;
309 return newnode;
310}
311
312DeclarationNode * DeclarationNode::newTuple( DeclarationNode * members ) {
313 DeclarationNode * newnode = new DeclarationNode;
314 newnode->type = new TypeData( TypeData::Tuple );
315 newnode->type->tuple = members;
316 return newnode;
317}
318
319DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr, bool basetypeof ) {
320 DeclarationNode * newnode = new DeclarationNode;
321 newnode->type = new TypeData( basetypeof ? TypeData::Basetypeof : TypeData::Typeof );
322 newnode->type->typeexpr = expr;
323 return newnode;
324}
325
326DeclarationNode * DeclarationNode::newFunction( const string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
327 DeclarationNode * newnode = newName( name );
328 newnode->type = new TypeData( TypeData::Function );
329 newnode->type->function.params = param;
330 newnode->type->function.body = body;
331
332 if ( ret ) {
333 newnode->type->base = ret->type;
334 ret->type = nullptr;
335 delete ret;
336 } // if
337
338 return newnode;
339} // DeclarationNode::newFunction
340
341DeclarationNode * DeclarationNode::newAttribute( const string * name, ExpressionNode * expr ) {
342 DeclarationNode * newnode = new DeclarationNode;
343 newnode->type = nullptr;
344 std::vector<ast::ptr<ast::Expr>> exprs;
345 buildList( expr, exprs );
346 newnode->attributes.push_back( new ast::Attribute( *name, std::move( exprs ) ) );
347 delete name;
348 return newnode;
349}
350
351DeclarationNode * DeclarationNode::newDirectiveStmt( StatementNode * stmt ) {
352 DeclarationNode * newnode = new DeclarationNode;
353 newnode->directiveStmt = stmt;
354 return newnode;
355}
356
357DeclarationNode * DeclarationNode::newAsmStmt( StatementNode * stmt ) {
358 DeclarationNode * newnode = new DeclarationNode;
359 newnode->asmStmt = stmt;
360 return newnode;
361}
362
363DeclarationNode * DeclarationNode::newStaticAssert( ExpressionNode * condition, ast::Expr * message ) {
364 DeclarationNode * newnode = new DeclarationNode;
365 newnode->assert.condition = condition;
366 newnode->assert.message = message;
367 return newnode;
368}
369
370static void appendError( string & dst, const string & src ) {
371 if ( src.empty() ) return;
372 if ( dst.empty() ) { dst = src; return; }
373 dst += ", " + src;
374} // appendError
375
376void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
377 const ast::CV::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
378 const ast::CV::Qualifiers duplicates = qsrc & qdst;
379
380 if ( duplicates.any() ) {
381 std::stringstream str;
382 str << "duplicate ";
383 ast::print( str, duplicates );
384 str << "qualifier(s)";
385 appendError( error, str.str() );
386 } // for
387} // DeclarationNode::checkQualifiers
388
389void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
390 ast::Function::Specs fsDups = funcSpecs & src->funcSpecs;
391 if ( fsDups.any() ) {
392 std::stringstream str;
393 str << "duplicate ";
394 ast::print( str, fsDups );
395 str << "function specifier(s)";
396 appendError( error, str.str() );
397 } // if
398
399 // Skip if everything is unset.
400 if ( storageClasses.any() && src->storageClasses.any() ) {
401 ast::Storage::Classes dups = storageClasses & src->storageClasses;
402 // Check for duplicates.
403 if ( dups.any() ) {
404 std::stringstream str;
405 str << "duplicate ";
406 ast::print( str, dups );
407 str << "storage class(es)";
408 appendError( error, str.str() );
409 // Check for conflicts.
410 } else if ( !src->storageClasses.is_threadlocal_any() ) {
411 std::stringstream str;
412 str << "conflicting ";
413 ast::print( str, ast::Storage::Classes( 1 << storageClasses.ffs() ) );
414 str << "& ";
415 ast::print( str, ast::Storage::Classes( 1 << src->storageClasses.ffs() ) );
416 str << "storage classes";
417 appendError( error, str.str() );
418 // FIX to preserve invariant of one basic storage specifier
419 src->storageClasses.reset();
420 }
421 } // if
422
423 appendError( error, src->error );
424} // DeclarationNode::checkSpecifiers
425
426DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q, bool copyattr ) {
427 funcSpecs |= q->funcSpecs;
428 storageClasses |= q->storageClasses;
429
430 if ( copyattr ) {
431 std::vector<ast::ptr<ast::Attribute>> tmp;
432 tmp.reserve( q->attributes.size() );
433 for ( auto const & attr : q->attributes ) {
434 tmp.emplace_back( ast::shallowCopy( attr.get() ) );
435 } // for
436 spliceBegin( attributes, tmp );
437 } // if
438
439 return this;
440} // DeclarationNode::copySpecifiers
441
442DeclarationNode * DeclarationNode::addQualifiers( DeclarationNode * q ) {
443 if ( ! q ) { return this; } // empty qualifier
444
445 checkSpecifiers( q );
446 copySpecifiers( q );
447
448 if ( ! q->type ) { delete q; return this; }
449
450 if ( ! type ) {
451 type = q->type; // reuse structure
452 q->type = nullptr;
453 delete q;
454 return this;
455 } // if
456
457 checkQualifiers( type, q->type );
458 TypeData::BuiltinType const builtin = type->builtintype;
459 if ( (builtin == TypeData::Zero || builtin == TypeData::One) && q->type->qualifiers.any() && error.length() == 0 ) {
460 SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, TypeData::builtinTypeNames[builtin] );
461 } // if
462 type = ::addQualifiers( q->type, type );
463 q->type = nullptr;
464
465 delete q;
466 return this;
467} // addQualifiers
468
469DeclarationNode * DeclarationNode::addType( DeclarationNode * o, bool copyattr ) {
470 if ( !o ) return this;
471
472 checkSpecifiers( o );
473 copySpecifiers( o, copyattr );
474 if ( o->type ) {
475 type = ::addType( o->type, type, o->attributes );
476 o->type = nullptr;
477 } // if
478 if ( o->bitfieldWidth ) {
479 bitfieldWidth = o->bitfieldWidth;
480 } // if
481
482 // there may be typedefs chained onto the type
483 if ( o->next ) {
484 set_last( o->next->clone() );
485 } // if
486
487 delete o;
488 return this;
489}
490
491DeclarationNode * DeclarationNode::addEnumBase( DeclarationNode * o ) {
492 if ( o && o->type ) {
493 type->base = o->type;
494 } // if
495 delete o;
496 return this;
497}
498
499// This code handles a special issue with the attribute transparent_union.
500//
501// typedef union U { int i; } typedef_name __attribute__(( aligned(16) )) __attribute__(( transparent_union ))
502//
503// Here the attribute aligned goes with the typedef_name, so variables declared of this type are
504// aligned. However, the attribute transparent_union must be moved from the typedef_name to
505// alias union U. Currently, this is the only know attribute that must be moved from typedef to
506// alias.
507static void moveUnionAttribute( DeclarationNode * decl, DeclarationNode * unionDecl ) {
508 assert( decl->type->kind == TypeData::Symbolic );
509 assert( decl->type->symbolic.isTypedef );
510 assert( unionDecl->type->kind == TypeData::Aggregate );
511
512 if ( unionDecl->type->aggregate.kind != ast::AggregateDecl::Union ) return;
513
514 // Ignore the Aggregate_t::attributes. Why did we add that before the rework?
515 for ( auto attr = decl->attributes.begin() ; attr != decl->attributes.end() ; ) {
516 if ( (*attr)->name == "transparent_union" || (*attr)->name == "__transparent_union__" ) {
517 unionDecl->attributes.emplace_back( attr->release() );
518 attr = decl->attributes.erase( attr );
519 } else {
520 ++attr;
521 }
522 }
523}
524
525// Helper for addTypedef, handles the case where the typedef wraps an
526// aggregate declaration (not a type), returns a chain of nodes.
527static DeclarationNode * addTypedefAggr(
528 DeclarationNode * olddecl, TypeData * newtype ) {
529 TypeData *& oldaggr = olddecl->type->aggInst.aggregate;
530
531 // Handle anonymous aggregates: typedef struct { int i; } foo
532 // Give the typedefed type a consistent name across translation units.
533 if ( oldaggr->aggregate.anon ) {
534 delete oldaggr->aggregate.name;
535 oldaggr->aggregate.name = new string( "__anonymous_" + *olddecl->name );
536 oldaggr->aggregate.anon = false;
537 oldaggr->qualifiers.reset();
538 }
539
540 // Replace the wrapped TypeData with a forward declaration.
541 TypeData * newaggr = new TypeData( TypeData::Aggregate );
542 newaggr->aggregate.kind = oldaggr->aggregate.kind;
543 newaggr->aggregate.name = oldaggr->aggregate.name ? new string( *oldaggr->aggregate.name ) : nullptr;
544 newaggr->aggregate.body = false;
545 newaggr->aggregate.anon = oldaggr->aggregate.anon;
546 newaggr->aggregate.typed = oldaggr->aggregate.typed;
547 newaggr->aggregate.hiding = oldaggr->aggregate.hiding;
548 swap( newaggr, oldaggr );
549
550 newtype->base = olddecl->type;
551 olddecl->type = newtype;
552 DeclarationNode * newdecl = new DeclarationNode;
553 newdecl->type = newaggr;
554 newdecl->next = olddecl;
555
556 moveUnionAttribute( olddecl, newdecl );
557
558 return newdecl;
559}
560
561// Wrap the declaration in a typedef. It actually does that by modifying the
562// existing declaration, and may split it into two declarations.
563// This only happens if the wrapped type is actually a declaration of a SUE
564// type. If it does, the DeclarationNode for the SUE declaration is the node
565// returned, make sure later transformations are applied to the right node.
566DeclarationNode * DeclarationNode::addTypedef() {
567 TypeData * newtype = new TypeData( TypeData::Symbolic );
568 newtype->symbolic.params = nullptr;
569 newtype->symbolic.isTypedef = true;
570 newtype->symbolic.name = name ? new string( *name ) : nullptr;
571 // If this typedef is wrapping an aggregate, separate them out.
572 if ( TypeData::AggregateInst == type->kind
573 && TypeData::Aggregate == type->aggInst.aggregate->kind
574 && type->aggInst.aggregate->aggregate.body ) {
575 return addTypedefAggr( this, newtype );
576 // There is no internal declaration, just a type.
577 } else {
578 newtype->base = type;
579 type = newtype;
580 return this;
581 }
582}
583
584DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) {
585 if ( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS ) {
586 if ( variable.assertions ) {
587 variable.assertions->set_last( assertions );
588 } else {
589 variable.assertions = assertions;
590 } // if
591 return this;
592 } // if
593
594 assert( type );
595 switch ( type->kind ) {
596 case TypeData::Symbolic:
597 if ( type->symbolic.assertions ) {
598 type->symbolic.assertions->set_last( assertions );
599 } else {
600 type->symbolic.assertions = assertions;
601 } // if
602 break;
603 default:
604 assert( false );
605 } // switch
606
607 return this;
608}
609
610DeclarationNode * DeclarationNode::addName( string * newname ) {
611 assert( ! name );
612 name = newname;
613 return this;
614}
615
616DeclarationNode * DeclarationNode::addAsmName( DeclarationNode * newname ) {
617 assert( ! asmName );
618 asmName = newname ? newname->asmName : nullptr;
619 return this->addQualifiers( newname );
620}
621
622DeclarationNode * DeclarationNode::addBitfield( ExpressionNode * size ) {
623 bitfieldWidth = size;
624 return this;
625}
626
627DeclarationNode * DeclarationNode::addVarArgs() {
628 assert( type );
629 hasEllipsis = true;
630 return this;
631}
632
633DeclarationNode * DeclarationNode::addFunctionBody( StatementNode * body, ExpressionNode * withExprs ) {
634 assert( type );
635 assert( type->kind == TypeData::Function );
636 assert( ! type->function.body );
637 type->function.body = body;
638 type->function.withExprs = withExprs;
639 return this;
640}
641
642DeclarationNode * DeclarationNode::addOldDeclList( DeclarationNode * list ) {
643 assert( type );
644 assert( type->kind == TypeData::Function );
645 assert( ! type->function.oldDeclList );
646 type->function.oldDeclList = list;
647 return this;
648}
649
650DeclarationNode * DeclarationNode::setBase( TypeData * newType ) {
651 if ( type ) {
652 type->setLastBase( newType );
653 } else {
654 type = newType;
655 } // if
656 return this;
657}
658
659DeclarationNode * DeclarationNode::copyAttribute( DeclarationNode * a ) {
660 if ( a ) {
661 spliceBegin( attributes, a->attributes );
662 a->attributes.clear();
663 } // if
664 return this;
665} // copyAttribute
666
667DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) {
668 if ( p ) {
669 assert( p->type->kind == TypeData::Pointer || p->type->kind == TypeData::Reference );
670 setBase( p->type );
671 p->type = nullptr;
672 copyAttribute( p );
673 delete p;
674 } // if
675 return this;
676}
677
678DeclarationNode * DeclarationNode::addArray( DeclarationNode * a ) {
679 if ( a ) {
680 assert( a->type->kind == TypeData::Array );
681 setBase( a->type );
682 a->type = nullptr;
683 copyAttribute( a );
684 delete a;
685 } // if
686 return this;
687}
688
689DeclarationNode * DeclarationNode::addNewPointer( DeclarationNode * p ) {
690 if ( p ) {
691 assert( p->type->kind == TypeData::Pointer || p->type->kind == TypeData::Reference );
692 if ( type ) {
693 p->type->base = makeNewBase( type );
694 type = nullptr;
695 } // if
696 delete this;
697 return p;
698 } else {
699 return this;
700 } // if
701}
702
703DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) {
704 if ( ! a ) return this;
705 assert( a->type->kind == TypeData::Array );
706 if ( type ) {
707 a->type->setLastBase( makeNewBase( type ) );
708 type = nullptr;
709 } // if
710 delete this;
711 return a;
712}
713
714DeclarationNode * DeclarationNode::addParamList( DeclarationNode * params ) {
715 TypeData * ftype = new TypeData( TypeData::Function );
716 ftype->function.params = params;
717 setBase( ftype );
718 return this;
719}
720
721static TypeData * addIdListToType( TypeData * type, DeclarationNode * ids ) {
722 if ( type ) {
723 if ( type->kind != TypeData::Function ) {
724 type->base = addIdListToType( type->base, ids );
725 } else {
726 type->function.idList = ids;
727 } // if
728 return type;
729 } else {
730 TypeData * newtype = new TypeData( TypeData::Function );
731 newtype->function.idList = ids;
732 return newtype;
733 } // if
734} // addIdListToType
735
736DeclarationNode * DeclarationNode::addIdList( DeclarationNode * ids ) {
737 type = addIdListToType( type, ids );
738 return this;
739}
740
741DeclarationNode * DeclarationNode::addInitializer( InitializerNode * init ) {
742 initializer = init;
743 return this;
744}
745
746DeclarationNode * DeclarationNode::addTypeInitializer( DeclarationNode * init ) {
747 assertf( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS, "Called addTypeInitializer on something that isn't a type variable." );
748 variable.initializer = init;
749 return this;
750}
751
752DeclarationNode * DeclarationNode::cloneType( string * name ) {
753 DeclarationNode * newnode = newName( name );
754 newnode->type = maybeCopy( type );
755 newnode->copySpecifiers( this );
756 return newnode;
757}
758
759DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o, bool copyattr ) {
760 if ( ! o ) return nullptr;
761 o->copySpecifiers( this, copyattr );
762 if ( type ) {
763 o->type = ::cloneBaseType( type, o->type );
764 } // if
765 return o;
766}
767
768DeclarationNode * DeclarationNode::extractAggregate() const {
769 if ( type ) {
770 TypeData * ret = typeextractAggregate( type );
771 if ( ret ) {
772 DeclarationNode * newnode = new DeclarationNode;
773 newnode->type = ret;
774 if ( ret->kind == TypeData::Aggregate ) {
775 newnode->attributes.swap( ret->aggregate.attributes );
776 } // if
777 return newnode;
778 } // if
779 } // if
780 return nullptr;
781}
782
783// Get the non-anonymous name of the instance type of the declaration,
784// if one exists.
785static const std::string * getInstTypeOfName( ast::Decl * decl ) {
786 if ( auto dwt = dynamic_cast<ast::DeclWithType *>( decl ) ) {
787 if ( auto aggr = dynamic_cast<ast::BaseInstType const *>( dwt->get_type() ) ) {
788 if ( aggr->name.find("anonymous") == std::string::npos ) {
789 return &aggr->name;
790 }
791 }
792 }
793 return nullptr;
794}
795
796void buildList( DeclarationNode * firstNode, std::vector<ast::ptr<ast::Decl>> & outputList ) {
797 SemanticErrorException errors;
798 std::back_insert_iterator<std::vector<ast::ptr<ast::Decl>>> out( outputList );
799
800 for ( const DeclarationNode * cur = firstNode ; cur ; cur = cur->next ) {
801 try {
802 bool extracted_named = false;
803
804 if ( DeclarationNode * extr = cur->extractAggregate() ) {
805 assert( cur->type );
806
807 if ( ast::Decl * decl = extr->build() ) {
808 *out++ = decl;
809
810 // need to remember the cases where a declaration contains an anonymous aggregate definition
811 assert( extr->type );
812 if ( extr->type->kind == TypeData::Aggregate ) {
813 // typedef struct { int A } B is the only case?
814 extracted_named = ! extr->type->aggregate.anon;
815 } else {
816 extracted_named = true;
817 }
818 } // if
819 delete extr;
820 } // if
821
822 if ( ast::Decl * decl = cur->build() ) {
823 if ( "" == decl->name && !cur->get_inLine() ) {
824 // Don't include anonymous declaration for named aggregates,
825 // but do include them for anonymous aggregates, e.g.:
826 // struct S {
827 // struct T { int x; }; // no anonymous member
828 // struct { int y; }; // anonymous member
829 // struct T; // anonymous member
830 // };
831 if ( extracted_named ) {
832 continue;
833 }
834
835 if ( auto name = getInstTypeOfName( decl ) ) {
836 // Temporary: warn about anonymous member declarations of named types, since
837 // this conflicts with the syntax for the forward declaration of an anonymous type.
838 SemanticWarning( cur->location, Warning::AggrForwardDecl, name->c_str() );
839 }
840 } // if
841 *out++ = decl;
842 } // if
843 } catch ( SemanticErrorException & e ) {
844 errors.append( e );
845 } // try
846 } // for
847
848 if ( ! errors.isEmpty() ) {
849 throw errors;
850 } // if
851} // buildList
852
853// currently only builds assertions, function parameters, and return values
854void buildList( DeclarationNode * firstNode, std::vector<ast::ptr<ast::DeclWithType>> & outputList ) {
855 SemanticErrorException errors;
856 std::back_insert_iterator<std::vector<ast::ptr<ast::DeclWithType>>> out( outputList );
857
858 for ( const DeclarationNode * cur = firstNode; cur; cur = cur->next ) {
859 try {
860 ast::Decl * decl = cur->build();
861 assertf( decl, "buildList: build for ast::DeclWithType." );
862 if ( ast::DeclWithType * dwt = dynamic_cast<ast::DeclWithType *>( decl ) ) {
863 dwt->location = cur->location;
864 *out++ = dwt;
865 } else if ( ast::StructDecl * agg = dynamic_cast<ast::StructDecl *>( decl ) ) {
866 // e.g., int foo(struct S) {}
867 auto inst = new ast::StructInstType( agg->name );
868 auto obj = new ast::ObjectDecl( cur->location, "", inst );
869 obj->linkage = linkage;
870 *out++ = obj;
871 delete agg;
872 } else if ( ast::UnionDecl * agg = dynamic_cast<ast::UnionDecl *>( decl ) ) {
873 // e.g., int foo(union U) {}
874 auto inst = new ast::UnionInstType( agg->name );
875 auto obj = new ast::ObjectDecl( cur->location,
876 "", inst, nullptr, ast::Storage::Classes(),
877 linkage );
878 *out++ = obj;
879 } else if ( ast::EnumDecl * agg = dynamic_cast<ast::EnumDecl *>( decl ) ) {
880 // e.g., int foo(enum E) {}
881 auto inst = new ast::EnumInstType( agg->name );
882 auto obj = new ast::ObjectDecl( cur->location,
883 "",
884 inst,
885 nullptr,
886 ast::Storage::Classes(),
887 linkage
888 );
889 *out++ = obj;
890 } else {
891 assertf( false, "buildList: Could not convert to ast::DeclWithType." );
892 } // if
893 } catch ( SemanticErrorException & e ) {
894 errors.append( e );
895 } // try
896 } // for
897
898 if ( ! errors.isEmpty() ) {
899 throw errors;
900 } // if
901} // buildList
902
903void buildTypeList( const DeclarationNode * firstNode,
904 std::vector<ast::ptr<ast::Type>> & outputList ) {
905 SemanticErrorException errors;
906 std::back_insert_iterator<std::vector<ast::ptr<ast::Type>>> out( outputList );
907
908 for ( const DeclarationNode * cur = firstNode ; cur ; cur = cur->next ) {
909 try {
910 * out++ = cur->buildType();
911 } catch ( SemanticErrorException & e ) {
912 errors.append( e );
913 } // try
914 } // for
915
916 if ( ! errors.isEmpty() ) {
917 throw errors;
918 } // if
919} // buildTypeList
920
921ast::Decl * DeclarationNode::build() const {
922 if ( ! error.empty() ) SemanticError( this, error + " in declaration of " );
923
924 if ( asmStmt ) {
925 auto stmt = strict_dynamic_cast<ast::AsmStmt *>( asmStmt->build() );
926 return new ast::AsmDecl( stmt->location, stmt );
927 } // if
928 if ( directiveStmt ) {
929 auto stmt = strict_dynamic_cast<ast::DirectiveStmt *>( directiveStmt->build() );
930 return new ast::DirectiveDecl( stmt->location, stmt );
931 } // if
932
933 if ( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS ) {
934 // otype is internally converted to dtype + otype parameters
935 static const ast::TypeDecl::Kind kindMap[] = { ast::TypeDecl::Dtype, ast::TypeDecl::Dtype, ast::TypeDecl::Dtype, ast::TypeDecl::Ftype, ast::TypeDecl::Ttype, ast::TypeDecl::Dimension };
936 static_assert( sizeof(kindMap) / sizeof(kindMap[0]) == ast::TypeDecl::NUMBER_OF_KINDS, "DeclarationNode::build: kindMap is out of sync." );
937 assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
938 ast::TypeDecl * ret = new ast::TypeDecl( location,
939 *name,
940 ast::Storage::Classes(),
941 (ast::Type *)nullptr,
942 kindMap[ variable.tyClass ],
943 variable.tyClass == ast::TypeDecl::Otype || variable.tyClass == ast::TypeDecl::DStype,
944 variable.initializer ? variable.initializer->buildType() : nullptr
945 );
946 buildList( variable.assertions, ret->assertions );
947 return ret;
948 } // if
949
950 if ( type ) {
951 // Function specifiers can only appear on a function definition/declaration.
952 //
953 // inline _Noreturn int f(); // allowed
954 // inline _Noreturn int g( int i ); // allowed
955 // inline _Noreturn int i; // disallowed
956 if ( type->kind != TypeData::Function && funcSpecs.any() ) {
957 SemanticError( this, "invalid function specifier for " );
958 } // if
959 // Forall qualifier can only appear on a function/aggregate definition/declaration.
960 //
961 // forall int f(); // allowed
962 // forall int g( int i ); // allowed
963 // forall int i; // disallowed
964 if ( type->kind != TypeData::Function && type->forall ) {
965 SemanticError( this, "invalid type qualifier for " );
966 } // if
967 bool isDelete = initializer && initializer->get_isDelete();
968 ast::Decl * decl = buildDecl(
969 type,
970 name ? *name : string( "" ),
971 storageClasses,
972 maybeBuild( bitfieldWidth ),
973 funcSpecs,
974 linkage,
975 asmName,
976 isDelete ? nullptr : maybeBuild( initializer ),
977 copy( attributes )
978 )->set_extension( extension );
979 if ( isDelete ) {
980 auto dwt = strict_dynamic_cast<ast::DeclWithType *>( decl );
981 dwt->isDeleted = true;
982 }
983 return decl;
984 } // if
985
986 if ( assert.condition ) {
987 auto cond = maybeBuild( assert.condition );
988 auto msg = strict_dynamic_cast<ast::ConstantExpr *>( maybeCopy( assert.message ) );
989 return new ast::StaticAssertDecl( location, cond, msg );
990 }
991
992 // SUE's cannot have function specifiers, either
993 //
994 // inline _Noreturn struct S { ... }; // disallowed
995 // inline _Noreturn enum E { ... }; // disallowed
996 if ( funcSpecs.any() ) {
997 SemanticError( this, "invalid function specifier for " );
998 } // if
999 if ( enumInLine ) {
1000 return new ast::InlineMemberDecl( location,
1001 *name, (ast::Type*)nullptr, storageClasses, linkage );
1002 } // if
1003 assertf( name, "ObjectDecl must a have name\n" );
1004 auto ret = new ast::ObjectDecl( location,
1005 *name,
1006 (ast::Type*)nullptr,
1007 maybeBuild( initializer ),
1008 storageClasses,
1009 linkage,
1010 maybeBuild( bitfieldWidth )
1011 );
1012 ret->asmName = asmName;
1013 ret->extension = extension;
1014 return ret;
1015}
1016
1017ast::Type * DeclarationNode::buildType() const {
1018 assert( type );
1019
1020 switch ( type->kind ) {
1021 case TypeData::Aggregate: {
1022 ast::BaseInstType * ret =
1023 buildComAggInst( type, copy( attributes ), linkage );
1024 buildList( type->aggregate.actuals, ret->params );
1025 return ret;
1026 }
1027 case TypeData::Symbolic: {
1028 ast::TypeInstType * ret = new ast::TypeInstType(
1029 *type->symbolic.name,
1030 // This is just a default, the true value is not known yet.
1031 ast::TypeDecl::Dtype,
1032 buildQualifiers( type ),
1033 copy( attributes ) );
1034 buildList( type->symbolic.actuals, ret->params );
1035 return ret;
1036 }
1037 default:
1038 ast::Type * simpletypes = typebuild( type );
1039 // copy because member is const
1040 simpletypes->attributes = attributes;
1041 return simpletypes;
1042 } // switch
1043}
1044
1045// Local Variables: //
1046// tab-width: 4 //
1047// mode: c++ //
1048// compile-command: "make install" //
1049// End: //
Note: See TracBrowser for help on using the repository browser.