Changes in src/CodeGen/CodeGenerator.cc [888cbe4:e04ef3a]

File:

• src/CodeGen/CodeGenerator.cc (modified) (11 diffs)

src/CodeGen/CodeGenerator.cc

@@ -26 +26 @@
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
-#include "SynTree/Attribute.h"
 
 #include "Common/utility.h"
@@ -34 +33 @@
 #include "OperatorTable.h"
 #include "GenType.h"
-
-#include "InitTweak/InitTweak.h"
 
 using namespace std;
@@ -48 +45 @@
         }
 
-        ostream & CodeGenerator::Indenter::operator()( ostream & output ) const {
+        ostream & CodeGenerator::Indenter::operator()( ostream & output ) {
           return output << string( cg.cur_indent, ' ' );
         }
 
-        ostream & operator<<( ostream & output, const CodeGenerator::Indenter &indent ) {
+        ostream & operator<<( ostream & output, CodeGenerator::Indenter &indent ) {
                 return indent( output );
         }
 
-        CodeGenerator::LabelPrinter & CodeGenerator::LabelPrinter::operator()( std::list< Label > & l ) {
-                labels = &l;
-                return *this;
-        }
-
-        ostream & operator<<( ostream & output, CodeGenerator::LabelPrinter &printLabels ) {
-                std::list< Label > & labs = *printLabels.labels;
-                // l.unique(); // assumes a sorted list. Why not use set? Does order matter?
-                for ( Label & l : labs ) {
-                        output << l.get_name() + ": ";
-                        printLabels.cg.genAttributes( l.get_attributes() );
-                }
-                return output;
-        }
-
-        CodeGenerator::CodeGenerator( std::ostream &os ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ) { }
+        CodeGenerator::CodeGenerator( std::ostream &os ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ) { }
 
         CodeGenerator::CodeGenerator( std::ostream &os, std::string init, int indentation, bool infunp )
-                        : indent( *this), cur_indent( indentation ), insideFunction( infunp ), output( os ), printLabels( *this ) {
+                        : indent( *this), cur_indent( indentation ), insideFunction( infunp ), output( os ) {
                 //output << std::string( init );
         }
 
         CodeGenerator::CodeGenerator( std::ostream &os, char *init, int indentation, bool infunp )
-                        : indent( *this ), cur_indent( indentation ), insideFunction( infunp ), output( os ), printLabels( *this ) {
+                        : indent( *this ), cur_indent( indentation ), insideFunction( infunp ), output( os ) {
                 //output << std::string( init );
         }
@@ -92 +74 @@
         }
 
-        void CodeGenerator::genAttributes( std::list< Attribute * > & attributes ) {
-                if ( ! attributes.empty() ) {
-                        output << "__attribute__ ((";
-                        for ( Attribute *& attr : attributes ) {
-                                if ( ! attr->empty() ) {
-                                        output << attr->get_name() << "(";
-                                        genCommaList( attr->get_parameters().begin(), attr->get_parameters().end() );
-                                        output << ")";
-                                }
-                                output << ",";
-                        }
-                        output << ")) ";
-                }
-        }
-
-
         //*** Declarations
         void CodeGenerator::visit( FunctionDecl *functionDecl ) {
-                genAttributes( functionDecl->get_attributes() );
-
+                // generalize this
+                FunctionDecl::Attribute attr = functionDecl->get_attribute();
+                switch ( attr.type ) {
+                        case FunctionDecl::Attribute::Constructor:
+                                output << "__attribute__ ((constructor";
+                                if ( attr.priority != FunctionDecl::Attribute::Default ) {
+                                        output << "(" << attr.priority << ")";
+                                }
+                                output << ")) ";
+                                break;
+                        case FunctionDecl::Attribute::Destructor:
+                                output << "__attribute__ ((destructor";
+                                if ( attr.priority != FunctionDecl::Attribute::Default ) {
+                                        output << "(" << attr.priority << ")";
+                                }
+                                output << ")) ";
+                                break;
+                        default:
+                                break;
+                }
                 handleStorageClass( functionDecl );
                 if ( functionDecl->get_isInline() ) {
@@ -286 +270 @@
                                                         UntypedExpr *newExpr = new UntypedExpr( new NameExpr( "*?" ) );
                                                         newExpr->get_args().push_back( *arg );
-                                                        assert( (*arg)->get_results().size() == 1 );
-                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_results().front() );
-                                                        assert( type );
-                                                        newExpr->get_results().push_back( type );
                                                         *arg = newExpr;
                                                 } // if
@@ -318 +298 @@
                                         if ( applicationExpr->get_args().size() == 1 ) {
                                                 // the expression fed into a single parameter constructor or destructor
-                                                // may contain side effects, so must still output this expression
-                                                output << "(";
+                                                // may contain side effects - output as a void expression
+                                                output << "((void)(";
                                                 (*arg++)->accept( *this );
-                                                output << ") /* " << opInfo.inputName << " */";
+                                                output << ")) /* " << opInfo.inputName << " */";
                                         } else if ( applicationExpr->get_args().size() == 2 ) {
                                                 // intrinsic two parameter constructors are essentially bitwise assignment
@@ -404 +384 @@
                                         if ( untypedExpr->get_args().size() == 1 ) {
                                                 // the expression fed into a single parameter constructor or destructor
-                                                // may contain side effects, so must still output this expression
-                                                output << "(";
+                                                // may contain side effects - output as a void expression
+                                                output << "((void)(";
                                                 (*arg++)->accept( *this );
-                                                output << ") /* " << opInfo.inputName << " */";
+                                                output << ")) /* " << opInfo.inputName << " */";
                                         } else if ( untypedExpr->get_args().size() == 2 ) {
                                                 // intrinsic two parameter constructors are essentially bitwise assignment
@@ -646 +626 @@
 
         void CodeGenerator::visit( ExprStmt *exprStmt ) {
+                // I don't see why this check is necessary.
+                // If this starts to cause problems then put it back in,
+                // with an explanation
                 assert( exprStmt );
-                // cast the top-level expression to void to reduce gcc warnings.
-                Expression * expr = new CastExpr( exprStmt->get_expr() );
-                expr->accept( *this );
-                output << ";";
+
+                // if ( exprStmt != 0 ) {
+                exprStmt->get_expr()->accept( *this );
+                output << ";" ;
+                // } // if
         }
 
@@ -759 +743 @@
 
         void CodeGenerator::visit( WhileStmt *whileStmt ) {
-                if ( whileStmt->get_isDoWhile() ) {
+                if ( whileStmt->get_isDoWhile() )
                         output << "do" ;
-                } else {
+                else {
                         output << "while (" ;
                         whileStmt->get_condition()->accept( *this );
@@ -785 +769 @@
                 output << "for (;";
 
-                if ( forStmt->get_condition() != 0 ) {
+                if ( forStmt->get_condition() != 0 )
                         forStmt->get_condition()->accept( *this );
-                }
                 output << ";";
 
-                if ( forStmt->get_increment() != 0 ) {
-                        // cast the top-level expression to void to reduce gcc warnings.
-                        Expression * expr = new CastExpr( forStmt->get_increment() );
-                        expr->accept( *this );
-                }
+                if ( forStmt->get_increment() != 0 )
+                        forStmt->get_increment()->accept( *this );
                 output << ") ";
 
@@ -814 +794 @@
                         output << ";";
                 } // if
+        }
+
+        std::string CodeGenerator::printLabels( std::list< Label > &l ) {
+                std::string str( "" );
+                l.unique(); // assumes a sorted list. Why not use set?
+
+                for ( std::list< Label >::iterator i = l.begin(); i != l.end(); i++ )
+                        str += *i + ": ";
+
+                return str;
         }