source: src/Parser/ExpressionNode.cc@ bc1ab61

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

only implicitly generate typedef for structures if name not in use and overwrite typedef name if explicit name appears, upate parser symbol table
  • Property mode set to 100644
File size: 26.8 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// ExpressionNode.cc --
8//
9// Author : Rodolfo G. Esteves
10// Created On : Sat May 16 13:17:07 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Sun Mar 13 12:34:38 2016
13// Update Count : 272
14//
15
16#include <cassert>
17#include <cctype>
18#include <algorithm>
19#include <sstream>
20#include <cstdio>
21#include <climits>
22
23#include "ParseNode.h"
24#include "SynTree/Constant.h"
25#include "SynTree/Expression.h"
26#include "Common/UnimplementedError.h"
27#include "parseutility.h"
28#include "Common/utility.h"
29
30using namespace std;
31
32ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) {}
33
34ExpressionNode::ExpressionNode( const string *name ) : ParseNode( name ), argName( 0 ) {}
35
36ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ) {
37 if ( other.argName ) {
38 argName = other.argName->clone();
39 } else {
40 argName = 0;
41 } // if
42}
43
44ExpressionNode * ExpressionNode::set_argName( const std::string *aName ) {
45 argName = new VarRefNode( aName );
46 return this;
47}
48
49ExpressionNode * ExpressionNode::set_argName( ExpressionNode *aDesignator ) {
50 argName = aDesignator;
51 return this;
52}
53
54void ExpressionNode::printDesignation( std::ostream &os, int indent ) const {
55 if ( argName ) {
56 os << string( indent, ' ' ) << "(designated by: ";
57 argName->printOneLine( os, indent );
58 os << ")" << std::endl;
59 } // if
60}
61
62//##############################################################################
63
64NullExprNode::NullExprNode() {}
65
66NullExprNode *NullExprNode::clone() const {
67 return new NullExprNode();
68}
69
70void NullExprNode::print( std::ostream & os, int indent ) const {
71 printDesignation( os );
72 os << "null expression";
73}
74
75void NullExprNode::printOneLine( std::ostream & os, int indent ) const {
76 printDesignation( os );
77 os << "null";
78}
79
80Expression *NullExprNode::build() const {
81 return 0;
82}
83
84CommaExprNode *ExpressionNode::add_to_list( ExpressionNode *exp ) {
85 return new CommaExprNode( this, exp );
86}
87
88//##############################################################################
89
90static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
91static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
92static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
93static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
94static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
95static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
96
97// Difficult to separate extra parts of constants during lexing because actions are not allow in the middle of patterns:
98//
99// prefix action constant action suffix
100//
101// Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty:
102//
103// constant BEGIN CONT ...
104// <CONT>(...)? BEGIN 0 ... // possible empty suffix
105//
106// because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
107// type.
108
109ConstantNode::ConstantNode( Type t, string *inVal ) : type( t ), value( *inVal ) {
110 // lexing divides constants into 4 kinds
111 switch ( type ) {
112 case Integer:
113 {
114 static const BasicType::Kind kind[2][3] = {
115 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
116 { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
117 };
118 bool dec = true, Unsigned = false; // decimal, unsigned constant
119 int size; // 0 => int, 1 => long, 2 => long long
120 unsigned long long v; // converted integral value
121 size_t last = value.length() - 1; // last character of constant
122
123 if ( value[0] == '0' ) { // octal constant ?
124 dec = false;
125 if ( last != 0 && checkX( value[1] ) ) { // hex constant ?
126 sscanf( (char *)value.c_str(), "%llx", &v );
127 //printf( "%llx %llu\n", v, v );
128 } else {
129 sscanf( (char *)value.c_str(), "%llo", &v );
130 //printf( "%llo %llu\n", v, v );
131 } // if
132 } else { // decimal constant ?
133 sscanf( (char *)value.c_str(), "%llu", &v );
134 //printf( "%llu %llu\n", v, v );
135 } // if
136
137 if ( v <= INT_MAX ) { // signed int
138 size = 0;
139 } else if ( v <= UINT_MAX && ! dec ) { // unsigned int
140 size = 0;
141 Unsigned = true; // unsigned
142 } else if ( v <= LONG_MAX ) { // signed long int
143 size = 1;
144 } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
145 size = 1;
146 Unsigned = true; // unsigned long int
147 } else if ( v <= LLONG_MAX ) { // signed long long int
148 size = 2;
149 } else { // unsigned long long int
150 size = 2;
151 Unsigned = true; // unsigned long long int
152 } // if
153
154 if ( checkU( value[last] ) ) { // suffix 'u' ?
155 Unsigned = true;
156 if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'l' ?
157 size = 1;
158 if ( last > 1 && checkL( value[ last - 2 ] ) ) { // suffix 'll' ?
159 size = 2;
160 } // if
161 } // if
162 } else if ( checkL( value[ last ] ) ) { // suffix 'l' ?
163 size = 1;
164 if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'll' ?
165 size = 2;
166 if ( last > 1 && checkU( value[ last - 2 ] ) ) { // suffix 'u' ?
167 Unsigned = true;
168 } // if
169 } else {
170 if ( last > 0 && checkU( value[ last - 1 ] ) ) { // suffix 'u' ?
171 Unsigned = true;
172 } // if
173 } // if
174 } // if
175 btype = kind[Unsigned][size]; // lookup constant type
176 break;
177 }
178 case Float:
179 {
180 static const BasicType::Kind kind[2][3] = {
181 { BasicType::Float, BasicType::Double, BasicType::LongDouble },
182 { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
183 };
184 bool complx = false; // real, complex
185 int size = 1; // 0 => float, 1 => double (default), 2 => long double
186 // floating-point constant has minimum of 2 characters: 1. or .1
187 size_t last = value.length() - 1;
188
189 if ( checkI( value[last] ) ) { // imaginary ?
190 complx = true;
191 last -= 1; // backup one character
192 } // if
193 if ( checkF( value[last] ) ) { // float ?
194 size = 0;
195 } else if ( checkD( value[last] ) ) { // double ?
196 size = 1;
197 } else if ( checkL( value[last] ) ) { // long double ?
198 size = 2;
199 } // if
200 if ( ! complx && checkI( value[last - 1] ) ) { // imaginary ?
201 complx = true;
202 } // if
203 btype = kind[complx][size]; // lookup constant type
204 break;
205 }
206 case Character:
207 btype = BasicType::Char; // default
208 if ( string( "LUu" ).find( value[0] ) != string::npos ) {
209 // ???
210 } // if
211 break;
212 case String:
213 // array of char
214 if ( string( "LUu" ).find( value[0] ) != string::npos ) {
215 if ( value[0] == 'u' && value[1] == '8' ) {
216 // ???
217 } else {
218 // ???
219 } // if
220 } // if
221 break;
222 } // switch
223} // ConstantNode::ConstantNode
224
225ConstantNode *ConstantNode::appendstr( const std::string *newValue ) {
226 assert( newValue != 0 );
227 assert( type == String );
228
229 // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
230 value.insert( value.length() - 1, newValue->substr( 1, newValue->length() - 2 ) );
231
232 delete newValue; // allocated by lexer
233 return this;
234}
235
236void ConstantNode::printOneLine( std::ostream &os, int indent ) const {
237 os << string( indent, ' ' );
238 printDesignation( os );
239
240 switch ( type ) {
241 case Integer:
242 case Float:
243 os << value ;
244 break;
245 case Character:
246 os << "'" << value << "'";
247 break;
248 case String:
249 os << '"' << value << '"';
250 break;
251 } // switch
252
253 os << ' ';
254}
255
256void ConstantNode::print( std::ostream &os, int indent ) const {
257 printOneLine( os, indent );
258 os << endl;
259}
260
261Expression *ConstantNode::build() const {
262 ::Type::Qualifiers q; // no qualifiers on constants
263
264 switch ( get_type() ) {
265 case String:
266 {
267 // string should probably be a primitive type
268 ArrayType *at = new ArrayType( q, new BasicType( q, BasicType::Char ),
269 new ConstantExpr(
270 Constant( new BasicType( q, BasicType::UnsignedInt ),
271 toString( value.size()+1-2 ) ) ), // +1 for '\0' and -2 for '"'
272 false, false );
273 return new ConstantExpr( Constant( at, value ), maybeBuild< Expression >( get_argName() ) );
274 }
275 default:
276 return new ConstantExpr( Constant( new BasicType( q, btype ), get_value() ), maybeBuild< Expression >( get_argName() ) );
277 }
278}
279
280//##############################################################################
281
282VarRefNode::VarRefNode() : isLabel( false ) {}
283
284VarRefNode::VarRefNode( const string *name_, bool labelp ) : ExpressionNode( name_ ), isLabel( labelp ) {}
285
286VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) {
287}
288
289Expression *VarRefNode::build() const {
290 return new NameExpr( get_name(), maybeBuild< Expression >( get_argName() ) );
291}
292
293void VarRefNode::printOneLine( std::ostream &os, int indent ) const {
294 printDesignation( os );
295 os << get_name() << ' ';
296}
297
298void VarRefNode::print( std::ostream &os, int indent ) const {
299 printDesignation( os );
300 os << string( indent, ' ' ) << "Referencing: ";
301 os << "Variable: " << get_name();
302 os << endl;
303}
304
305//##############################################################################
306
307DesignatorNode::DesignatorNode( ExpressionNode *expr, bool isArrayIndex ) : isArrayIndex( isArrayIndex ) {
308 set_argName( expr );
309 assert( get_argName() );
310
311 if ( ! isArrayIndex ) {
312 if ( VarRefNode * var = dynamic_cast< VarRefNode * >( expr ) ) {
313
314 stringstream ss( var->get_name() );
315 double value;
316 if ( ss >> value ) {
317 // this is a floating point constant. It MUST be
318 // ".0" or ".1", otherwise the program is invalid
319 if ( ! (var->get_name() == ".0" || var->get_name() == ".1") ) {
320 throw SemanticError( "invalid designator name: " + var->get_name() );
321 } // if
322 var->set_name( var->get_name().substr(1) );
323 } // if
324 } // if
325 } // if
326}
327
328DesignatorNode::DesignatorNode( const DesignatorNode &other ) : ExpressionNode( other ), isArrayIndex( other.isArrayIndex ) {
329}
330
331class DesignatorFixer : public Mutator {
332public:
333 virtual Expression* mutate( NameExpr *nameExpr ) {
334 if ( nameExpr->get_name() == "0" || nameExpr->get_name() == "1" ) {
335 Constant val( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nameExpr->get_name() );
336 delete nameExpr;
337 return new ConstantExpr( val );
338 }
339 return nameExpr;
340 }
341};
342
343Expression *DesignatorNode::build() const {
344 Expression * ret = get_argName()->build();
345
346 if ( isArrayIndex ) {
347 // need to traverse entire structure and change any instances of 0 or 1 to
348 // ConstantExpr
349 DesignatorFixer fixer;
350 ret = ret->acceptMutator( fixer );
351 } // if
352
353 return ret;
354}
355
356void DesignatorNode::printOneLine( std::ostream &os, int indent ) const {
357 if ( get_argName() ) {
358 if ( isArrayIndex ) {
359 os << "[";
360 get_argName()->printOneLine( os, indent );
361 os << "]";
362 } else {
363 os << ".";
364 get_argName()->printOneLine( os, indent );
365 }
366 } // if
367}
368
369void DesignatorNode::print( std::ostream &os, int indent ) const {
370 if ( get_argName() ) {
371 if ( isArrayIndex ) {
372 os << "[";
373 get_argName()->print( os, indent );
374 os << "]";
375 } else {
376 os << ".";
377 get_argName()->print( os, indent );
378 }
379 } // if
380}
381
382//##############################################################################
383
384static const char *opName[] = {
385 "TupleC", "Comma", "TupleFieldSel", // "TuplePFieldSel", // n-adic
386 // triadic
387 "Cond", "NCond",
388 // diadic
389 "SizeOf", "AlignOf", "OffsetOf", "Attr", "CompLit", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
390 "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
391 "?=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
392 "?[?]", "FieldSel", "PFieldSel", "Range",
393 // monadic
394 "+?", "-?", "AddressOf", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "&&"
395};
396
397OperatorNode::OperatorNode( Type t ) : type( t ) {}
398
399OperatorNode::OperatorNode( const OperatorNode &other ) : ExpressionNode( other ), type( other.type ) {
400}
401
402OperatorNode::~OperatorNode() {}
403
404OperatorNode::Type OperatorNode::get_type( void ) const{
405 return type;
406}
407
408void OperatorNode::printOneLine( std::ostream &os, int indent ) const {
409 printDesignation( os );
410 os << opName[ type ] << ' ';
411}
412
413void OperatorNode::print( std::ostream &os, int indent ) const{
414 printDesignation( os );
415 os << string( indent, ' ' ) << "Operator: " << opName[type] << endl;
416 return;
417}
418
419const char *OperatorNode::get_typename( void ) const{
420 return opName[ type ];
421}
422
423//##############################################################################
424
425CompositeExprNode::CompositeExprNode() : ExpressionNode(), function( 0 ), arguments( 0 ) {
426}
427
428CompositeExprNode::CompositeExprNode( const string *name_ ) : ExpressionNode( name_ ), function( 0 ), arguments( 0 ) {
429}
430
431CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *args ):
432 function( f ), arguments( args ) {
433}
434
435CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2):
436 function( f ), arguments( arg1 ) {
437 arguments->set_link( arg2 );
438}
439
440CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ) {
441 ParseNode *cur = other.arguments;
442 while ( cur ) {
443 if ( arguments ) {
444 arguments->set_link( cur->clone() );
445 } else {
446 arguments = ( ExpressionNode*)cur->clone();
447 } // if
448 cur = cur->get_link();
449 }
450}
451
452CompositeExprNode::~CompositeExprNode() {
453 delete function;
454 delete arguments;
455}
456
457#include "Common/utility.h"
458
459Expression *CompositeExprNode::build() const {
460 OperatorNode *op;
461 std::list<Expression *> args;
462
463 buildList( get_args(), args );
464
465 if ( ! ( op = dynamic_cast<OperatorNode *>( function ) ) ) { // function as opposed to operator
466 return new UntypedExpr( function->build(), args, maybeBuild< Expression >( get_argName() ));
467 } // if
468
469 switch ( op->get_type()) {
470 case OperatorNode::Incr:
471 case OperatorNode::Decr:
472 case OperatorNode::IncrPost:
473 case OperatorNode::DecrPost:
474 case OperatorNode::Assign:
475 case OperatorNode::MulAssn:
476 case OperatorNode::DivAssn:
477 case OperatorNode::ModAssn:
478 case OperatorNode::PlusAssn:
479 case OperatorNode::MinusAssn:
480 case OperatorNode::LSAssn:
481 case OperatorNode::RSAssn:
482 case OperatorNode::AndAssn:
483 case OperatorNode::ERAssn:
484 case OperatorNode::OrAssn:
485 // the rewrite rules for these expressions specify that the first argument has its address taken
486 assert( ! args.empty() );
487 args.front() = new AddressExpr( args.front() );
488 break;
489 default: // do nothing
490 ;
491 } // switch
492
493 switch ( op->get_type() ) {
494 case OperatorNode::Incr:
495 case OperatorNode::Decr:
496 case OperatorNode::IncrPost:
497 case OperatorNode::DecrPost:
498 case OperatorNode::Assign:
499 case OperatorNode::MulAssn:
500 case OperatorNode::DivAssn:
501 case OperatorNode::ModAssn:
502 case OperatorNode::PlusAssn:
503 case OperatorNode::MinusAssn:
504 case OperatorNode::LSAssn:
505 case OperatorNode::RSAssn:
506 case OperatorNode::AndAssn:
507 case OperatorNode::ERAssn:
508 case OperatorNode::OrAssn:
509 case OperatorNode::Plus:
510 case OperatorNode::Minus:
511 case OperatorNode::Mul:
512 case OperatorNode::Div:
513 case OperatorNode::Mod:
514 case OperatorNode::BitOr:
515 case OperatorNode::BitAnd:
516 case OperatorNode::Xor:
517 case OperatorNode::LShift:
518 case OperatorNode::RShift:
519 case OperatorNode::LThan:
520 case OperatorNode::GThan:
521 case OperatorNode::LEThan:
522 case OperatorNode::GEThan:
523 case OperatorNode::Eq:
524 case OperatorNode::Neq:
525 case OperatorNode::Index:
526 case OperatorNode::Range:
527 case OperatorNode::UnPlus:
528 case OperatorNode::UnMinus:
529 case OperatorNode::PointTo:
530 case OperatorNode::Neg:
531 case OperatorNode::BitNeg:
532 case OperatorNode::LabelAddress:
533 return new UntypedExpr( new NameExpr( opName[ op->get_type() ] ), args );
534 case OperatorNode::AddressOf:
535 assert( args.size() == 1 );
536 assert( args.front() );
537
538 return new AddressExpr( args.front() );
539 case OperatorNode::Cast:
540 {
541 TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args());
542 assert( arg );
543
544 DeclarationNode *decl_node = arg->get_decl();
545 ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>( arg->get_link());
546
547 Type *targetType = decl_node->buildType();
548 if ( dynamic_cast< VoidType* >( targetType ) ) {
549 delete targetType;
550 return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
551 } else {
552 return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
553 } // if
554 }
555 case OperatorNode::FieldSel:
556 {
557 assert( args.size() == 2 );
558
559 NameExpr *member = dynamic_cast<NameExpr *>( args.back());
560 // TupleExpr *memberTup = dynamic_cast<TupleExpr *>( args.back());
561
562 if ( member != 0 ) {
563 UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front());
564 delete member;
565 return ret;
566 /* else if ( memberTup != 0 )
567 {
568 UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front());
569 delete member;
570 return ret;
571 } */
572 } else
573 assert( false );
574 }
575 case OperatorNode::PFieldSel:
576 {
577 assert( args.size() == 2 );
578
579 NameExpr *member = dynamic_cast<NameExpr *>( args.back()); // modify for Tuples xxx
580 assert( member != 0 );
581
582 UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
583 deref->get_args().push_back( args.front() );
584
585 UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
586 delete member;
587 return ret;
588 }
589 case OperatorNode::SizeOf:
590 {
591 if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
592 return new SizeofExpr( arg->get_decl()->buildType());
593 } else {
594 return new SizeofExpr( args.front());
595 } // if
596 }
597 case OperatorNode::AlignOf:
598 {
599 if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
600 return new AlignofExpr( arg->get_decl()->buildType());
601 } else {
602 return new AlignofExpr( args.front());
603 } // if
604 }
605 case OperatorNode::OffsetOf:
606 {
607 assert( args.size() == 2 );
608
609 if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args() ) ) {
610 NameExpr *member = dynamic_cast<NameExpr *>( args.back() );
611 assert( member != 0 );
612
613 return new UntypedOffsetofExpr( arg->get_decl()->buildType(), member->get_name() );
614 } else assert( false );
615 }
616 case OperatorNode::Attr:
617 {
618 VarRefNode *var = dynamic_cast<VarRefNode *>( get_args());
619 assert( var );
620 if ( ! get_args()->get_link() ) {
621 return new AttrExpr( var->build(), ( Expression*)0);
622 } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {
623 return new AttrExpr( var->build(), arg->get_decl()->buildType());
624 } else {
625 return new AttrExpr( var->build(), args.back());
626 } // if
627 }
628 case OperatorNode::CompLit:
629 throw UnimplementedError( "C99 compound literals" );
630 // the short-circuited operators
631 case OperatorNode::Or:
632 case OperatorNode::And:
633 assert( args.size() == 2);
634 return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), ( op->get_type() == OperatorNode::And ) );
635 case OperatorNode::Cond:
636 {
637 assert( args.size() == 3);
638 std::list< Expression * >::const_iterator i = args.begin();
639 Expression *arg1 = notZeroExpr( *i++ );
640 Expression *arg2 = *i++;
641 Expression *arg3 = *i++;
642 return new ConditionalExpr( arg1, arg2, arg3 );
643 }
644 case OperatorNode::NCond:
645 throw UnimplementedError( "GNU 2-argument conditional expression" );
646 case OperatorNode::Comma:
647 {
648 assert( args.size() == 2);
649 std::list< Expression * >::const_iterator i = args.begin();
650 Expression *ret = *i++;
651 while ( i != args.end() ) {
652 ret = new CommaExpr( ret, *i++ );
653 }
654 return ret;
655 }
656 // Tuples
657 case OperatorNode::TupleC:
658 {
659 TupleExpr *ret = new TupleExpr();
660 std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) );
661 return ret;
662 }
663 default:
664 // shouldn't happen
665 assert( false );
666 return 0;
667 } // switch
668}
669
670void CompositeExprNode::printOneLine( std::ostream &os, int indent ) const {
671 printDesignation( os );
672 os << "( ";
673 function->printOneLine( os, indent );
674 for ( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
675 cur->printOneLine( os, indent );
676 } // for
677 os << ") ";
678}
679
680void CompositeExprNode::print( std::ostream &os, int indent ) const {
681 printDesignation( os );
682 os << string( indent, ' ' ) << "Application of: " << endl;
683 function->print( os, indent + ParseNode::indent_by );
684
685 os << string( indent, ' ' ) ;
686 if ( arguments ) {
687 os << "... on arguments: " << endl;
688 arguments->printList( os, indent + ParseNode::indent_by );
689 } else
690 os << "... on no arguments: " << endl;
691}
692
693void CompositeExprNode::set_function( ExpressionNode *f ) {
694 function = f;
695}
696
697void CompositeExprNode::set_args( ExpressionNode *args ) {
698 arguments = args;
699}
700
701ExpressionNode *CompositeExprNode::get_function( void ) const {
702 return function;
703}
704
705ExpressionNode *CompositeExprNode::get_args( void ) const {
706 return arguments;
707}
708
709void CompositeExprNode::add_arg( ExpressionNode *arg ) {
710 if ( arguments )
711 arguments->set_link( arg );
712 else
713 set_args( arg );
714}
715
716//##############################################################################
717
718Expression *AsmExprNode::build() const {
719 return new AsmExpr( maybeBuild< Expression >( inout ), (ConstantExpr *)constraint->build(), operand->build() );
720}
721
722void AsmExprNode::print( std::ostream &os, int indent ) const {
723 os << string( indent, ' ' ) << "Assembler Expression:" << endl;
724 if ( inout ) {
725 os << string( indent, ' ' ) << "inout: " << std::endl;
726 inout->print( os, indent + 2 );
727 } // if
728 if ( constraint ) {
729 os << string( indent, ' ' ) << "constraint: " << std::endl;
730 constraint->print( os, indent + 2 );
731 } // if
732 if ( operand ) {
733 os << string( indent, ' ' ) << "operand: " << std::endl;
734 operand->print( os, indent + 2 );
735 } // if
736}
737
738void AsmExprNode::printOneLine( std::ostream &os, int indent ) const {
739 printDesignation( os );
740 os << "( ";
741 if ( inout ) inout->printOneLine( os, indent + 2 );
742 os << ", ";
743 if ( constraint ) constraint->printOneLine( os, indent + 2 );
744 os << ", ";
745 if ( operand ) operand->printOneLine( os, indent + 2 );
746 os << ") ";
747}
748
749//##############################################################################
750
751void LabelNode::print( std::ostream &os, int indent ) const {}
752
753void LabelNode::printOneLine( std::ostream &os, int indent ) const {}
754
755//##############################################################################
756
757CommaExprNode::CommaExprNode(): CompositeExprNode( new OperatorNode( OperatorNode::Comma )) {}
758
759CommaExprNode::CommaExprNode( ExpressionNode *exp ) : CompositeExprNode( new OperatorNode( OperatorNode::Comma ), exp ) {
760}
761
762CommaExprNode::CommaExprNode( ExpressionNode *exp1, ExpressionNode *exp2) : CompositeExprNode( new OperatorNode( OperatorNode::Comma ), exp1, exp2) {
763}
764
765CommaExprNode *CommaExprNode::add_to_list( ExpressionNode *exp ) {
766 add_arg( exp );
767
768 return this;
769}
770
771CommaExprNode::CommaExprNode( const CommaExprNode &other ) : CompositeExprNode( other ) {
772}
773
774//##############################################################################
775
776ValofExprNode::ValofExprNode( StatementNode *s ): body( s ) {}
777
778ValofExprNode::ValofExprNode( const ValofExprNode &other ) : ExpressionNode( other ), body( maybeClone( body ) ) {
779}
780
781ValofExprNode::~ValofExprNode() {
782 delete body;
783}
784
785void ValofExprNode::print( std::ostream &os, int indent ) const {
786 printDesignation( os );
787 os << string( indent, ' ' ) << "Valof Expression:" << std::endl;
788 get_body()->print( os, indent + 4);
789}
790
791void ValofExprNode::printOneLine( std::ostream &, int indent ) const {
792 assert( false );
793}
794
795Expression *ValofExprNode::build() const {
796 return new UntypedValofExpr ( get_body()->build(), maybeBuild< Expression >( get_argName() ) );
797}
798
799//##############################################################################
800
801ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) {
802 if ( init_ == 0 )
803 init = 0;
804 else {
805 DeclarationNode *decl;
806 ExpressionNode *exp;
807
808 if (( decl = dynamic_cast<DeclarationNode *>(init_) ) != 0)
809 init = new StatementNode( decl );
810 else if (( exp = dynamic_cast<ExpressionNode *>( init_)) != 0)
811 init = new StatementNode( StatementNode::Exp, exp );
812 else
813 throw SemanticError("Error in for control expression");
814 }
815}
816
817ForCtlExprNode::ForCtlExprNode( const ForCtlExprNode &other )
818 : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) ) {
819}
820
821ForCtlExprNode::~ForCtlExprNode() {
822 delete init;
823 delete condition;
824 delete change;
825}
826
827Expression *ForCtlExprNode::build() const {
828 // this shouldn't be used!
829 assert( false );
830 return 0;
831}
832
833void ForCtlExprNode::print( std::ostream &os, int indent ) const{
834 os << string( indent,' ' ) << "For Control Expression -- :" << endl;
835
836 os << string( indent + 2, ' ' ) << "initialization:" << endl;
837 if ( init != 0 )
838 init->printList( os, indent + 4 );
839
840 os << string( indent + 2, ' ' ) << "condition: " << endl;
841 if ( condition != 0 )
842 condition->print( os, indent + 4 );
843 os << string( indent + 2, ' ' ) << "increment: " << endl;
844 if ( change != 0 )
845 change->print( os, indent + 4 );
846}
847
848void ForCtlExprNode::printOneLine( std::ostream &, int indent ) const {
849 assert( false );
850}
851
852//##############################################################################
853
854TypeValueNode::TypeValueNode( DeclarationNode *decl ) : decl( decl ) {
855}
856
857TypeValueNode::TypeValueNode( const TypeValueNode &other ) : ExpressionNode( other ), decl( maybeClone( other.decl ) ) {
858}
859
860Expression *TypeValueNode::build() const {
861 return new TypeExpr( decl->buildType() );
862}
863
864void TypeValueNode::print( std::ostream &os, int indent ) const {
865 os << std::string( indent, ' ' ) << "Type:";
866 get_decl()->print( os, indent + 2);
867}
868
869void TypeValueNode::printOneLine( std::ostream &os, int indent ) const {
870 os << "Type:";
871 get_decl()->print( os, indent + 2);
872}
873
874ExpressionNode *flattenCommas( ExpressionNode *list ) {
875 if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {
876 OperatorNode *op;
877 if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) ) {
878 if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
879 composite->add_arg( next );
880 return flattenCommas( composite->get_args() );
881 } // if
882 } // if
883
884 if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
885 list->set_next( flattenCommas( next ) );
886
887 return list;
888}
889
890ExpressionNode *tupleContents( ExpressionNode *tuple ) {
891 if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) {
892 OperatorNode *op = 0;
893 if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::TupleC ) )
894 return composite->get_args();
895 } // if
896 return tuple;
897}
898
899// Local Variables: //
900// tab-width: 4 //
901// mode: c++ //
902// compile-command: "make install" //
903// End: //
Note: See TracBrowser for help on using the repository browser.