source: src/Parser/ExpressionNode.cc @ 9706554

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since 9706554 was 9706554, checked in by Peter A. Buhr <pabuhr@…>, 9 years ago

even more refactoring of parser code

  • Property mode set to 100644
File size: 22.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// 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 : Fri Aug  5 11:39:25 2016
13// Update Count     : 391
14//
15
16#include <cassert>
17#include <cctype>
18#include <algorithm>
19#include <sstream>
20#include <cstdio>
21
22#include "ParseNode.h"
23#include "TypeData.h"
24#include "SynTree/Constant.h"
25#include "SynTree/Expression.h"
26#include "SynTree/Declaration.h"
27#include "Common/UnimplementedError.h"
28#include "parseutility.h"
29#include "Common/utility.h"
30
31using namespace std;
32
33ExpressionNode::ExpressionNode() : ParseNode() {}
34
35ExpressionNode::ExpressionNode( const string *name ) : ParseNode( name ) {}
36
37ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ), extension( other.extension ) {
38        if ( other.argName ) {
39                argName = other.argName->clone();
40        } else {
41                argName = 0;
42        } // if
43}
44
45ExpressionNode * ExpressionNode::set_argName( const std::string *aName ) {
46        argName = new VarRefNode( aName );
47        return this;
48}
49
50ExpressionNode * ExpressionNode::set_argName( ExpressionNode *aDesignator ) {
51        argName = aDesignator;
52        return this;
53}
54
55void ExpressionNode::printDesignation( std::ostream &os, int indent ) const {
56        if ( argName ) {
57                os << string( indent, ' ' ) << "(designated by:  ";
58                argName->printOneLine( os, indent );
59                os << ")" << std::endl;
60        } // if
61}
62
63//##############################################################################
64
65NullExprNode::NullExprNode() {}
66
67NullExprNode *NullExprNode::clone() const {
68        return new NullExprNode();
69}
70
71void NullExprNode::print( std::ostream & os, int indent ) const {
72        printDesignation( os );
73        os << "null expression";
74}
75
76void NullExprNode::printOneLine( std::ostream & os, int indent ) const {
77        printDesignation( os );
78        os << "null";
79}
80
81Expression *NullExprNode::build() const {
82        return 0;
83}
84
85// CommaExprNode *ExpressionNode::add_to_list( ExpressionNode *exp ) {
86//      return new CommaExprNode( this, exp );
87// }
88
89//##############################################################################
90
91ConstantNode::ConstantNode( ConstantExpr *expr ) : expr( expr ) {
92} // ConstantNode::ConstantNode
93
94ConstantNode *ConstantNode::appendstr( const std::string *newValue ) {
95        assert( newValue != 0 );
96
97        string value = expr->get_constant()->get_value();
98
99        // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
100        value.insert( value.length() - 1, newValue->substr( 1, newValue->length() - 2 ) );
101        expr->get_constant()->set_value( value );
102
103        delete newValue;                                                                        // allocated by lexer
104        return this;
105}
106
107void ConstantNode::printOneLine( std::ostream &os, int indent ) const {
108        // os << string( indent, ' ' );
109        // printDesignation( os );
110
111        // switch ( type ) {
112        //   case Integer:
113        //   case Float:
114        //      os << value ;
115        //      break;
116        //   case Character:
117        //      os << "'" << value << "'";
118        //      break;
119        //   case String:
120        //      os << '"' << value << '"';
121        //      break;
122        // } // switch
123
124        // os << ' ';
125}
126
127void ConstantNode::print( std::ostream &os, int indent ) const {
128        printOneLine( os, indent );
129        os << endl;
130}
131
132Expression *ConstantNode::build() const {
133        return expr->clone();
134}
135
136//##############################################################################
137
138VarRefNode::VarRefNode() : isLabel( false ) {}
139
140VarRefNode::VarRefNode( const string *name_, bool labelp ) : ExpressionNode( name_ ), isLabel( labelp ) {}
141
142VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) {
143}
144
145Expression *VarRefNode::build() const {
146        return new NameExpr( get_name(), maybeBuild< Expression >( get_argName() ) );
147}
148
149void VarRefNode::printOneLine( std::ostream &os, int indent ) const {
150        printDesignation( os );
151        os << get_name() << ' ';
152}
153
154void VarRefNode::print( std::ostream &os, int indent ) const {
155        printDesignation( os );
156        os << string( indent, ' ' ) << "Referencing: ";
157        os << "Variable: " << get_name();
158        os << endl;
159}
160
161//##############################################################################
162
163DesignatorNode::DesignatorNode( ExpressionNode *expr, bool isArrayIndex ) : isArrayIndex( isArrayIndex ) {
164        set_argName( expr );
165        assert( get_argName() );
166
167        if ( ! isArrayIndex ) {
168                if ( VarRefNode * var = dynamic_cast< VarRefNode * >( expr ) ) {
169
170                        stringstream ss( var->get_name() );
171                        double value;
172                        if ( ss >> value ) {
173                                // this is a floating point constant. It MUST be
174                                // ".0" or ".1", otherwise the program is invalid
175                                if ( ! (var->get_name() == ".0" || var->get_name() == ".1") ) {
176                                        throw SemanticError( "invalid designator name: " + var->get_name() );
177                                } // if
178                                var->set_name( var->get_name().substr(1) );
179                        } // if
180                } // if
181        } // if
182}
183
184DesignatorNode::DesignatorNode( const DesignatorNode &other ) : ExpressionNode( other ), isArrayIndex( other.isArrayIndex ) {
185}
186
187class DesignatorFixer : public Mutator {
188public:
189        virtual Expression* mutate( NameExpr *nameExpr ) {
190                if ( nameExpr->get_name() == "0" || nameExpr->get_name() == "1" ) {
191                        Constant val( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nameExpr->get_name() );
192                        delete nameExpr;
193                        return new ConstantExpr( val );
194                }
195                return nameExpr;
196        }
197};
198
199Expression *DesignatorNode::build() const {
200        Expression * ret = maybeBuild<Expression>(get_argName());
201
202        if ( isArrayIndex ) {
203                // need to traverse entire structure and change any instances of 0 or 1 to
204                // ConstantExpr
205                DesignatorFixer fixer;
206                ret = ret->acceptMutator( fixer );
207        } // if
208
209        return ret;
210}
211
212void DesignatorNode::printOneLine( std::ostream &os, int indent ) const {
213        if ( get_argName() ) {
214                if ( isArrayIndex ) {
215                        os << "[";
216                        get_argName()->printOneLine( os, indent );
217                        os << "]";
218                } else {
219                        os << ".";
220                        get_argName()->printOneLine( os, indent );
221                }
222        } // if
223}
224
225void DesignatorNode::print( std::ostream &os, int indent ) const {
226        if ( get_argName() ) {
227                if ( isArrayIndex ) {
228                        os << "[";
229                        get_argName()->print( os, indent );
230                        os << "]";
231                } else {
232                        os << ".";
233                        get_argName()->print( os, indent );
234                }
235        } // if
236}
237
238//##############################################################################
239
240static const char *opName[] = {
241        "TupleC", "Comma", "TupleFieldSel", // "TuplePFieldSel", // n-adic
242        // triadic
243        "Cond", "NCond",
244        // diadic
245        "SizeOf", "AlignOf", "OffsetOf", "Attr", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
246        "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
247        "?=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
248        "?[?]", "FieldSel", "PFieldSel", "...",
249        // monadic
250        "+?", "-?", "AddressOf", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "&&"
251};
252
253OperatorNode::OperatorNode( Type t ) : type( t ) {}
254
255OperatorNode::OperatorNode( const OperatorNode &other ) : ExpressionNode( other ), type( other.type ) {
256}
257
258OperatorNode::~OperatorNode() {}
259
260OperatorNode::Type OperatorNode::get_type( void ) const {
261        return type;
262}
263
264void OperatorNode::printOneLine( std::ostream &os, int indent ) const {
265        printDesignation( os );
266        os << opName[ type ] << ' ';
267}
268
269void OperatorNode::print( std::ostream &os, int indent ) const{
270        printDesignation( os );
271        os << string( indent, ' ' ) << "Operator: " << opName[type] << endl;
272        return;
273}
274
275const char *OperatorNode::get_typename( void ) const{
276        return opName[ type ];
277}
278
279//##############################################################################
280
281CompositeExprNode::CompositeExprNode() : ExpressionNode(), function( 0 ), arguments( 0 ) {
282}
283
284CompositeExprNode::CompositeExprNode( const string *name_ ) : ExpressionNode( name_ ), function( 0 ), arguments( 0 ) {
285}
286
287CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *args ):
288        function( f ), arguments( args ) {
289}
290
291CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 ):
292        function( f ), arguments( arg1 ) {
293        arguments->set_link( arg2 );
294}
295
296CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ), arguments( 0 ) {
297        ParseNode *cur = other.arguments;
298        while ( cur ) {
299                if ( arguments ) {
300                        arguments->set_link( cur->clone() );
301                } else {
302                        arguments = ( ExpressionNode*)cur->clone();
303                } // if
304                cur = cur->get_link();
305        }
306}
307
308CompositeExprNode::~CompositeExprNode() {
309        delete function;
310        delete arguments;
311}
312
313
314Expression *build_cast( TypeValueNode * arg, ExpressionNode *expr_node ) {
315        DeclarationNode *decl_node = arg->get_decl();
316
317        Type *targetType = decl_node->buildType();
318        if ( dynamic_cast< VoidType* >( targetType ) ) {
319                delete targetType;
320                return new CastExpr( maybeBuild<Expression>(expr_node) );
321        } else {
322                return new CastExpr( maybeBuild<Expression>(expr_node), targetType );
323        } // if
324}
325
326Expression *build_fieldSel( ExpressionNode *expr_node, VarRefNode *member ) {
327        NameExpr* memberExpr = dynamic_cast<NameExpr*> ( maybeBuild<Expression>( member) );
328        assert( memberExpr );
329        UntypedMemberExpr *ret = new UntypedMemberExpr( memberExpr->get_name(), maybeBuild<Expression>(expr_node) );
330        delete member;
331        return ret;
332}
333
334Expression *build_pfieldSel( ExpressionNode *expr_node, VarRefNode *member ) {
335        NameExpr* memberExpr = dynamic_cast<NameExpr*> ( maybeBuild<Expression>( member) );
336        assert( memberExpr );
337        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
338        deref->get_args().push_back( maybeBuild<Expression>(expr_node) );
339        UntypedMemberExpr *ret = new UntypedMemberExpr( memberExpr->get_name(), deref );
340        delete member;
341        return ret;
342}
343
344Expression *build_addressOf( ExpressionNode *expr_node ) {
345                return new AddressExpr( maybeBuild<Expression>(expr_node) );
346}
347Expression *build_sizeOf( ExpressionNode *expr_node ) {
348        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( expr_node ) ) {
349                return new SizeofExpr( arg->get_decl()->buildType() );
350        } else {
351                return new SizeofExpr( maybeBuild<Expression>(expr_node) );
352        } // if
353}
354Expression *build_alignOf( ExpressionNode *expr_node ) {
355        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( expr_node ) ) {
356                return new AlignofExpr( arg->get_decl()->buildType() );
357        } else {
358                return new AlignofExpr( maybeBuild<Expression>(expr_node) );
359        } // if
360}
361Expression *build_offsetOf( TypeValueNode * arg, VarRefNode *member ) {
362        NameExpr *memberExpr = dynamic_cast<NameExpr *>( maybeBuild<Expression>( member ) );
363        assert( memberExpr );
364        return new UntypedOffsetofExpr( arg->get_decl()->buildType(), memberExpr->get_name() );
365}
366
367Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind ) {
368        return new LogicalExpr( notZeroExpr( maybeBuild<Expression>(expr_node1) ), notZeroExpr( maybeBuild<Expression>(expr_node2) ), kind );
369}
370
371Expression *build_unary_val( OperatorNode::Type op, ExpressionNode *expr_node ) {
372        std::list<Expression *> args;
373        args.push_back( maybeBuild<Expression>(expr_node) );
374        return new UntypedExpr( new NameExpr( opName[ op ] ), args );
375}
376Expression *build_unary_ptr( OperatorNode::Type op, ExpressionNode *expr_node ) {
377        std::list<Expression *> args;
378        args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node) ) );
379        return new UntypedExpr( new NameExpr( opName[ op ] ), args );
380}
381Expression *build_binary_val( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
382        std::list<Expression *> args;
383        args.push_back( maybeBuild<Expression>(expr_node1) );
384        args.push_back( maybeBuild<Expression>(expr_node2) );
385        return new UntypedExpr( new NameExpr( opName[ op ] ), args );
386}
387Expression *build_binary_ptr( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
388        std::list<Expression *> args;
389        args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node1) ) );
390        args.push_back( maybeBuild<Expression>(expr_node2) );
391        return new UntypedExpr( new NameExpr( opName[ op ] ), args );
392}
393
394Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ) {
395        return new ConditionalExpr( notZeroExpr( maybeBuild<Expression>(expr_node1) ), maybeBuild<Expression>(expr_node2), maybeBuild<Expression>(expr_node3) );
396}
397
398Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
399        return new CommaExpr( maybeBuild<Expression>(expr_node1), maybeBuild<Expression>(expr_node2) );
400}
401
402Expression *build_attr( VarRefNode *var, ExpressionNode * expr ) {
403        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( expr ) ) {
404                return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType() );
405        } else {
406                return new AttrExpr( maybeBuild<Expression>(var), maybeBuild<Expression>(expr) );
407        } // if
408}
409
410Expression *build_tuple( ExpressionNode * expr ) {
411        TupleExpr *ret = new TupleExpr();
412        buildList( expr, ret->get_exprs() );
413        return ret;
414}
415
416Expression *build_func( ExpressionNode * function, ExpressionNode * expr ) {
417        std::list<Expression *> args;
418
419        buildList( expr, args );
420        return new UntypedExpr( maybeBuild<Expression>(function), args, nullptr );
421}
422
423CompositeExprNode2::CompositeExprNode2( Expression *expr ) : expr( expr ) {}
424CompositeExprNode2::CompositeExprNode2( const CompositeExprNode2 &other ) : expr( other.expr->clone() ) {}
425CompositeExprNode2::~CompositeExprNode2() { delete expr; }
426void CompositeExprNode2::print( std::ostream &, int indent ) const { assert( false ); }
427void CompositeExprNode2::printOneLine( std::ostream &, int indent ) const { assert( false ); }
428
429
430Expression *CompositeExprNode::build() const {
431        OperatorNode *op;
432        std::list<Expression *> args;
433
434        buildList( get_args(), args );
435
436        if ( ! ( op = dynamic_cast<OperatorNode *>( function ) ) ) { // function as opposed to operator
437                return new UntypedExpr( maybeBuild<Expression>(function), args, maybeBuild< Expression >( get_argName() ));
438        } // if
439
440        assert( ((void)"CompositeExprNode::build", false) );
441        return nullptr;
442}
443
444void CompositeExprNode::printOneLine( std::ostream &os, int indent ) const {
445        printDesignation( os );
446        os << "( ";
447        function->printOneLine( os, indent );
448        for ( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
449                cur->printOneLine( os, indent );
450        } // for
451        os << ") ";
452}
453
454void CompositeExprNode::print( std::ostream &os, int indent ) const {
455        printDesignation( os );
456        os << string( indent, ' ' ) << "Application of: " << endl;
457        function->print( os, indent + ParseNode::indent_by );
458
459        os << string( indent, ' ' ) ;
460        if ( arguments ) {
461                os << "... on arguments: " << endl;
462                arguments->printList( os, indent + ParseNode::indent_by );
463        } else
464                os << "... on no arguments: " << endl;
465}
466
467void CompositeExprNode::set_function( ExpressionNode *f ) {
468        function = f;
469}
470
471void CompositeExprNode::set_args( ExpressionNode *args ) {
472        arguments = args;
473}
474
475ExpressionNode *CompositeExprNode::get_function( void ) const {
476        return function;
477}
478
479ExpressionNode *CompositeExprNode::get_args( void ) const {
480        return arguments;
481}
482
483void CompositeExprNode::add_arg( ExpressionNode *arg ) {
484        if ( arguments )
485                arguments->set_link( arg );
486        else
487                set_args( arg );
488}
489
490//##############################################################################
491
492Expression *AsmExprNode::build() const {
493        return new AsmExpr( maybeBuild< Expression >( inout ), (ConstantExpr *)maybeBuild<Expression>(constraint), maybeBuild<Expression>(operand) );
494}
495
496void AsmExprNode::print( std::ostream &os, int indent ) const {
497        os << string( indent, ' ' ) << "Assembler Expression:" << endl;
498        if ( inout ) {
499                os << string( indent, ' ' ) << "inout: " << std::endl;
500                inout->print( os, indent + 2 );
501        } // if
502        if ( constraint ) {
503                os << string( indent, ' ' ) << "constraint: " << std::endl;
504                constraint->print( os, indent + 2 );
505        } // if
506        if ( operand ) {
507                os << string( indent, ' ' ) << "operand: " << std::endl;
508                operand->print( os, indent + 2 );
509        } // if
510}
511
512void AsmExprNode::printOneLine( std::ostream &os, int indent ) const {
513        printDesignation( os );
514        os << "( ";
515        if ( inout ) inout->printOneLine( os, indent + 2 );
516        os << ", ";
517        if ( constraint ) constraint->printOneLine( os, indent + 2 );
518        os << ", ";
519        if ( operand ) operand->printOneLine( os, indent + 2 );
520        os << ") ";
521}
522
523//##############################################################################
524
525void LabelNode::print( std::ostream &os, int indent ) const {}
526
527void LabelNode::printOneLine( std::ostream &os, int indent ) const {}
528
529//##############################################################################
530
531CommaExprNode::CommaExprNode(): CompositeExprNode( new OperatorNode( OperatorNode::Comma )) {}
532
533CommaExprNode::CommaExprNode( ExpressionNode *exp ) : CompositeExprNode( new OperatorNode( OperatorNode::Comma ), exp ) {
534}
535
536CommaExprNode::CommaExprNode( ExpressionNode *exp1, ExpressionNode *exp2) : CompositeExprNode( new OperatorNode( OperatorNode::Comma ), exp1, exp2) {
537}
538
539// CommaExprNode *CommaExprNode::add_to_list( ExpressionNode *exp ) {
540//      add_arg( exp );
541//
542//      return this;
543// }
544
545CommaExprNode::CommaExprNode( const CommaExprNode &other ) : CompositeExprNode( other ) {
546}
547
548//##############################################################################
549
550ValofExprNode::ValofExprNode( StatementNode *s ): body( s ) {}
551
552ValofExprNode::ValofExprNode( const ValofExprNode &other ) : ExpressionNode( other ), body( maybeClone( body ) ) {
553}
554
555ValofExprNode::~ValofExprNode() {
556        delete body;
557}
558
559void ValofExprNode::print( std::ostream &os, int indent ) const {
560        printDesignation( os );
561        os << string( indent, ' ' ) << "Valof Expression:" << std::endl;
562        get_body()->print( os, indent + 4);
563}
564
565void ValofExprNode::printOneLine( std::ostream &, int indent ) const {
566        assert( false );
567}
568
569Expression *ValofExprNode::build() const {
570        return new UntypedValofExpr ( maybeBuild<Statement>(get_body()), maybeBuild< Expression >( get_argName() ) );
571}
572
573//##############################################################################
574
575ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) {
576        if ( init_ == 0 )
577                init = 0;
578        else {
579                DeclarationNode *decl;
580                ExpressionNode *exp;
581
582                if (( decl = dynamic_cast<DeclarationNode *>(init_) ) != 0)
583                        init = new StatementNode( decl );
584                else if (( exp = dynamic_cast<ExpressionNode *>( init_)) != 0)
585                        init = new StatementNode( StatementNode::Exp, exp );
586                else
587                        throw SemanticError("Error in for control expression");
588        }
589}
590
591ForCtlExprNode::ForCtlExprNode( const ForCtlExprNode &other )
592        : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) ) {
593}
594
595ForCtlExprNode::~ForCtlExprNode() {
596        delete init;
597        delete condition;
598        delete change;
599}
600
601Expression *ForCtlExprNode::build() const {
602        // this shouldn't be used!
603        assert( false );
604        return 0;
605}
606
607void ForCtlExprNode::print( std::ostream &os, int indent ) const{
608        os << string( indent,' ' ) << "For Control Expression -- :" << endl;
609
610        os << string( indent + 2, ' ' ) << "initialization:" << endl;
611        if ( init != 0 )
612                init->printList( os, indent + 4 );
613
614        os << string( indent + 2, ' ' ) << "condition: " << endl;
615        if ( condition != 0 )
616                condition->print( os, indent + 4 );
617        os << string( indent + 2, ' ' ) << "increment: " << endl;
618        if ( change != 0 )
619                change->print( os, indent + 4 );
620}
621
622void ForCtlExprNode::printOneLine( std::ostream &, int indent ) const {
623        assert( false );
624}
625
626//##############################################################################
627
628TypeValueNode::TypeValueNode( DeclarationNode *decl ) : decl( decl ) {
629}
630
631TypeValueNode::TypeValueNode( const TypeValueNode &other ) : ExpressionNode( other ), decl( maybeClone( other.decl ) ) {
632}
633
634Expression *TypeValueNode::build() const {
635        return new TypeExpr( decl->buildType() );
636}
637
638void TypeValueNode::print( std::ostream &os, int indent ) const {
639        os << std::string( indent, ' ' ) << "Type:";
640        get_decl()->print( os, indent + 2);
641}
642
643void TypeValueNode::printOneLine( std::ostream &os, int indent ) const {
644        os << "Type:";
645        get_decl()->print( os, indent + 2);
646}
647
648
649CompoundLiteralNode::CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids ) : type( type ), kids( kids ) {}
650CompoundLiteralNode::CompoundLiteralNode( const CompoundLiteralNode &other ) : ExpressionNode( other ), type( other.type ), kids( other.kids ) {}
651
652CompoundLiteralNode::~CompoundLiteralNode() {
653        delete kids;
654        delete type;
655}
656
657CompoundLiteralNode *CompoundLiteralNode::clone() const {
658        return new CompoundLiteralNode( *this );
659}
660
661void CompoundLiteralNode::print( std::ostream &os, int indent ) const {
662        os << string( indent,' ' ) << "CompoundLiteralNode:" << endl;
663
664        os << string( indent + 2, ' ' ) << "type:" << endl;
665        if ( type != 0 )
666                type->print( os, indent + 4 );
667
668        os << string( indent + 2, ' ' ) << "initialization:" << endl;
669        if ( kids != 0 )
670                kids->printList( os, indent + 4 );
671}
672
673void CompoundLiteralNode::printOneLine( std::ostream &os, int indent ) const {
674        os << "( ";
675        if ( type ) type->print( os );
676        os << ", ";
677        if ( kids ) kids->printOneLine( os );
678        os << ") ";
679}
680
681Expression *CompoundLiteralNode::build() const {
682        Declaration * newDecl = maybeBuild<Declaration>(type); // compound literal type
683        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
684                return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeBuild<Initializer>(kids) );
685        // these types do not have associated type information
686        } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
687                return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeBuild<Initializer>(kids) );
688        } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
689                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeBuild<Initializer>(kids) );
690        } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
691                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeBuild<Initializer>(kids) );
692        } else {
693                assert( false );
694        } // if
695}
696
697ExpressionNode *flattenCommas( ExpressionNode *list ) {
698        if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {
699                OperatorNode *op;
700                if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) ) {
701                        if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
702                                composite->add_arg( next );
703                        return flattenCommas( composite->get_args() );
704                } // if
705        } // if
706
707        if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
708                list->set_next( flattenCommas( next ) );
709
710        return list;
711}
712
713ExpressionNode *tupleContents( ExpressionNode *tuple ) {
714        if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) {
715                OperatorNode *op = 0;
716                if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::TupleC ) )
717                        return composite->get_args();
718        } // if
719        return tuple;
720}
721
722// Local Variables: //
723// tab-width: 4 //
724// mode: c++ //
725// compile-command: "make install" //
726// End: //
Note: See TracBrowser for help on using the repository browser.