source: src/CodeGen/CodeGenerator.cc @ 4390fb6

ADTast-experimentalenumpthread-emulationqualifiedEnum
Last change on this file since 4390fb6 was 4390fb6, checked in by JiadaL <j82liang@…>, 2 years ago

Forget to ship the code in codeGen

  • Property mode set to 100644
File size: 40.1 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// CodeGenerator.cc --
8//
9// Author           : Richard C. Bilson
10// Created On       : Mon May 18 07:44:20 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Wed Feb  2 20:30:30 2022
13// Update Count     : 541
14//
15#include "CodeGenerator.h"
16
17#include <cassert>                   // for assert, assertf
18#include <list>                      // for _List_iterator, list, list<>::it...
19
20#include "Common/UniqueName.h"       // for UniqueName
21#include "Common/utility.h"          // for CodeLocation, toString
22#include "GenType.h"                 // for genType
23#include "InitTweak/InitTweak.h"     // for getPointerBase
24#include "OperatorTable.h"           // for OperatorInfo, operatorLookup
25#include "SynTree/LinkageSpec.h"     // for Spec, Intrinsic
26#include "SynTree/Attribute.h"       // for Attribute
27#include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode
28#include "SynTree/Constant.h"        // for Constant
29#include "SynTree/Declaration.h"     // for DeclarationWithType, TypeDecl
30#include "SynTree/Expression.h"      // for Expression, UntypedExpr, Applica...
31#include "SynTree/Initializer.h"     // for Initializer, ListInit, Designation
32#include "SynTree/Label.h"           // for Label, operator<<
33#include "SynTree/Statement.h"       // for Statement, AsmStmt, BranchStmt
34#include "SynTree/Type.h"            // for Type, Type::StorageClasses, Func...
35
36using namespace std;
37
38namespace CodeGen {
39        int CodeGenerator::tabsize = 4;
40
41        // The kinds of statements that would ideally be followed by whitespace.
42        bool wantSpacing( Statement * stmt) {
43                return dynamic_cast< IfStmt * >( stmt ) || dynamic_cast< CompoundStmt * >( stmt ) ||
44                        dynamic_cast< WhileDoStmt * >( stmt ) || dynamic_cast< ForStmt * >( stmt ) || dynamic_cast< SwitchStmt *>( stmt );
45        }
46
47        void CodeGenerator::extension( Expression * expr ) {
48                if ( expr->get_extension() ) {
49                        output << "__extension__ ";
50                } // if
51        } // extension
52
53        void CodeGenerator::extension( Declaration * decl ) {
54                if ( decl->get_extension() ) {
55                        output << "__extension__ ";
56                } // if
57        } // extension
58
59        void CodeGenerator::asmName( DeclarationWithType * decl ) {
60                if ( ConstantExpr * asmName = dynamic_cast<ConstantExpr *>(decl->get_asmName()) ) {
61                        output << " asm ( " << asmName->get_constant()->get_value() << " )";
62                } // if
63        } // extension
64
65        CodeGenerator::LabelPrinter & CodeGenerator::LabelPrinter::operator()( std::list< Label > & l ) {
66                labels = &l;
67                return *this;
68        }
69
70        ostream & operator<<( ostream & output, CodeGenerator::LabelPrinter & printLabels ) {
71                std::list< Label > & labs = *printLabels.labels;
72                // l.unique(); // assumes a sorted list. Why not use set? Does order matter?
73                for ( Label & l : labs ) {
74                        output << l.get_name() + ": ";
75                        printLabels.cg.genAttributes( l.get_attributes() );
76                } // for
77                return output;
78        }
79
80        // Using updateLocation at the beginning of a node and endl within a node should become the method of formating.
81        void CodeGenerator::updateLocation( CodeLocation const & to ) {
82                // skip if linemarks shouldn't appear or if codelocation is unset
83                if ( !options.lineMarks || to.isUnset() ) return;
84
85                if ( currentLocation.followedBy( to, 0 ) ) {
86                        return;
87                } else if ( currentLocation.followedBy( to, 1 ) ) {
88                        output << "\n" << indent;
89                        currentLocation.first_line += 1;
90                } else if ( currentLocation.followedBy( to, 2 ) ) {
91                        output << "\n\n" << indent;
92                        currentLocation.first_line += 2;
93                } else {
94                        output << "\n# " << to.first_line << " \"" << to.filename
95                                   << "\"\n" << indent;
96                        currentLocation = to;
97                }
98                output << std::flush;
99        }
100
101        void CodeGenerator::updateLocation( BaseSyntaxNode const * to ) {
102                updateLocation( to->location );
103        }
104
105        // replace endl
106        ostream & CodeGenerator::LineEnder::operator()( ostream & os ) const {
107                // if ( !cg.lineMarks ) {
108                //      os << "\n" << cg.indent << std::flush;
109                // }
110                os << "\n" << std::flush;
111                cg.currentLocation.first_line++;
112                // os << "/* did endl; current loc is: " << cg.currentLocation.first_line << "*/";
113                return os;
114        }
115
116        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks, bool printExprTypes ) : indent( 0, CodeGenerator::tabsize ), output( os ), printLabels( *this ), options( pretty, genC, lineMarks, printExprTypes ), endl( *this ) {}
117        CodeGenerator::CodeGenerator( std::ostream & os, const Options &options ) : indent( 0, CodeGenerator::tabsize ), output( os ), printLabels( *this ), options(options), endl( *this ) {}
118
119        string CodeGenerator::mangleName( DeclarationWithType * decl ) {
120                // GCC builtins should always be printed unmangled
121                if ( options.pretty || decl->linkage.is_gcc_builtin ) return decl->name;
122                if ( LinkageSpec::isMangled(decl->linkage) && decl->mangleName != "" ) {
123                        // need to incorporate scope level in order to differentiate names for destructors
124                        return decl->get_scopedMangleName();
125                } else {
126                        return decl->name;
127                } // if
128        }
129
130        void CodeGenerator::genAttributes( list< Attribute * > & attributes ) {
131                if ( attributes.empty() ) return;
132                output << "__attribute__ ((";
133                for ( list< Attribute * >::iterator attr( attributes.begin() );; ) {
134                        output << (*attr)->name;
135                        if ( ! (*attr)->parameters.empty() ) {
136                                output << "(";
137                                genCommaList( (*attr)->parameters.begin(), (*attr)->parameters.end() );
138                                output << ")";
139                        } // if
140                        if ( ++attr == attributes.end() ) break;
141                        output << ",";                                                          // separator
142                } // for
143                output << ")) ";
144        } // CodeGenerator::genAttributes
145
146        // *** BaseSyntaxNode
147        void CodeGenerator::previsit( BaseSyntaxNode * node ) {
148                // turn off automatic recursion for all nodes, to allow each visitor to
149                // precisely control the order in which its children are visited.
150                visit_children = false;
151                updateLocation( node );
152        }
153
154        // *** BaseSyntaxNode
155        void CodeGenerator::postvisit( BaseSyntaxNode * node ) {
156                std::stringstream ss;
157                node->print( ss );
158                assertf( false, "Unhandled node reached in CodeGenerator: %s", ss.str().c_str() );
159        }
160
161        // *** Expression
162        void CodeGenerator::previsit( Expression * node ) {
163                previsit( (BaseSyntaxNode *)node );
164                GuardAction( [this, node](){
165                                if ( options.printExprTypes && node->result ) {
166                                        output << " /* " << genType( node->result, "", options ) << " */ ";
167                                }
168                        } );
169        }
170
171        // *** Declarations
172        void CodeGenerator::postvisit( FunctionDecl * functionDecl ) {
173                // deleted decls should never be used, so don't print them
174                if ( functionDecl->isDeleted && options.genC ) return;
175                extension( functionDecl );
176                genAttributes( functionDecl->get_attributes() );
177
178                handleStorageClass( functionDecl );
179                functionDecl->get_funcSpec().print( output );
180
181                Options subOptions = options;
182                subOptions.anonymousUnused = functionDecl->has_body();
183                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), subOptions );
184
185                asmName( functionDecl );
186
187                if ( functionDecl->get_statements() ) {
188                        functionDecl->get_statements()->accept( *visitor );
189                } // if
190                if ( functionDecl->isDeleted ) {
191                        output << " = void";
192                }
193        }
194
195        void CodeGenerator::postvisit( ObjectDecl * objectDecl ) {
196                // deleted decls should never be used, so don't print them
197                if ( objectDecl->isDeleted && options.genC ) return;
198
199                // objectDecl->checkAssignedValue();
200                /* Temporary add the enum check here; need a better location */
201                // {
202                //      EnumInstType * enumTypePtr = dynamic_cast< EnumInstType *>(objectDecl->get_type());
203                //      if (enumTypePtr) {
204                //              EnumDecl * enumBase = enumTypePtr -> baseEnum;
205                //              if ( enumTypePtr && enumBase->base ) {
206                //                      std::list< Declaration * > & enumMembers = enumBase->get_members();
207                //                      auto in_enum = [&]( Declaration * enumMem ) -> bool {
208                //                              ObjectDecl * obj = dynamic_cast< ObjectDecl* >( enumMem );
209                //                              if ( mangleName( obj ) == mangleName( objectDecl ) ) {
210                //                                      return true;
211                //                              }
212                //                              return false;
213                //                      };
214                //                      if ( std::find_if( enumMembers.begin(), enumMembers.end(), in_enum ) == enumMembers.end() ) {
215                //                              output<< "/* Cannot assign a Non-enum member value to a typed enum variable. */" ;
216                //                      }
217                               
218                //              }
219                //      }
220                       
221                // }
222
223                // gcc allows an empty declarator (no name) for bit-fields and C states: 6.7.2.1 Structure and union specifiers,
224                // point 4, page 113: If the (bit field) value is zero, the declaration shall have no declarator.  For anything
225                // else, the anonymous name refers to the anonymous object for plan9 inheritance.
226                if ( objectDecl->get_name().empty() && options.genC && ! objectDecl->get_bitfieldWidth() ) {
227                        // only generate an anonymous name when generating C code, otherwise it clutters the output too much
228                        static UniqueName name = { "__anonymous_object" };
229                        objectDecl->set_name( name.newName() );
230                        // Stops unused parameter warnings.
231                        if ( options.anonymousUnused ) {
232                                objectDecl->attributes.push_back( new Attribute( "unused" ) );
233                        }
234                }
235
236                extension( objectDecl );
237                genAttributes( objectDecl->get_attributes() );
238
239                handleStorageClass( objectDecl );
240                output << genType( objectDecl->get_type(), mangleName( objectDecl ), options.pretty, options.genC );
241
242                asmName( objectDecl );
243
244                if ( objectDecl->get_init() ) {
245                        output << " = ";
246                        objectDecl->get_init()->accept( *visitor );
247                } // if
248                if ( objectDecl->isDeleted ) {
249                        output << " = void";
250                }
251
252                if ( objectDecl->get_bitfieldWidth() ) {
253                        output << ":";
254                        objectDecl->get_bitfieldWidth()->accept( *visitor );
255                } // if
256                output << "/* objectDecl */";
257        }
258
259        void CodeGenerator::handleAggregate( AggregateDecl * aggDecl, const std::string & kind ) {
260                if( ! aggDecl->parameters.empty() && ! options.genC ) {
261                        // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
262                        output << "forall(";
263                        genCommaList( aggDecl->parameters.begin(), aggDecl->parameters.end() );
264                        output << ")" << endl;
265                        output << indent;
266                }
267
268                output << kind;
269                genAttributes( aggDecl->attributes );
270                output << aggDecl->name;
271
272                if ( aggDecl->has_body() ) {
273                        std::list< Declaration * > & memb = aggDecl->members;
274                        output << " {" << endl;
275
276                        ++indent;
277                        for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++ ) {
278                                output << indent;
279                                (*i)->accept( *visitor );
280                                output << ";" << endl;
281                        } // for
282
283                        --indent;
284
285                        output << indent << "}";
286                } // if
287        }
288
289        void CodeGenerator::postvisit( StructDecl * structDecl ) {
290                extension( structDecl );
291                handleAggregate( structDecl, "struct " );
292        }
293
294        void CodeGenerator::postvisit( UnionDecl * unionDecl ) {
295                extension( unionDecl );
296                handleAggregate( unionDecl, "union " );
297        }
298
299        void CodeGenerator::postvisit( EnumDecl * enumDecl ) {
300                extension( enumDecl );
301                std::list< Declaration* > &memb = enumDecl->get_members();
302                if (enumDecl->base && ! memb.empty() && 
303                (dynamic_cast<BasicType *>(enumDecl->base)
304                 && !dynamic_cast<BasicType *>(enumDecl->base)->kind == BasicType::Kind::SignedInt)) {
305                        ObjectDecl * last = nullptr;
306                        for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
307                                ObjectDecl * obj = dynamic_cast< ObjectDecl* >( *i );
308                                assert( obj );
309                                output << "static const ";
310                                output << genType(enumDecl->base, "", options) << " ";
311                                output << mangleName( obj ) << " ";
312                                output << " = ";
313                                output << "(" << genType(enumDecl->base, "", options) << ")";;
314                                if ( obj->get_init() ) {
315                                        obj->get_init()->accept( *visitor );
316                                } else {
317                                        if (last == nullptr) {
318                                                output << 0;
319                                        } else {
320                                                output << mangleName(last) << " + 1";
321                                        }
322                                } // if—
323                                output << ";" << endl;
324                                last = obj;
325                        } // for
326                } else {
327                        output << "enum ";
328                        genAttributes( enumDecl->get_attributes() );
329
330                        output << enumDecl->get_name();
331
332                        if ( ! memb.empty() ) {
333                                output << " {" << endl;
334
335                                ++indent;
336                                for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
337                                        ObjectDecl * obj = dynamic_cast< ObjectDecl* >( *i );
338                                        assert( obj );
339                                        output << indent << mangleName( obj );
340                                        if ( obj->get_init() ) {
341                                                output << " = ";
342                                                obj->get_init()->accept( *visitor );
343                                        } // if
344                                        output << "," << endl;
345                                } // for
346                        --indent;
347                        output << indent << "}";
348                        } // if
349                } // if
350        }
351
352        void CodeGenerator::postvisit( TraitDecl * traitDecl ) {
353                assertf( ! options.genC, "TraitDecls should not reach code generation." );
354                extension( traitDecl );
355                handleAggregate( traitDecl, "trait " );
356        }
357
358        void CodeGenerator::postvisit( TypedefDecl * typeDecl ) {
359                assertf( ! options.genC, "Typedefs are removed and substituted in earlier passes." );
360                output << "typedef ";
361                output << genType( typeDecl->get_base(), typeDecl->get_name(), options ) << endl;
362        }
363
364        void CodeGenerator::postvisit( TypeDecl * typeDecl ) {
365                assertf( ! options.genC, "TypeDecls should not reach code generation." );
366                output << typeDecl->genTypeString() << " " << typeDecl->name;
367                if ( typeDecl->sized ) {
368                        output << " | sized(" << typeDecl->name << ")";
369                }
370                if ( ! typeDecl->assertions.empty() ) {
371                        output << " | { ";
372                        for ( DeclarationWithType * assert :  typeDecl->assertions ) {
373                                assert->accept( *visitor );
374                                output << "; ";
375                        }
376                        output << " }";
377                }
378        }
379
380        void CodeGenerator::postvisit( StaticAssertDecl * assertDecl ) {
381                output << "_Static_assert(";
382                assertDecl->condition->accept( *visitor );
383                output << ", ";
384                assertDecl->message->accept( *visitor );
385                output << ")";
386        }
387
388        void CodeGenerator::postvisit( Designation * designation ) {
389                std::list< Expression * > designators = designation->get_designators();
390                if ( designators.size() == 0 ) return;
391                for ( Expression * des : designators ) {
392                        if ( dynamic_cast< NameExpr * >( des ) || dynamic_cast< VariableExpr * >( des ) ) {
393                                // if expression is a NameExpr or VariableExpr, then initializing aggregate member
394                                output << ".";
395                                des->accept( *visitor );
396                        } else {
397                                // otherwise, it has to be a ConstantExpr or CastExpr, initializing array element
398                                output << "[";
399                                des->accept( *visitor );
400                                output << "]";
401                        } // if
402                } // for
403                output << " = /* Designation */";
404        }
405
406        void CodeGenerator::postvisit( SingleInit * init ) {
407                init->get_value()->accept( *visitor );
408        }
409
410        void CodeGenerator::postvisit( ListInit * init ) {
411                auto initBegin = init->begin();
412                auto initEnd = init->end();
413                auto desigBegin = init->get_designations().begin();
414                auto desigEnd = init->get_designations().end();
415
416                output << "{ ";
417                for ( ; initBegin != initEnd && desigBegin != desigEnd; ) {
418                        (*desigBegin)->accept( *visitor );
419                        (*initBegin)->accept( *visitor );
420                        ++initBegin, ++desigBegin;
421                        if ( initBegin != initEnd ) {
422                                output << ", ";
423                        }
424                }
425                output << " }";
426                assertf( initBegin == initEnd && desigBegin == desigEnd, "Initializers and designators not the same length. %s", toString( init ).c_str() );
427        }
428
429        void CodeGenerator::postvisit( ConstructorInit * init ){
430                assertf( ! options.genC, "ConstructorInit nodes should not reach code generation." );
431                // pseudo-output for constructor/destructor pairs
432                output << "<ctorinit>{" << endl << ++indent << "ctor: ";
433                maybeAccept( init->get_ctor(), *visitor );
434                output << ", " << endl << indent << "dtor: ";
435                maybeAccept( init->get_dtor(), *visitor );
436                output << endl << --indent << "}";
437        }
438
439        void CodeGenerator::postvisit( Constant * constant ) {
440                output << constant->get_value();
441        }
442
443        // *** Expressions
444        void CodeGenerator::postvisit( ApplicationExpr * applicationExpr ) {
445                extension( applicationExpr );
446                if ( VariableExpr * varExpr = dynamic_cast< VariableExpr* >( applicationExpr->get_function() ) ) {
447                        const OperatorInfo * opInfo;
448                        if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && ( opInfo = operatorLookup( varExpr->get_var()->get_name() ) ) ) {
449                                std::list< Expression* >::iterator arg = applicationExpr->get_args().begin();
450                                switch ( opInfo->type ) {
451                                  case OT_INDEX:
452                                        assert( applicationExpr->get_args().size() == 2 );
453                                        (*arg++)->accept( *visitor );
454                                        output << "[";
455                                        (*arg)->accept( *visitor );
456                                        output << "]";
457                                        break;
458
459                                  case OT_CALL:
460                                        // there are no intrinsic definitions of the function call operator
461                                        assert( false );
462                                        break;
463
464                                  case OT_CTOR:
465                                  case OT_DTOR:
466                                        if ( applicationExpr->get_args().size() == 1 ) {
467                                                // the expression fed into a single parameter constructor or destructor may contain side
468                                                // effects, so must still output this expression
469                                                output << "(";
470                                                (*arg++)->accept( *visitor );
471                                                output << ") /* " << opInfo->inputName << " */";
472                                        } else if ( applicationExpr->get_args().size() == 2 ) {
473                                                // intrinsic two parameter constructors are essentially bitwise assignment
474                                                output << "(";
475                                                (*arg++)->accept( *visitor );
476                                                output << opInfo->symbol;
477                                                (*arg)->accept( *visitor );
478                                                output << ") /* " << opInfo->inputName << " */";
479                                        } else {
480                                                // no constructors with 0 or more than 2 parameters
481                                                assert( false );
482                                        } // if
483                                        break;
484
485                                  case OT_PREFIX:
486                                  case OT_PREFIXASSIGN:
487                                        assert( applicationExpr->get_args().size() == 1 );
488                                        output << "(";
489                                        output << opInfo->symbol;
490                                        (*arg)->accept( *visitor );
491                                        output << ")";
492                                        break;
493
494                                  case OT_POSTFIX:
495                                  case OT_POSTFIXASSIGN:
496                                        assert( applicationExpr->get_args().size() == 1 );
497                                        (*arg)->accept( *visitor );
498                                        output << opInfo->symbol;
499                                        break;
500
501
502                                  case OT_INFIX:
503                                  case OT_INFIXASSIGN:
504                                        assert( applicationExpr->get_args().size() == 2 );
505                                        output << "(";
506                                        (*arg++)->accept( *visitor );
507                                        output << opInfo->symbol;
508                                        (*arg)->accept( *visitor );
509                                        output << ")";
510                                        break;
511
512                                  case OT_CONSTANT:
513                                  case OT_LABELADDRESS:
514                                        // there are no intrinsic definitions of 0/1 or label addresses as functions
515                                        assert( false );
516                                } // switch
517                        } else {
518                                varExpr->accept( *visitor );
519                                output << "(";
520                                genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
521                                output << ")";
522                        } // if
523                } else {
524                        applicationExpr->get_function()->accept( *visitor );
525                        output << "(";
526                        genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
527                        output << ")";
528                } // if
529        }
530
531        void CodeGenerator::postvisit( UntypedExpr * untypedExpr ) {
532                extension( untypedExpr );
533                if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->function ) ) {
534                        const OperatorInfo * opInfo = operatorLookup( nameExpr->name );
535                        if ( opInfo ) {
536                                std::list< Expression* >::iterator arg = untypedExpr->args.begin();
537                                switch ( opInfo->type ) {
538                                  case OT_INDEX:
539                                        assert( untypedExpr->args.size() == 2 );
540                                        (*arg++)->accept( *visitor );
541                                        output << "[";
542                                        (*arg)->accept( *visitor );
543                                        output << "]";
544                                        break;
545
546                                  case OT_CALL:
547                                        assert( false );
548
549                                  case OT_CTOR:
550                                  case OT_DTOR:
551                                        if ( untypedExpr->args.size() == 1 ) {
552                                                // the expression fed into a single parameter constructor or destructor may contain side
553                                                // effects, so must still output this expression
554                                                output << "(";
555                                                (*arg++)->accept( *visitor );
556                                                output << ") /* " << opInfo->inputName << " */";
557                                        } else if ( untypedExpr->get_args().size() == 2 ) {
558                                                // intrinsic two parameter constructors are essentially bitwise assignment
559                                                output << "(";
560                                                (*arg++)->accept( *visitor );
561                                                output << opInfo->symbol;
562                                                (*arg)->accept( *visitor );
563                                                output << ") /* " << opInfo->inputName << " */";
564                                        } else {
565                                                // no constructors with 0 or more than 2 parameters
566                                                assertf( ! options.genC, "UntypedExpr constructor/destructor with 0 or more than 2 parameters." );
567                                                output << "(";
568                                                (*arg++)->accept( *visitor );
569                                                output << opInfo->symbol << "{ ";
570                                                genCommaList( arg, untypedExpr->args.end() );
571                                                output << "}) /* " << opInfo->inputName << " */";
572                                        } // if
573                                        break;
574
575                                  case OT_PREFIX:
576                                  case OT_PREFIXASSIGN:
577                                  case OT_LABELADDRESS:
578                                        assert( untypedExpr->args.size() == 1 );
579                                        output << "(";
580                                        output << opInfo->symbol;
581                                        (*arg)->accept( *visitor );
582                                        output << ")";
583                                        break;
584
585                                  case OT_POSTFIX:
586                                  case OT_POSTFIXASSIGN:
587                                        assert( untypedExpr->args.size() == 1 );
588                                        (*arg)->accept( *visitor );
589                                        output << opInfo->symbol;
590                                        break;
591
592                                  case OT_INFIX:
593                                  case OT_INFIXASSIGN:
594                                        assert( untypedExpr->args.size() == 2 );
595                                        output << "(";
596                                        (*arg++)->accept( *visitor );
597                                        output << opInfo->symbol;
598                                        (*arg)->accept( *visitor );
599                                        output << ")";
600                                        break;
601
602                                  case OT_CONSTANT:
603                                        // there are no intrinsic definitions of 0 or 1 as functions
604                                        assert( false );
605                                } // switch
606                        } else {
607                                // builtin routines
608                                nameExpr->accept( *visitor );
609                                output << "(";
610                                genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() );
611                                output << ")";
612                        } // if
613                } else {
614                        untypedExpr->function->accept( *visitor );
615                        output << "(";
616                        genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() );
617                        output << ")";
618                } // if
619        }
620
621        void CodeGenerator::postvisit( RangeExpr * rangeExpr ) {
622                rangeExpr->low->accept( *visitor );
623                output << " ... ";
624                rangeExpr->high->accept( *visitor );
625        }
626
627        void CodeGenerator::postvisit( NameExpr * nameExpr ) {
628                extension( nameExpr );
629                const OperatorInfo * opInfo = operatorLookup( nameExpr->name );
630                if ( opInfo ) {
631                        if ( opInfo->type == OT_CONSTANT ) {
632                                output << opInfo->symbol;
633                        } else {
634                                output << opInfo->outputName;
635                        }
636                } else {
637                        output << nameExpr->get_name();
638                } // if
639        }
640
641        void CodeGenerator::postvisit( DimensionExpr * dimensionExpr ) {
642                extension( dimensionExpr );
643                output << "/*non-type*/" << dimensionExpr->get_name();
644        }
645
646        void CodeGenerator::postvisit( AddressExpr * addressExpr ) {
647                extension( addressExpr );
648                output << "(&";
649                addressExpr->arg->accept( *visitor );
650                output << ")";
651        }
652
653        void CodeGenerator::postvisit( LabelAddressExpr *addressExpr ) {
654                extension( addressExpr );
655                output << "(&&" << addressExpr->arg << ")";
656        }
657
658        void CodeGenerator::postvisit( CastExpr * castExpr ) {
659                extension( castExpr );
660                output << "(";
661                if ( castExpr->get_result()->isVoid() ) {
662                        output << "(void)";
663                } else {
664                        // at least one result type of cast.
665                        // Note: previously, lvalue casts were skipped. Since it's now impossible for the user to write
666                        // an lvalue cast, this has been taken out.
667                        output << "(";
668                        output << genType( castExpr->get_result(), "", options );
669                        output << ")";
670                } // if
671                castExpr->arg->accept( *visitor );
672                output << ")";
673        }
674
675        void CodeGenerator::postvisit( KeywordCastExpr * castExpr ) {
676                assertf( ! options.genC, "KeywordCast should not reach code generation." );
677                extension( castExpr );
678                output << "((" << castExpr->targetString() << " &)";
679                castExpr->arg->accept( *visitor );
680                output << ")";
681        }
682
683        void CodeGenerator::postvisit( VirtualCastExpr * castExpr ) {
684                assertf( ! options.genC, "VirtualCastExpr should not reach code generation." );
685                extension( castExpr );
686                output << "(virtual ";
687                castExpr->get_arg()->accept( *visitor );
688                output << ")";
689        }
690
691        void CodeGenerator::postvisit( UntypedMemberExpr * memberExpr ) {
692                assertf( ! options.genC, "UntypedMemberExpr should not reach code generation." );
693                extension( memberExpr );
694                memberExpr->get_aggregate()->accept( *visitor );
695                output << ".";
696                memberExpr->get_member()->accept( *visitor );
697        }
698
699        void CodeGenerator::postvisit( MemberExpr * memberExpr ) {
700                extension( memberExpr );
701                memberExpr->get_aggregate()->accept( *visitor );
702                output << "." << mangleName( memberExpr->get_member() );
703        }
704
705        void CodeGenerator::postvisit( VariableExpr * variableExpr ) {
706                extension( variableExpr );
707                const OperatorInfo * opInfo;
708                if ( variableExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && (opInfo = operatorLookup( variableExpr->get_var()->get_name() )) && opInfo->type == OT_CONSTANT ) {
709                        output << opInfo->symbol;
710                } else {
711                        // if (dynamic_cast<EnumInstType *>(variableExpr->get_var()->get_type())
712                        // && dynamic_cast<EnumInstType *>(variableExpr->get_var()->get_type())->baseEnum->base) {
713                        //      output << '(' <<genType(dynamic_cast<EnumInstType *>(variableExpr->get_var()->get_type())->baseEnum->base, "", options) << ')';
714                        // }
715                        output << mangleName( variableExpr->get_var() );
716                } // if
717        }
718
719        void CodeGenerator::postvisit( ConstantExpr * constantExpr ) {
720                assert( constantExpr->get_constant() );
721                extension( constantExpr );
722                constantExpr->get_constant()->accept( *visitor );
723        }
724
725        void CodeGenerator::postvisit( SizeofExpr * sizeofExpr ) {
726                extension( sizeofExpr );
727                output << "sizeof(";
728                if ( sizeofExpr->get_isType() ) {
729                        output << genType( sizeofExpr->get_type(), "", options );
730                } else {
731                        sizeofExpr->get_expr()->accept( *visitor );
732                } // if
733                output << ")";
734        }
735
736        void CodeGenerator::postvisit( AlignofExpr * alignofExpr ) {
737                // use GCC extension to avoid bumping std to C11
738                extension( alignofExpr );
739                output << "__alignof__(";
740                if ( alignofExpr->get_isType() ) {
741                        output << genType( alignofExpr->get_type(), "", options );
742                } else {
743                        alignofExpr->get_expr()->accept( *visitor );
744                } // if
745                output << ")";
746        }
747
748        void CodeGenerator::postvisit( UntypedOffsetofExpr * offsetofExpr ) {
749                assertf( ! options.genC, "UntypedOffsetofExpr should not reach code generation." );
750                output << "offsetof(";
751                output << genType( offsetofExpr->get_type(), "", options );
752                output << ", " << offsetofExpr->get_member();
753                output << ")";
754        }
755
756        void CodeGenerator::postvisit( OffsetofExpr * offsetofExpr ) {
757                // use GCC builtin
758                output << "__builtin_offsetof(";
759                output << genType( offsetofExpr->get_type(), "", options );
760                output << ", " << mangleName( offsetofExpr->get_member() );
761                output << ")";
762        }
763
764        void CodeGenerator::postvisit( OffsetPackExpr * offsetPackExpr ) {
765                assertf( ! options.genC, "OffsetPackExpr should not reach code generation." );
766                output << "__CFA_offsetpack(" << genType( offsetPackExpr->get_type(), "", options ) << ")";
767        }
768
769        void CodeGenerator::postvisit( LogicalExpr * logicalExpr ) {
770                extension( logicalExpr );
771                output << "(";
772                logicalExpr->get_arg1()->accept( *visitor );
773                if ( logicalExpr->get_isAnd() ) {
774                        output << " && ";
775                } else {
776                        output << " || ";
777                } // if
778                logicalExpr->get_arg2()->accept( *visitor );
779                output << ")";
780        }
781
782        void CodeGenerator::postvisit( ConditionalExpr * conditionalExpr ) {
783                extension( conditionalExpr );
784                output << "(";
785                conditionalExpr->get_arg1()->accept( *visitor );
786                output << " ? ";
787                conditionalExpr->get_arg2()->accept( *visitor );
788                output << " : ";
789                conditionalExpr->get_arg3()->accept( *visitor );
790                output << ")";
791        }
792
793        void CodeGenerator::postvisit( CommaExpr * commaExpr ) {
794                extension( commaExpr );
795                output << "(";
796                if ( options.genC ) {
797                        // arg1 of a CommaExpr is never used, so it can be safely cast to void to reduce gcc warnings.
798                        commaExpr->set_arg1( new CastExpr( commaExpr->get_arg1() ) );
799                }
800                commaExpr->get_arg1()->accept( *visitor );
801                output << " , ";
802                commaExpr->get_arg2()->accept( *visitor );
803                output << ")";
804        }
805
806        void CodeGenerator::postvisit( TupleAssignExpr * tupleExpr ) {
807                assertf( ! options.genC, "TupleAssignExpr should not reach code generation." );
808                tupleExpr->stmtExpr->accept( *visitor );
809        }
810
811        void CodeGenerator::postvisit( UntypedTupleExpr * tupleExpr ) {
812                assertf( ! options.genC, "UntypedTupleExpr should not reach code generation." );
813                extension( tupleExpr );
814                output << "[";
815                genCommaList( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end() );
816                output << "]";
817        }
818
819        void CodeGenerator::postvisit( TupleExpr * tupleExpr ) {
820                assertf( ! options.genC, "TupleExpr should not reach code generation." );
821                extension( tupleExpr );
822                output << "[";
823                genCommaList( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end() );
824                output << "]";
825        }
826
827        void CodeGenerator::postvisit( TupleIndexExpr * tupleExpr ) {
828                assertf( ! options.genC, "TupleIndexExpr should not reach code generation." );
829                extension( tupleExpr );
830                tupleExpr->get_tuple()->accept( *visitor );
831                output << "." << tupleExpr->get_index();
832        }
833
834        void CodeGenerator::postvisit( TypeExpr * typeExpr ) {
835                // if ( options.genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
836                // assertf( ! options.genC, "TypeExpr should not reach code generation." );
837                if ( ! options.genC ) {
838                        output << genType( typeExpr->get_type(), "", options );
839                }
840        }
841
842        void CodeGenerator::postvisit( AsmExpr * asmExpr ) {
843                if ( !asmExpr->inout.empty() ) {
844                        output << "[ ";
845                        output << asmExpr->inout;
846                        output << " ] ";
847                } // if
848                asmExpr->constraint->accept( *visitor );
849                output << " ( ";
850                asmExpr->operand->accept( *visitor );
851                output << " )";
852        }
853
854        void CodeGenerator::postvisit( CompoundLiteralExpr *compLitExpr ) {
855                assert( compLitExpr->get_result() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
856                output << "(" << genType( compLitExpr->get_result(), "", options ) << ")";
857                compLitExpr->get_initializer()->accept( *visitor );
858        }
859
860        void CodeGenerator::postvisit( UniqueExpr * unqExpr ) {
861                assertf( ! options.genC, "Unique expressions should not reach code generation." );
862                output << "unq<" << unqExpr->get_id() << ">{ ";
863                unqExpr->get_expr()->accept( *visitor );
864                output << " }";
865        }
866
867        void CodeGenerator::postvisit( StmtExpr * stmtExpr ) {
868                std::list< Statement * > & stmts = stmtExpr->statements->kids;
869                output << "({" << endl;
870                ++indent;
871                unsigned int numStmts = stmts.size();
872                unsigned int i = 0;
873                for ( Statement * stmt : stmts ) {
874                        output << indent << printLabels( stmt->get_labels() );
875                        if ( i+1 == numStmts ) {
876                                // last statement in a statement expression needs to be handled specially -
877                                // cannot cast to void, otherwise the expression statement has no value
878                                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
879                                        exprStmt->expr->accept( *visitor );
880                                        output << ";" << endl;
881                                        ++i;
882                                        break;
883                                }
884                        }
885                        stmt->accept( *visitor );
886                        output << endl;
887                        if ( wantSpacing( stmt ) ) {
888                                output << endl;
889                        } // if
890                        ++i;
891                }
892                --indent;
893                output << indent << "})";
894        }
895
896        void CodeGenerator::postvisit( ConstructorExpr * expr ) {
897                assertf( ! options.genC, "Unique expressions should not reach code generation." );
898                expr->callExpr->accept( *visitor );
899        }
900
901        void CodeGenerator::postvisit( DeletedExpr * expr ) {
902                assertf( ! options.genC, "Deleted expressions should not reach code generation." );
903                expr->expr->accept( *visitor );
904        }
905
906        void CodeGenerator::postvisit( DefaultArgExpr * arg ) {
907                assertf( ! options.genC, "Default argument expressions should not reach code generation." );
908                arg->expr->accept( *visitor );
909        }
910
911        void CodeGenerator::postvisit( GenericExpr * expr ) {
912                assertf( ! options.genC, "C11 _Generic expressions should not reach code generation." );
913                output << "_Generic(";
914                expr->control->accept( *visitor );
915                output << ", ";
916                unsigned int numAssocs = expr->associations.size();
917                unsigned int i = 0;
918                for ( GenericExpr::Association & assoc : expr->associations ) {
919                        if (assoc.isDefault) {
920                                output << "default: ";
921                        } else {
922                                output << genType( assoc.type, "", options ) << ": ";
923                        }
924                        assoc.expr->accept( *visitor );
925                        if ( i+1 != numAssocs ) {
926                                output << ", ";
927                        }
928                        i++;
929                }
930                output << ")";
931        }
932
933
934        // *** Statements
935        void CodeGenerator::postvisit( CompoundStmt * compoundStmt ) {
936                std::list<Statement*> ks = compoundStmt->get_kids();
937                output << "{" << endl;
938
939                ++indent;
940
941                for ( std::list<Statement *>::iterator i = ks.begin(); i != ks.end();  i++ ) {
942                        output << indent << printLabels( (*i)->get_labels() );
943                        (*i)->accept( *visitor );
944
945                        output << endl;
946                        if ( wantSpacing( *i ) ) {
947                                output << endl;
948                        } // if
949                } // for
950                --indent;
951
952                output << indent << "}";
953        }
954
955        void CodeGenerator::postvisit( ExprStmt * exprStmt ) {
956                assert( exprStmt );
957                if ( options.genC ) {
958                        // cast the top-level expression to void to reduce gcc warnings.
959                        exprStmt->set_expr( new CastExpr( exprStmt->get_expr() ) );
960                }
961                exprStmt->get_expr()->accept( *visitor );
962                output << "; /* ExprStmt */";
963        }
964
965        void CodeGenerator::postvisit( AsmStmt * asmStmt ) {
966                output << "asm ";
967                if ( asmStmt->get_voltile() ) output << "volatile ";
968                if ( ! asmStmt->get_gotolabels().empty()  ) output << "goto ";
969                output << "( ";
970                if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *visitor );
971                output << " : ";
972                genCommaList( asmStmt->get_output().begin(), asmStmt->get_output().end() );
973                output << " : ";
974                genCommaList( asmStmt->get_input().begin(), asmStmt->get_input().end() );
975                output << " : ";
976                genCommaList( asmStmt->get_clobber().begin(), asmStmt->get_clobber().end() );
977                if ( ! asmStmt->get_gotolabels().empty() ) {
978                        output << " : ";
979                        for ( std::list<Label>::iterator begin = asmStmt->get_gotolabels().begin();; ) {
980                                output << *begin++;
981                                if ( begin == asmStmt->get_gotolabels().end() ) break;
982                                output << ", ";
983                        } // for
984                } // if
985                output << " );";
986        }
987
988        void CodeGenerator::postvisit( AsmDecl * asmDecl ) {
989                output << "asm ";
990                AsmStmt * asmStmt = asmDecl->get_stmt();
991                output << "( ";
992                if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *visitor );
993                output << " )";
994        }
995
996        void CodeGenerator::postvisit( DirectiveDecl * directiveDecl ) {
997                output << endl << directiveDecl->get_stmt()->directive; // endl prevents spaces before directive
998        }
999
1000        void CodeGenerator::postvisit( DirectiveStmt * dirStmt ) {
1001                output << endl << dirStmt->directive;                   // endl prevents spaces before directive
1002        }
1003
1004        void CodeGenerator::postvisit( IfStmt * ifStmt ) {
1005                output << "if ( ";
1006                ifStmt->get_condition()->accept( *visitor );
1007                output << " ) ";
1008
1009                ifStmt->get_then()->accept( *visitor );
1010
1011                if ( ifStmt->get_else() != 0) {
1012                        output << " else ";
1013                        ifStmt->get_else()->accept( *visitor );
1014                } // if
1015        }
1016
1017        void CodeGenerator::postvisit( SwitchStmt * switchStmt ) {
1018                output << "switch ( ";
1019                switchStmt->get_condition()->accept( *visitor );
1020                output << " ) ";
1021
1022                output << "{" << endl;
1023                ++indent;
1024                acceptAll( switchStmt->get_statements(), *visitor );
1025                --indent;
1026                output << indent << "}";
1027        }
1028
1029        void CodeGenerator::postvisit( CaseStmt * caseStmt ) {
1030                updateLocation( caseStmt );
1031                output << indent;
1032                if ( caseStmt->isDefault()) {
1033                        output << "default";
1034                } else {
1035                        output << "case ";
1036                        caseStmt->get_condition()->accept( *visitor );
1037                } // if
1038                output << ":" << endl;
1039
1040                std::list<Statement *> sts = caseStmt->get_statements();
1041
1042                ++indent;
1043                for ( std::list<Statement *>::iterator i = sts.begin(); i != sts.end();  i++) {
1044                        output << indent << printLabels( (*i)->get_labels() ) ;
1045                        (*i)->accept( *visitor );
1046                        output << endl;
1047                } // for
1048                --indent;
1049        }
1050
1051        void CodeGenerator::postvisit( BranchStmt * branchStmt ) {
1052                switch ( branchStmt->get_type()) {
1053                  case BranchStmt::Goto:
1054                        if ( ! branchStmt->get_target().empty() )
1055                                output << "goto " << branchStmt->get_target();
1056                        else {
1057                                if ( branchStmt->get_computedTarget() != 0 ) {
1058                                        output << "goto *";
1059                                        branchStmt->get_computedTarget()->accept( *visitor );
1060                                } // if
1061                        } // if
1062                        break;
1063                  case BranchStmt::Break:
1064                        output << "break";
1065                        break;
1066                  case BranchStmt::Continue:
1067                        output << "continue";
1068                        break;
1069                  case BranchStmt::FallThrough:
1070                  case BranchStmt::FallThroughDefault:
1071                        assertf( ! options.genC, "fallthru should not reach code generation." );
1072                        output << "fallthru";
1073                        break;
1074                  default: ;                                                                    // prevent warning
1075                } // switch
1076                // print branch target for labelled break/continue/fallthru in debug mode
1077                if ( ! options.genC && branchStmt->get_type() != BranchStmt::Goto ) {
1078                        if ( ! branchStmt->get_target().empty() ) {
1079                                output << " " << branchStmt->get_target();
1080                        } else if ( branchStmt->get_type() == BranchStmt::FallThrough ) {
1081                                output << " default";
1082                        }
1083                }
1084                output << ";";
1085        }
1086
1087        void CodeGenerator::postvisit( ReturnStmt * returnStmt ) {
1088                output << "return ";
1089                maybeAccept( returnStmt->get_expr(), *visitor );
1090                output << ";";
1091        }
1092
1093        void CodeGenerator::postvisit( ThrowStmt * throwStmt ) {
1094                assertf( ! options.genC, "Throw statements should not reach code generation." );
1095
1096                output << ((throwStmt->get_kind() == ThrowStmt::Terminate) ?
1097                                   "throw" : "throwResume");
1098                if (throwStmt->get_expr()) {
1099                        output << " ";
1100                        throwStmt->get_expr()->accept( *visitor );
1101                }
1102                if (throwStmt->get_target()) {
1103                        output << " _At ";
1104                        throwStmt->get_target()->accept( *visitor );
1105                }
1106                output << ";";
1107        }
1108        void CodeGenerator::postvisit( CatchStmt * stmt ) {
1109                assertf( ! options.genC, "Catch statements should not reach code generation." );
1110
1111                output << ((stmt->get_kind() == CatchStmt::Terminate) ?
1112                                   "catch" : "catchResume");
1113                output << "( ";
1114                stmt->decl->accept( *visitor );
1115                output << " ) ";
1116
1117                if( stmt->cond ) {
1118                        output << "if/when(?) (";
1119                        stmt->cond->accept( *visitor );
1120                        output << ") ";
1121                }
1122                stmt->body->accept( *visitor );
1123        }
1124
1125        void CodeGenerator::postvisit( WaitForStmt * stmt ) {
1126                assertf( ! options.genC, "Waitfor statements should not reach code generation." );
1127
1128                bool first = true;
1129                for( auto & clause : stmt->clauses ) {
1130                        if(first) { output << "or "; first = false; }
1131                        if( clause.condition ) {
1132                                output << "when(";
1133                                stmt->timeout.condition->accept( *visitor );
1134                                output << ") ";
1135                        }
1136                        output << "waitfor(";
1137                        clause.target.function->accept( *visitor );
1138                        for( Expression * expr : clause.target.arguments ) {
1139                                output << ",";
1140                                expr->accept( *visitor );
1141                        }
1142                        output << ") ";
1143                        clause.statement->accept( *visitor );
1144                }
1145
1146                if( stmt->timeout.statement ) {
1147                        output << "or ";
1148                        if( stmt->timeout.condition ) {
1149                                output << "when(";
1150                                stmt->timeout.condition->accept( *visitor );
1151                                output << ") ";
1152                        }
1153                        output << "timeout(";
1154                        stmt->timeout.time->accept( *visitor );
1155                        output << ") ";
1156                        stmt->timeout.statement->accept( *visitor );
1157                }
1158
1159                if( stmt->orelse.statement ) {
1160                        output << "or ";
1161                        if( stmt->orelse.condition ) {
1162                                output << "when(";
1163                                stmt->orelse.condition->accept( *visitor );
1164                                output << ")";
1165                        }
1166                        output << "else ";
1167                        stmt->orelse.statement->accept( *visitor );
1168                }
1169        }
1170
1171        void CodeGenerator::postvisit( WithStmt * with ) {
1172                if ( ! options.genC ) {
1173                        output << "with ( ";
1174                        genCommaList( with->exprs.begin(), with->exprs.end() );
1175                        output << " ) ";
1176                }
1177                with->stmt->accept( *visitor );
1178        }
1179
1180        void CodeGenerator::postvisit( WhileDoStmt * whileDoStmt ) {
1181                if ( whileDoStmt->get_isDoWhile() ) {
1182                        output << "do";
1183                } else {
1184                        output << "while (";
1185                        whileDoStmt->get_condition()->accept( *visitor );
1186                        output << ")";
1187                } // if
1188                output << " ";
1189
1190                output << CodeGenerator::printLabels( whileDoStmt->get_body()->get_labels() );
1191                whileDoStmt->get_body()->accept( *visitor );
1192
1193                output << indent;
1194
1195                if ( whileDoStmt->get_isDoWhile() ) {
1196                        output << " while (";
1197                        whileDoStmt->get_condition()->accept( *visitor );
1198                        output << ");";
1199                } // if
1200        }
1201
1202        void CodeGenerator::postvisit( ForStmt * forStmt ) {
1203                // initialization is always hoisted, so don't bother doing anything with that
1204                output << "for (;";
1205
1206                if ( forStmt->get_condition() != 0 ) {
1207                        forStmt->get_condition()->accept( *visitor );
1208                } // if
1209                output << ";";
1210
1211                if ( forStmt->get_increment() != 0 ) {
1212                        // cast the top-level expression to void to reduce gcc warnings.
1213                        Expression * expr = new CastExpr( forStmt->get_increment() );
1214                        expr->accept( *visitor );
1215                } // if
1216                output << ") ";
1217
1218                if ( forStmt->get_body() != 0 ) {
1219                        output << CodeGenerator::printLabels( forStmt->get_body()->get_labels() );
1220                        forStmt->get_body()->accept( *visitor );
1221                } // if
1222        }
1223
1224        void CodeGenerator::postvisit( __attribute__((unused)) NullStmt * nullStmt ) {
1225                //output << indent << CodeGenerator::printLabels( nullStmt->get_labels() );
1226                output << "/* null statement */ ;";
1227        }
1228
1229        void CodeGenerator::postvisit( DeclStmt * declStmt ) {
1230                declStmt->get_decl()->accept( *visitor );
1231
1232                if ( doSemicolon( declStmt->get_decl() ) ) {
1233                        output << ";";
1234                } // if
1235        }
1236
1237        void CodeGenerator::postvisit( ImplicitCtorDtorStmt * stmt ) {
1238                assertf( ! options.genC, "ImplicitCtorDtorStmts should not reach code generation." );
1239                stmt->callStmt->accept( *visitor );
1240        }
1241
1242        void CodeGenerator::postvisit( MutexStmt * stmt ) {
1243                assertf( ! options.genC, "ImplicitCtorDtorStmts should not reach code generation." );
1244                stmt->stmt->accept( *visitor );
1245        }
1246
1247        void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) {
1248                if ( decl->get_storageClasses().any() ) {
1249                        decl->get_storageClasses().print( output );
1250                } // if
1251        } // CodeGenerator::handleStorageClass
1252
1253        std::string genName( DeclarationWithType * decl ) {
1254                const OperatorInfo * opInfo = operatorLookup( decl->get_name() );
1255                if ( opInfo ) {
1256                        return opInfo->outputName;
1257                } else {
1258                        return decl->get_name();
1259                } // if
1260        }
1261} // namespace CodeGen
1262
1263
1264unsigned Indenter::tabsize = 2;
1265
1266std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) {
1267        if ( node ) {
1268                node->print( out );
1269        } else {
1270                out << "nullptr";
1271        }
1272        return out;
1273}
1274
1275// Local Variables: //
1276// tab-width: 4 //
1277// mode: c++ //
1278// compile-command: "make install" //
1279// End: //
Note: See TracBrowser for help on using the repository browser.