Index: src/ArgTweak/FunctionFixer.cc =================================================================== --- src/ArgTweak/FunctionFixer.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/ArgTweak/FunctionFixer.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,125 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// FunctionFixer.cc -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 08:12:38 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu May 21 21:11:45 2015 +// Update Count : 7 +// + +#include +#include +#include +#include + +#include "FunctionFixer.h" +#include "SynTree/Expression.h" +#include "SynTree/Declaration.h" +#include "SynTree/Type.h" + +namespace ArgTweak { + FunctionFixer::FunctionFixer( SymTab::Indexer *ind ) : index( ind ) { + if ( index == 0 ) index = new SymTab::Indexer(); + } + + FunctionFixer::~FunctionFixer() { + delete index; + } + + DeclarationWithType *FunctionFixer::mutate( FunctionDecl *functionDecl ) { + index->visit( functionDecl ); + /* check for duplicate named parameters here? It might not be an error if they're never used, on the other hand, it + might be to costly to check for duplicates every time we try a match */ + return Parent::mutate( functionDecl ); + } + + Expression *FunctionFixer::mutate( UntypedExpr *untypedExpr ) throw ( SemanticError ) { + assert( untypedExpr != 0 ); + NameExpr *function; + + if ( ( function = dynamic_cast< NameExpr *>(untypedExpr->get_function()) ) != 0 ) { + std::list < DeclarationWithType * > options; + index->lookupId ( function->get_name(), options ); + for ( std::list < DeclarationWithType * >::iterator i = options.begin(); i != options.end(); i++ ) { + FunctionType *f; + if ( ( f = dynamic_cast< FunctionType * > ( (*i)->get_type() ) ) != 0 ) { + std::list < DeclarationWithType * > &pars = f->get_parameters(); + + bool candidateExists ; + for ( std::list < DeclarationWithType * >::iterator p = pars.begin(); p != pars.end(); p++ ) + if ( ( candidateExists = align( f->get_parameters(), untypedExpr->get_args(), Matcher() ) ) ) break; + + if ( ! candidateExists ) throw SemanticError("Error in function call"); + } // if + } // for + } // if + return untypedExpr; + } + + template < class L1, class L2, class Helper > + bool align( L1 &pattern, L2 &possible_permutation, Helper help ) { + std::map < typename Helper::key, int > positions; + int p = 0; + + for ( typename L1::iterator i = pattern.begin(); i != pattern.end(); i++, p++ ) + if ( help.extract_key( *i ) != Helper::null_key ) + positions[ help.extract_key( *i ) ] = p; + + L2 copy_pp( possible_permutation ); + + std::vector< typename L2::value_type > temp(copy_pp.size(), Helper::null_value ); + for ( typename L2::iterator i = copy_pp.begin(); i != copy_pp.end(); i++ ) + if ( positions.find( help.extract_key( *i ) ) != positions.end() ) { + temp [ positions [ help.extract_key( *i ) ] ] = *i; + *i = Helper::null_value; + } // if + + // rest of the arguments + int a = 0; + bool goAhead = true; // go ahead and change the list + for ( typename L2::iterator i = copy_pp.begin(); i != copy_pp.end(); i++, a++ ) { + if ( *i != Helper::null_value ) + if ( temp[a] == Helper::null_value ) + temp[a] = *i; + else + { goAhead = false; /* there's something there already */; break; } + else + if ( temp[a] == Helper::null_value ) + { goAhead = false; /* can't leave empty spaces */ break; } + else + ; // all good, this was filled during the first pass + assert ( temp[a] != Helper::null_value ); + } // for + + // Change the original list + if ( goAhead ) std::copy( temp.begin(), temp.end(), possible_permutation.begin() ); + + return goAhead; + } + + std::string FunctionFixer::Matcher::null_key(""); + Expression *FunctionFixer::Matcher::null_value = 0; + + std::string FunctionFixer::Matcher::extract_key ( DeclarationWithType *decl ) { + return decl->get_name(); + } + + std::string FunctionFixer::Matcher::extract_key ( Expression *expression ) { + if ( expression->get_argName() == 0 ) + return std::string(""); + else + return *(expression->get_argName()); + } +} // namespace ArgTweak + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/ArgTweak/FunctionFixer.h =================================================================== --- src/ArgTweak/FunctionFixer.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/ArgTweak/FunctionFixer.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,60 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// FunctionFixer.h -- +// +// Author : Rodolfo G. Esteves +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon May 18 23:31:58 2015 +// Update Count : 3 +// + +#ifndef _FUNCTION_FIXER_H_ +#define _FUNCTION_FIXER_H_ + +#include "SynTree/Mutator.h" +#include "SymTab/Indexer.h" + +#include "SynTree/Expression.h" + +namespace ArgTweak { + class FunctionFixer : public Mutator { + typedef Mutator Parent; + public: + FunctionFixer(SymTab::Indexer *ind = 0); + ~FunctionFixer(); + + virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ); + virtual Expression *mutate( UntypedExpr *untypedExpr ) throw ( SemanticError ); + private: + class Matcher { + typedef std::string key; + typedef DeclarationWithType * pattern_type; + typedef Expression * permutation_type; + public: + static key null_key; + static permutation_type null_value; + + std::string extract_key( DeclarationWithType * ); + std::string extract_key( Expression * ); + + bool operator()( DeclarationWithType *, Expression * ) { return true; } + }; + + SymTab::Indexer *index; + }; + + template < class L1, class L2, class Predicate > bool align( L1 &pattern, L2 &possible_permutation, Predicate pred ); +} // namespace ArgTweak + +#endif // _FUNCTION_FIXER_H_ + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/ArgTweak/Mutate.cc =================================================================== --- src/ArgTweak/Mutate.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/ArgTweak/Mutate.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,33 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Mutate.cc -- +// +// Author : Rodolfo G. Esteves +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon May 18 23:32:23 2015 +// Update Count : 1 +// + +#include "SynTree/Mutator.h" + +#include "Mutate.h" +#include "FunctionFixer.h" + +namespace ArgTweak { + void mutate( std::list< Declaration * > translationUnit ) { + FunctionFixer ff; + + mutateAll( translationUnit, ff ); + } +} // namespace ArgTweak + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/ArgTweak/Mutate.h =================================================================== --- src/ArgTweak/Mutate.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/ArgTweak/Mutate.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,34 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Mutate.h -- +// +// Author : Rodolfo G. Esteves +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon May 18 23:33:04 2015 +// Update Count : 2 +// + +#ifndef _MUTATE_H +#define _MUTATE_H + +#include +#include + +#include "SynTree/Declaration.h" + +namespace ArgTweak { + void mutate( std::list< Declaration* > translationUnit ); +} // namespace ArgTweak + +#endif // _MUTATE_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/ArgTweak/module.mk =================================================================== --- src/ArgTweak/module.mk (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/ArgTweak/module.mk (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,4 @@ +SRC += ArgTweak/Rewriter.cc \ +# ArgTweak/Mutate.cc \ + $(NULL) + Index: src/CodeGen/CodeGenerator2.cc =================================================================== --- src/CodeGen/CodeGenerator2.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/CodeGen/CodeGenerator2.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,666 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// CodeGenerator2.cc -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu May 21 17:13:35 2015 +// Update Count : 7 +// + +#include +#include +#include +#include + +#include "SynTree/Type.h" +#include "SynTree/Declaration.h" +#include "SynTree/Statement.h" +#include "SynTree/Expression.h" +#include "SynTree/Initializer.h" + +#include "utility.h" +#include "UnimplementedError.h" + +#include "CodeGenerator2.h" +#include "OperatorTable.h" +#include "GenType.h" + +using namespace std; + +namespace CodeGen { + int CodeGenerator2::tabsize = 4; + + CodeGenerator2::CodeGenerator2( std::ostream &os ) : cur_indent( 0 ), insideFunction( false ), before( os ), after() { } + + CodeGenerator2::CodeGenerator2( std::ostream &os, std::string init, int indent, bool infunp ) + : cur_indent( indent ), insideFunction( infunp ), before( os ) { + //before << std::string( init ); + } + + CodeGenerator2::CodeGenerator2( std::ostream &os, char *init, int indent, bool infunp ) + : cur_indent( indent ), insideFunction( infunp ), before( os ) { + //before << std::string( init ); + } + + string mangleName( DeclarationWithType *decl ) { + if ( decl->get_mangleName() != "" ) { + return decl->get_mangleName(); + } else { + return decl->get_name(); + } // if + } + + //*** Declarations + void CodeGenerator2::visit( FunctionDecl *functionDecl ) { + handleStorageClass( functionDecl ); + before << genType( functionDecl->get_functionType(), mangleName( functionDecl ) ); + + // how to get this to the Functype? + std::list< Declaration * > olds = functionDecl->get_oldDecls(); + if ( ! olds.empty() ) { + before << " /* function has old declaration */"; + } // if + + // acceptAll( functionDecl->get_oldDecls(), *this ); + if ( functionDecl->get_statements() ) { + functionDecl->get_statements()->accept(*this ); + } // if + } + + void CodeGenerator2::visit( ObjectDecl *objectDecl ) { + handleStorageClass( objectDecl ); + before << genType( objectDecl->get_type(), mangleName( objectDecl ) ); + + if ( objectDecl->get_init() ) { + before << " = "; + objectDecl->get_init()->accept( *this ); + } // if + if ( objectDecl->get_bitfieldWidth() ) { + before << ":"; + objectDecl->get_bitfieldWidth()->accept( *this ); + } // if + } + + void CodeGenerator2::handleAggregate( AggregateDecl *aggDecl ) { + if ( aggDecl->get_name() != "" ) + before << aggDecl->get_name(); + + std::list< Declaration * > &memb = aggDecl->get_members(); + + if ( ! memb.empty() ) { + before << endl << string( cur_indent, ' ' ) << "{" << endl; + + cur_indent += CodeGenerator2::tabsize; + for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++) { + before << string( cur_indent, ' ' ); + (*i)->accept(*this ); + before << ";" << endl; + } + + cur_indent -= CodeGenerator2::tabsize; + + before << string( cur_indent, ' ' ) << "}"; + } // if + } + + void CodeGenerator2::visit( StructDecl *structDecl ) { + before << "struct "; + handleAggregate( structDecl ); + } + + void CodeGenerator2::visit( UnionDecl *aggregateDecl ) { + before << "union "; + handleAggregate( aggregateDecl ); + } + + void CodeGenerator2::visit( EnumDecl *aggDecl ) { + before << "enum "; + + if ( aggDecl->get_name() != "" ) + before << aggDecl->get_name(); + + std::list< Declaration* > &memb = aggDecl->get_members(); + + if ( ! memb.empty() ) { + before << endl << "{" << endl; + + cur_indent += CodeGenerator2::tabsize; + for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++) { + ObjectDecl *obj = dynamic_cast< ObjectDecl* >( *i ); + assert( obj ); + before << string( cur_indent, ' ' ) << mangleName( obj ); + if ( obj->get_init() ) { + before << " = "; + obj->get_init()->accept(*this ); + } // if + before << "," << endl; + } // for + + cur_indent -= CodeGenerator2::tabsize; + + before << "}" << endl; + } // if + } + + void CodeGenerator2::visit( ContextDecl *aggregateDecl ) {} + + void CodeGenerator2::visit( TypedefDecl *typeDecl ) { + before << "typedef "; + before << genType( typeDecl->get_base(), typeDecl->get_name() ); + } + + void CodeGenerator2::visit( TypeDecl *typeDecl ) { + // really, we should mutate this into something that isn't a TypeDecl but that requires large-scale changes, + // still to be done + before << "extern unsigned long " << typeDecl->get_name(); + if ( typeDecl->get_base() ) { + before << " = sizeof( " << genType( typeDecl->get_base(), "" ) << " )"; + } // if + } + + void CodeGenerator2::visit( SingleInit *init ) { + init->get_value()->accept( *this ); + } + + void CodeGenerator2::visit( ListInit *init ) { + before << "{ "; + genCommaList( init->begin_initializers(), init->end_initializers() ); + before << " }"; + } + + void CodeGenerator2::visit( Constant *constant ) { + before << constant->get_value() ; + } + + //*** Expressions + void CodeGenerator2::visit( ApplicationExpr *applicationExpr ) { + if ( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( applicationExpr->get_function() ) ) { + OperatorInfo opInfo; + if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( varExpr->get_var()->get_name(), opInfo ) ) { + std::list< Expression* >::iterator arg = applicationExpr->get_args().begin(); + switch ( opInfo.type ) { + case OT_PREFIXASSIGN: + case OT_POSTFIXASSIGN: + case OT_INFIXASSIGN: + { + assert( arg != applicationExpr->get_args().end() ); + if ( AddressExpr *addrExpr = dynamic_cast< AddressExpr * >( *arg ) ) { + + *arg = addrExpr->get_arg(); + } else { + UntypedExpr *newExpr = new UntypedExpr( new NameExpr( "*?" ) ); + newExpr->get_args().push_back( *arg ); + *arg = newExpr; + } // if + break; + } + + default: + // do nothing + ; + } + + switch ( opInfo.type ) { + case OT_INDEX: + assert( applicationExpr->get_args().size() == 2 ); + (*arg++)->accept( *this ); + before << "["; + (*arg)->accept( *this ); + before << "]"; + break; + + case OT_CALL: + // there are no intrinsic definitions of the function call operator + assert( false ); + break; + + case OT_PREFIX: + case OT_PREFIXASSIGN: + assert( applicationExpr->get_args().size() == 1 ); + before << "("; + before << opInfo.symbol; + (*arg)->accept( *this ); + before << ")"; + break; + + case OT_POSTFIX: + case OT_POSTFIXASSIGN: + assert( applicationExpr->get_args().size() == 1 ); + (*arg)->accept( *this ); + before << opInfo.symbol; + break; + + case OT_INFIX: + case OT_INFIXASSIGN: + assert( applicationExpr->get_args().size() == 2 ); + before << "("; + (*arg++)->accept( *this ); + before << opInfo.symbol; + (*arg)->accept( *this ); + before << ")"; + break; + + case OT_CONSTANT: + // there are no intrinsic definitions of 0 or 1 as functions + assert( false ); + } + } else { + varExpr->accept( *this ); + before << "("; + genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() ); + before << ")"; + } // if + } else { + applicationExpr->get_function()->accept( *this ); + before << "("; + genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() ); + before << ")"; + } // if + } + + void CodeGenerator2::visit( UntypedExpr *untypedExpr ) { + if ( NameExpr *nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) { + OperatorInfo opInfo; + if ( operatorLookup( nameExpr->get_name(), opInfo ) ) { + std::list< Expression* >::iterator arg = untypedExpr->get_args().begin(); + switch ( opInfo.type ) { + case OT_INDEX: + assert( untypedExpr->get_args().size() == 2 ); + (*arg++)->accept( *this ); + before << "["; + (*arg)->accept( *this ); + before << "]"; + break; + + case OT_CALL: + assert( false ); + break; + + case OT_PREFIX: + case OT_PREFIXASSIGN: + assert( untypedExpr->get_args().size() == 1 ); + before << "("; + before << opInfo.symbol; + (*arg)->accept( *this ); + before << ")"; + break; + + case OT_POSTFIX: + case OT_POSTFIXASSIGN: + assert( untypedExpr->get_args().size() == 1 ); + (*arg)->accept( *this ); + before << opInfo.symbol; + break; + + case OT_INFIX: + case OT_INFIXASSIGN: + assert( untypedExpr->get_args().size() == 2 ); + before << "("; + (*arg++)->accept( *this ); + before << opInfo.symbol; + (*arg)->accept( *this ); + before << ")"; + break; + + case OT_CONSTANT: + // there are no intrinsic definitions of 0 or 1 as functions + assert( false ); + } + } else { + nameExpr->accept( *this ); + before << "("; + genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() ); + before << ")"; + } // if + } else { + untypedExpr->get_function()->accept( *this ); + before << "("; + genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() ); + before << ")"; + } // if + } + + void CodeGenerator2::visit( NameExpr *nameExpr ) { + OperatorInfo opInfo; + if ( operatorLookup( nameExpr->get_name(), opInfo ) ) { + assert( opInfo.type == OT_CONSTANT ); + before << opInfo.symbol; + } else { + before << nameExpr->get_name(); + } // if + } + + void CodeGenerator2::visit( AddressExpr *addressExpr ) { + before << "(&"; + // this hack makes sure that we don't convert "constant_zero" to "0" if we're taking its address + if ( VariableExpr *variableExpr = dynamic_cast< VariableExpr* >( addressExpr->get_arg() ) ) { + before << mangleName( variableExpr->get_var() ); + } else { + addressExpr->get_arg()->accept( *this ); + } // if + before << ")"; + } + + void CodeGenerator2::visit( CastExpr *castExpr ) { + before << "(("; + if ( castExpr->get_results().empty() ) { + before << "void" ; + } else { + before << genType( castExpr->get_results().front(), "" ); + } // if + before << ")"; + castExpr->get_arg()->accept( *this ); + before << ")"; + } + + void CodeGenerator2::visit( UntypedMemberExpr *memberExpr ) { + assert( false ); + } + + void CodeGenerator2::visit( MemberExpr *memberExpr ) { + memberExpr->get_aggregate()->accept( *this ); + before << "." << mangleName( memberExpr->get_member() ); + } + + void CodeGenerator2::visit( VariableExpr *variableExpr ) { + OperatorInfo opInfo; + if ( variableExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( variableExpr->get_var()->get_name(), opInfo ) && opInfo.type == OT_CONSTANT ) { + before << opInfo.symbol; + } else { + before << mangleName( variableExpr->get_var() ); + } // if + } + + void CodeGenerator2::visit( ConstantExpr *constantExpr ) { + assert( constantExpr->get_constant() ); + constantExpr->get_constant()->accept( *this ); + } + + void CodeGenerator2::visit( SizeofExpr *sizeofExpr ) { + before << "sizeof("; + if ( sizeofExpr->get_isType() ) { + before << genType( sizeofExpr->get_type(), "" ); + } else { + sizeofExpr->get_expr()->accept( *this ); + } // if + before << ")"; + } + + void CodeGenerator2::visit( LogicalExpr *logicalExpr ) { + before << "("; + logicalExpr->get_arg1()->accept( *this ); + if ( logicalExpr->get_isAnd() ) { + before << " && "; + } else { + before << " || "; + } // if + logicalExpr->get_arg2()->accept( *this ); + before << ")"; + } + + void CodeGenerator2::visit( ConditionalExpr *conditionalExpr ) { + before << "("; + conditionalExpr->get_arg1()->accept( *this ); + before << " ? "; + conditionalExpr->get_arg2()->accept( *this ); + before << " : "; + conditionalExpr->get_arg3()->accept( *this ); + before << ")"; + } + + void CodeGenerator2::visit( CommaExpr *commaExpr ) { + before << "("; + commaExpr->get_arg1()->accept( *this ); + before << " , "; + commaExpr->get_arg2()->accept( *this ); + before << ")"; + } + + void CodeGenerator2::visit( TupleExpr *tupleExpr ) {} + + void CodeGenerator2::visit( TypeExpr *typeExpr ) {} + + + //*** Statements + void CodeGenerator2::visit( CompoundStmt *compoundStmt ) { + std::list ks = compoundStmt->get_kids(); + + before << endl << string( cur_indent, ' ' ) << "{" << endl; + + cur_indent += CodeGenerator2::tabsize; + + for ( std::list::iterator i = ks.begin(); i != ks.end(); i++) { + before << string( cur_indent, ' ' ) << printLabels( (*i)->get_labels() ) ; + (*i)->accept(*this ); + shift_left(); + before << endl; + } + cur_indent -= CodeGenerator2::tabsize; + + before << string( cur_indent, ' ' ) << "}" << endl; + } + + void CodeGenerator2::visit( ExprStmt *exprStmt ) { + if ( exprStmt != 0 ) { + exprStmt->get_expr()->accept( *this ); + shift_left(); + before << ";" ; + } // if + } + + void CodeGenerator2::visit( IfStmt *ifStmt ) { + before << "if ("; + ifStmt->get_condition()->accept(*this ); + after += ")\n"; + shift_left(); + + cur_indent += CodeGenerator2::tabsize; + before << string( cur_indent, ' ' ); + ifStmt->get_thenPart()->accept(*this ); + cur_indent -= CodeGenerator2::tabsize; + shift_left(); before << endl; + + if ( ifStmt->get_elsePart() != 0) { + before << string( cur_indent, ' ' ) << " else " << endl ; + + cur_indent += CodeGenerator2::tabsize; + ifStmt->get_elsePart()->accept(*this ); + cur_indent -= CodeGenerator2::tabsize; + } // if + } + + void CodeGenerator2::visit( SwitchStmt *switchStmt ) { + //before << /* "\r" << */ string( cur_indent, ' ' ) << CodeGenerator2::printLabels( switchStmt->get_labels() ) + before << "switch (" ; + switchStmt->get_condition()->accept(*this ); + after += ")\n"; + shift_left(); + + before << string( cur_indent, ' ' ) << "{" << std::endl; + cur_indent += CodeGenerator2::tabsize; + + std::list< Statement * > stmts = switchStmt->get_branches(); + bool lastBreak = false; + + // horrible, horrible hack + if ( dynamic_cast( stmts.back() ) != 0 ) { + lastBreak = true; + stmts.pop_back(); + } // if + acceptAll( stmts, *this ); + if ( lastBreak ) { + Statement *st = switchStmt->get_branches().back(); + before << CodeGenerator2::printLabels( st->get_labels()); + st->accept( *this ); + } // if + + cur_indent -= CodeGenerator2::tabsize; + + before << /* "\r" << */ string( cur_indent, ' ' ) << "}" << endl ; + } + + void CodeGenerator2::visit( CaseStmt *caseStmt ) { + before << string( cur_indent, ' ' ); + if ( caseStmt->isDefault()) + before << "default " ; + else { + before << "case " ; + caseStmt->get_condition()->accept(*this ); + } // if + after += ":\n"; + shift_left(); + + std::list sts = caseStmt->get_statements(); + + cur_indent += CodeGenerator2::tabsize; + for ( std::list::iterator i = sts.begin(); i != sts.end(); i++) { + before << /* "\r" << */ string( cur_indent, ' ' ) << printLabels( (*i)->get_labels() ) ; + (*i)->accept(*this ); + shift_left(); + before << ";" << endl; + } + cur_indent -= CodeGenerator2::tabsize; + } + + void CodeGenerator2::visit( BranchStmt *branchStmt ) { + switch ( branchStmt->get_type()) { + case BranchStmt::Goto: + if ( ! branchStmt->get_target().empty() ) + before << "goto " << branchStmt->get_target(); + else { + if ( branchStmt->get_computedTarget() != 0 ) { + before << "goto *"; + branchStmt->get_computedTarget()->accept( *this ); + } // if + } // if + break; + case BranchStmt::Break: + before << "break"; + break; + case BranchStmt::Continue: + before << "continue"; + break; + } + before << ";"; + } + + + void CodeGenerator2::visit( ReturnStmt *returnStmt ) { + before << "return "; + + // xxx -- check for null expression; + if ( returnStmt->get_expr() ) { + returnStmt->get_expr()->accept( *this ); + } // if + after += ";"; + } + + void CodeGenerator2::visit( WhileStmt *whileStmt ) { + if ( whileStmt->get_isDoWhile() ) + before << "do" ; + else { + before << "while (" ; + whileStmt->get_condition()->accept(*this ); + after += ")"; + } // if + after += "{\n"; + shift_left(); + + whileStmt->get_body()->accept( *this ); + + before << /* "\r" << */ string( cur_indent, ' ' ) << "}" ; + + if ( whileStmt->get_isDoWhile() ) { + before << " while (" ; + whileStmt->get_condition()->accept(*this ); + after += ");"; + } // if + + after += "\n"; + } + + void CodeGenerator2::visit( ForStmt *forStmt ) { + before << "for ("; + + if ( forStmt->get_initialization() != 0 ) + forStmt->get_initialization()->accept( *this ); + else + before << ";"; + shift_left(); + + if ( forStmt->get_condition() != 0 ) + forStmt->get_condition()->accept( *this ); + shift_left(); before << ";"; + + if ( forStmt->get_increment() != 0 ) + forStmt->get_increment()->accept( *this ); + shift_left(); before << ")" << endl; + + if ( forStmt->get_body() != 0 ) { + cur_indent += CodeGenerator2::tabsize; + before << string( cur_indent, ' ' ) << CodeGenerator2::printLabels( forStmt->get_body()->get_labels() ); + forStmt->get_body()->accept( *this ); + cur_indent -= CodeGenerator2::tabsize; + } // if + } + + void CodeGenerator2::visit( NullStmt *nullStmt ) { + //before << /* "\r" << */ string( cur_indent, ' ' ) << CodeGenerator2::printLabels( nullStmt->get_labels() ); + before << "/* null statement */ ;"; + } + + void CodeGenerator2::visit( DeclStmt *declStmt ) { + declStmt->get_decl()->accept( *this ); + + if ( doSemicolon( declStmt->get_decl() ) ) { + after += ";"; + } // if + shift_left(); + } + + std::string CodeGenerator2::printLabels( std::list< Label > &l ) { + std::string str( "" ); + l.unique(); + + for ( std::list< Label >::iterator i = l.begin(); i != l.end(); i++ ) + str += *i + ": "; + + return str; + } + + void CodeGenerator2::shift_left() { + before << after; + after = ""; + } + + void CodeGenerator2::handleStorageClass( Declaration *decl ) { + switch ( decl->get_storageClass() ) { + case Declaration::NoStorageClass: + break; + case Declaration::Extern: + before << "extern "; + break; + case Declaration::Static: + before << "static "; + break; + case Declaration::Auto: + // silently drop storage class + break; + case Declaration::Register: + before << "register "; + break; + } // switch + } +} // namespace CodeGen + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/CodeGen/CodeGenerator2.h =================================================================== --- src/CodeGen/CodeGenerator2.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/CodeGen/CodeGenerator2.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,126 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// CodeGenerator2.h -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon May 18 23:35:37 2015 +// Update Count : 2 +// + +#ifndef CODEGENV_H +#define CODEGENV_H + +#include +#include + +#include "SynTree/SynTree.h" +#include "SynTree/Visitor.h" +#include "SymTab/Indexer.h" + +namespace CodeGen { + class CodeGenerator2 : public Visitor { + public: + static int tabsize; + + CodeGenerator2( std::ostream &os ); + CodeGenerator2( std::ostream &os, std::string, int indent = 0, bool infun = false ); + CodeGenerator2( std::ostream &os, char *, int indent = 0, bool infun = false ); + + CodeGenerator2( CodeGenerator2 & ); + + //*** Declaration + virtual void visit( StructDecl * ); + virtual void visit( FunctionDecl * ); + virtual void visit( ObjectDecl * ); + virtual void visit( UnionDecl *aggregateDecl ); + virtual void visit( EnumDecl *aggregateDecl ); + virtual void visit( ContextDecl *aggregateDecl ); + virtual void visit( TypedefDecl *typeDecl ); + virtual void visit( TypeDecl *typeDecl ); + + //*** Initializer + virtual void visit( SingleInit * ); + virtual void visit( ListInit * ); + + //*** Constant + virtual void visit( Constant * ); + + //*** Expression + virtual void visit( ApplicationExpr *applicationExpr ); + virtual void visit( UntypedExpr *untypedExpr ); + virtual void visit( NameExpr *nameExpr ); + virtual void visit( AddressExpr *addressExpr ); + virtual void visit( CastExpr *castExpr ); + virtual void visit( UntypedMemberExpr *memberExpr ); + virtual void visit( MemberExpr *memberExpr ); + virtual void visit( VariableExpr *variableExpr ); + virtual void visit( ConstantExpr *constantExpr ); + virtual void visit( SizeofExpr *sizeofExpr ); + virtual void visit( LogicalExpr *logicalExpr ); + virtual void visit( ConditionalExpr *conditionalExpr ); + virtual void visit( CommaExpr *commaExpr ); + virtual void visit( TupleExpr *tupleExpr ); + virtual void visit( TypeExpr *typeExpr ); + + //*** Statements + virtual void visit( CompoundStmt * ); + virtual void visit( ExprStmt * ); + virtual void visit( IfStmt * ); + virtual void visit( SwitchStmt * ); + virtual void visit( CaseStmt * ); + virtual void visit( BranchStmt * ); + virtual void visit( ReturnStmt * ); + virtual void visit( WhileStmt * ); + virtual void visit( ForStmt * ); + virtual void visit( NullStmt * ); + virtual void visit( DeclStmt * ); + + std::string get_string( void ); + void add_string_left( std::string s ) { before << s; } + void shift_left(); + template< class Iterator > void genCommaList( Iterator begin, Iterator end ); + private: + int cur_indent; + bool insideFunction; + std::ostream &before; + std::string after; + + static std::string printLabels ( std::list < Label > & ); + void handleStorageClass( Declaration *decl ); + void handleAggregate( AggregateDecl *aggDecl ); + void handleTypedef( NamedTypeDecl *namedType ); + + }; + + template< class Iterator > + void CodeGenerator2::genCommaList( Iterator begin, Iterator end ) { + if ( begin == end ) return; + + for ( ;; ) { + (*begin++)->accept( *this ); + if ( begin == end ) return; + before << ", "; + } // for + } + + inline bool doSemicolon( Declaration* decl ) { + if ( FunctionDecl* func = dynamic_cast< FunctionDecl* >( decl ) ) { + return ! func->get_statements(); + } // if + return true; + } +} // namespace CodeGen + +#endif // CODEGENV_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/CodeGen/FixNames.cc =================================================================== --- src/CodeGen/FixNames.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/CodeGen/FixNames.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,58 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// FixNames.cc -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon May 18 23:36:42 2015 +// Update Count : 1 +// + +#include "FixNames.h" +#include "SynTree/Declaration.h" +#include "SynTree/Expression.h" +#include "SynTree/Visitor.h" +#include "SymTab/Mangler.h" +#include "OperatorTable.h" + +namespace CodeGen { + class FixNames : public Visitor { + public: + virtual void visit( ObjectDecl *objectDecl ); + virtual void visit( FunctionDecl *functionDecl ); + }; + + void fixNames( std::list< Declaration* > translationUnit ) { + FixNames fixer; + acceptAll( translationUnit, fixer ); + } + + void fixDWT( DeclarationWithType *dwt ) { + if ( dwt->get_name() != "" ) { + if ( LinkageSpec::isDecoratable( dwt->get_linkage() ) ) { + dwt->set_mangleName( SymTab::Mangler::mangle( dwt ) ); + } // if + } // if + } + + void FixNames::visit( ObjectDecl *objectDecl ) { + Visitor::visit( objectDecl ); + fixDWT( objectDecl ); + } + + void FixNames::visit( FunctionDecl *functionDecl ) { + Visitor::visit( functionDecl ); + fixDWT( functionDecl ); + } +} // namespace CodeGen + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/CodeGen/FixNames.h =================================================================== --- src/CodeGen/FixNames.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/CodeGen/FixNames.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,31 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// FixNames.h -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon May 18 23:37:32 2015 +// Update Count : 2 +// + +#ifndef FIXNAMES_H +#define FIXNAMES_H + +#include "SynTree/SynTree.h" + +namespace CodeGen { + void fixNames( std::list< Declaration* > translationUnit ); +} // namespace CodeGen + +#endif // FIXNAMES_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/CodeGen/GenType.cc =================================================================== --- src/CodeGen/GenType.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/CodeGen/GenType.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,210 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// GenType.cc -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon May 18 23:38:22 2015 +// Update Count : 2 +// + +#include +#include + +#include "GenType.h" +#include "CodeGenerator2.h" +#include "SynTree/Visitor.h" +#include "SynTree/Type.h" +#include "SynTree/Expression.h" + +namespace CodeGen { + class GenType : public Visitor { + public: + GenType( const std::string &typeString ); + std::string get_typeString() const { return typeString; } + void set_typeString( const std::string &newValue ) { typeString = newValue; } + + virtual void visit( FunctionType *funcType ); + virtual void visit( VoidType *voidType ); + virtual void visit( BasicType *basicType ); + virtual void visit( PointerType *pointerType ); + virtual void visit( ArrayType *arrayType ); + virtual void visit( StructInstType *structInst ); + virtual void visit( UnionInstType *unionInst ); + virtual void visit( EnumInstType *enumInst ); + virtual void visit( TypeInstType *typeInst ); + + private: + void handleQualifiers( Type *type ); + void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic ); + + std::string typeString; + }; + + std::string genType( Type *type, const std::string &baseString ) { + GenType gt( baseString ); + type->accept( gt ); + return gt.get_typeString(); + } + + GenType::GenType( const std::string &typeString ) : typeString( typeString ) {} + + void GenType::visit( VoidType *voidType ) { + typeString = "void " + typeString; + handleQualifiers( voidType ); + } + + void GenType::visit( BasicType *basicType ) { + BasicType::Kind kind = basicType->get_kind(); + assert( 0 <= kind && kind < BasicType::NUMBER_OF_BASIC_TYPES ); + typeString = std::string( BasicType::typeNames[kind] ) + " " + typeString; + handleQualifiers( basicType ); + } + + void GenType::genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic ) { + std::ostrstream os; + if ( typeString != "" ) { + if ( typeString[ 0 ] == '*' ) { + os << "(" << typeString << ")"; + } else { + os << typeString; + } // if + } // if + os << "["; + + if ( isStatic ) { + os << "static "; + } // if + if ( qualifiers.isConst ) { + os << "const "; + } // if + if ( qualifiers.isVolatile ) { + os << "volatile "; + } // if + if ( qualifiers.isRestrict ) { + os << "__restrict "; + } // if + if ( qualifiers.isAtomic ) { + os << "_Atomic "; + } // if + if ( isVarLen ) { + os << "*"; + } // if + if ( dimension != 0 ) { + CodeGenerator2 cg( os ); + dimension->accept( cg ); + } // if + os << "]"; + + typeString = std::string( os.str(), os.pcount() ); + + base->accept( *this ); + } + + void GenType::visit( PointerType *pointerType ) { + assert( pointerType->get_base() != 0); + if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->get_dimension() ) { + genArray( pointerType->get_qualifiers(), pointerType->get_base(), pointerType->get_dimension(), pointerType->get_isVarLen(), pointerType->get_isStatic() ); + } else { + handleQualifiers( pointerType ); + if ( typeString[ 0 ] == '?' ) { + typeString = "* " + typeString; + } else { + typeString = "*" + typeString; + } // if + pointerType->get_base()->accept( *this ); + } // if + } + + void GenType::visit( ArrayType *arrayType ) { + genArray( arrayType->get_qualifiers(), arrayType->get_base(), arrayType->get_dimension(), arrayType->get_isVarLen(), arrayType->get_isStatic() ); + } + + void GenType::visit( FunctionType *funcType ) { + std::ostrstream os; + + if ( typeString != "" ) { + if ( typeString[ 0 ] == '*' ) { + os << "(" << typeString << ")"; + } else { + os << typeString; + } // if + } // if + + /************* parameters ***************/ + + const std::list &pars = funcType->get_parameters(); + + if ( pars.empty() ) { + if ( funcType->get_isVarArgs() ) { + os << "()"; + } else { + os << "(void)"; + } // if + } else { + CodeGenerator2 cg( os ); + os << "(" ; + + cg.genCommaList( pars.begin(), pars.end() ); + + if ( funcType->get_isVarArgs() ) { + os << ", ..."; + } // if + os << ")"; + } // if + + typeString = std::string( os.str(), os.pcount() ); + + if ( funcType->get_returnVals().size() == 0 ) { + typeString = "void " + typeString; + } else { + funcType->get_returnVals().front()->get_type()->accept( *this ); + } // if + } + + void GenType::visit( StructInstType *structInst ) { + typeString = "struct " + structInst->get_name() + " " + typeString; + handleQualifiers( structInst ); + } + + void GenType::visit( UnionInstType *unionInst ) { + typeString = "union " + unionInst->get_name() + " " + typeString; + handleQualifiers( unionInst ); + } + + void GenType::visit( EnumInstType *enumInst ) { + typeString = "enum " + enumInst->get_name() + " " + typeString; + handleQualifiers( enumInst ); + } + + void GenType::visit( TypeInstType *typeInst ) { + typeString = typeInst->get_name() + " " + typeString; + handleQualifiers( typeInst ); + } + + void GenType::handleQualifiers( Type *type ) { + if ( type->get_isConst() ) { + typeString = "const " + typeString; + } // if + if ( type->get_isVolatile() ) { + typeString = "volatile " + typeString; + } // if + if ( type->get_isRestrict() ) { + typeString = "__restrict " + typeString; + } // if + if ( type->get_isAtomic() ) { + typeString = "_Atomic " + typeString; + } // if + } +} // namespace CodeGen + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/CodeGen/GenType.h =================================================================== --- src/CodeGen/GenType.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/CodeGen/GenType.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,32 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// GenType.h -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon May 18 23:38:53 2015 +// Update Count : 1 +// + +#ifndef _GENTYPE_H +#define _GENTYPE_H + +#include +#include "SynTree/SynTree.h" + +namespace CodeGen { + std::string genType( Type *type, const std::string &baseString ); +} // namespace CodeGen + +#endif // _GENTYPE_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/CodeGen/Generate.cc =================================================================== --- src/CodeGen/Generate.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/CodeGen/Generate.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,49 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Generate.cc -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon May 18 23:39:24 2015 +// Update Count : 1 +// + +#include +#include +#include +#include + +#include "Generate.h" +#include "SynTree/Declaration.h" + +#include "CodeGenerator2.h" + +using namespace std; + +namespace CodeGen { + void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics ) { + CodeGen::CodeGenerator2 cgv( os ); + + for ( std::list::iterator i = translationUnit.begin(); i != translationUnit.end(); i++ ) { + if ( LinkageSpec::isGeneratable( (*i)->get_linkage() ) && (doIntrinsics || ! LinkageSpec::isBuiltin( (*i)->get_linkage() ) ) ) { + (*i)->accept(cgv); + cgv.shift_left(); + if ( doSemicolon( *i ) ) { + os << ";"; + } // if + os << std::endl; + } // if + } // for + } +} // namespace CodeGen + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/CodeGen/Generate.h =================================================================== --- src/CodeGen/Generate.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/CodeGen/Generate.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,34 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Generate.h -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon May 18 23:39:51 2015 +// Update Count : 1 +// + +#ifndef GENERATE_H +#define GENERATE_H + +#include +#include + +#include "SynTree/SynTree.h" + +namespace CodeGen { + void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics ); +} // namespace CodeGen + +#endif // GENERATE_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/CodeGen/OperatorTable.cc =================================================================== --- src/CodeGen/OperatorTable.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/CodeGen/OperatorTable.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,94 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// OperatorTable.cc -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon May 18 23:42:07 2015 +// Update Count : 2 +// + +#include +#include "OperatorTable.h" + +namespace CodeGen { + namespace { + const OperatorInfo tableValues[] = { + { "?[?]", "", "_operator_index", OT_INDEX }, + { "?()", "", "_operator_call", OT_CALL }, + { "?++", "++", "_operator_postincr", OT_POSTFIXASSIGN }, + { "?--", "--", "_operator_postdecr", OT_POSTFIXASSIGN }, + { "*?", "*", "_operator_deref", OT_PREFIX }, + { "+?", "+", "_operator_unaryplus", OT_PREFIX }, + { "-?", "-", "_operator_unaryminus", OT_PREFIX }, + { "~?", "~", "_operator_bitnot", OT_PREFIX }, + { "!?", "!", "_operator_lognot", OT_PREFIX }, + { "++?", "++", "_operator_preincr", OT_PREFIXASSIGN }, + { "--?", "--", "_operator_predecr", OT_PREFIXASSIGN }, + { "?*?", "*", "_operator_multiply", OT_INFIX }, + { "?/?", "/", "_operator_divide", OT_INFIX }, + { "?%?", "%", "_operator_modulus", OT_INFIX }, + { "?+?", "+", "_operator_add", OT_INFIX }, + { "?-?", "-", "_operator_subtract", OT_INFIX }, + { "?<>?", ">>", "_operator_shiftright", OT_INFIX }, + { "??", ">", "_operator_greater", OT_INFIX }, + { "?<=?", "<=", "_operator_lessequal", OT_INFIX }, + { "?>=?", ">=", "_operator_greaterequal", OT_INFIX }, + { "?==?", "==", "_operator_equal", OT_INFIX }, + { "?!=?", "!=", "_operator_notequal", OT_INFIX }, + { "?&?", "&", "_operator_bitand", OT_INFIX }, + { "?^?", "^", "_operator_bitxor", OT_INFIX }, + { "?|?", "|", "_operator_bitor", OT_INFIX }, + { "?=?", "=", "_operator_assign", OT_INFIXASSIGN }, + { "?*=?", "*=", "_operator_multassign", OT_INFIXASSIGN }, + { "?/=?", "/=", "_operator_divassign", OT_INFIXASSIGN }, + { "?%=?", "%=", "_operator_modassign", OT_INFIXASSIGN }, + { "?+=?", "+=", "_operator_addassign", OT_INFIXASSIGN }, + { "?-=?", "-=", "_operator_subassign", OT_INFIXASSIGN }, + { "?<<=?", "<<=", "_operator_shiftleftassign", OT_INFIXASSIGN }, + { "?>>=?", ">>=", "_operator_shiftrightassign", OT_INFIXASSIGN }, + { "?&=?", "&=", "_operator_bitandassign", OT_INFIXASSIGN }, + { "?^=?", "^=", "_operator_bitxorassign", OT_INFIXASSIGN }, + { "?|=?", "|=", "_operator_bitorassign", OT_INFIXASSIGN }, + { "0", "0", "_constant_zero", OT_CONSTANT }, + { "1", "1", "_constant_one", OT_CONSTANT } + }; + + const int numOps = sizeof( tableValues ) / sizeof( OperatorInfo ); + + std::map< std::string, OperatorInfo > table; + + void initialize() { + for ( int i = 0; i < numOps; ++i ) { + table[ tableValues[i].inputName ] = tableValues[i]; + } // for + } + } // namespace + + bool operatorLookup( std::string funcName, OperatorInfo &info ) { + static bool init = false; + if ( ! init ) { + initialize(); + } // if + std::map< std::string, OperatorInfo >::const_iterator i = table.find( funcName ); + if ( i == table.end() ) { + return false; + } else { + info = i->second; + return true; + } // if + } +} // namespace CodeGen + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/CodeGen/OperatorTable.h =================================================================== --- src/CodeGen/OperatorTable.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/CodeGen/OperatorTable.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,50 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// OperatorTable.h -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon May 18 23:43:07 2015 +// Update Count : 2 +// + +#ifndef _OPERATORTABLE_H +#define _OPERATORTABLE_H + +#include + +namespace CodeGen { + enum OperatorType { + OT_INDEX, + OT_CALL, + OT_PREFIX, + OT_POSTFIX, + OT_INFIX, + OT_PREFIXASSIGN, + OT_POSTFIXASSIGN, + OT_INFIXASSIGN, + OT_CONSTANT + }; + + struct OperatorInfo { + std::string inputName; + std::string symbol; + std::string outputName; + OperatorType type; + }; + + bool operatorLookup( std::string funcName, OperatorInfo &info ); +} // namespace CodeGen + +#endif // _OPERATORTABLE_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/CodeGen/module.mk =================================================================== --- src/CodeGen/module.mk (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/CodeGen/module.mk (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,6 @@ +SRC += CodeGen/Generate.cc \ + CodeGen/CodeGenerator2.cc \ + CodeGen/GenType.cc \ + CodeGen/FixNames.cc \ + CodeGen/OperatorTable.cc \ + $(NULL) Index: src/Common/CompilerError.h =================================================================== --- src/Common/CompilerError.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Common/CompilerError.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,40 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// CompilerError.h -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue May 19 07:20:37 2015 +// Update Count : 2 +// + +#ifndef COMPILER_ERROR_H +#define COMPILER_ERROR_H + +#include +//#include "../config.h" + +class CompilerError : public std::exception { + public: + CompilerError(); + CompilerError( std::string what ) : what( what ) {} + ~CompilerError() throw () {} + + std::string get_what() const { return what; } + void set_what( std::string newValue ) { what = newValue; } + private: + std::string what; +}; + +#endif // COMPILER_ERROR_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Common/SemanticError.cc =================================================================== --- src/Common/SemanticError.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Common/SemanticError.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,47 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// SemanticError.cc -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue May 19 07:21:25 2015 +// Update Count : 1 +// + +#include +#include +#include +#include +#include + +#include "SemanticError.h" + +SemanticError::SemanticError() { +} + +SemanticError::SemanticError( std::string error ) { + errors.push_back( std::string( "Error: " ) + error ); +} + +void SemanticError::append( SemanticError &other ) { + errors.splice( errors.end(), other.errors ); +} + +bool SemanticError::isEmpty() const { + return errors.empty(); +} + +void SemanticError::print( std::ostream &os ) { + std::copy( errors.begin(), errors.end(), std::ostream_iterator< std::string >( os, "\n" ) ); +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Common/SemanticError.h =================================================================== --- src/Common/SemanticError.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Common/SemanticError.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,56 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// SemanticError.h -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue May 19 07:22:23 2015 +// Update Count : 1 +// + +#ifndef SEMANTICERROR_H +#define SEMANTICERROR_H + +#include +#include +#include +#include +#include + +class SemanticError : public std::exception { + public: + SemanticError(); + SemanticError( std::string error ); + template< typename T > SemanticError( const std::string &error, const T *obj ); + ~SemanticError() throw() {} + + void append( SemanticError &other ); + bool isEmpty() const; + void print( std::ostream &os ); + + // constructs an exception using the given message and the printed + // representation of the obj (T must have a print method) + private: + std::list< std::string > errors; +}; + +template< typename T > +SemanticError::SemanticError( const std::string &error, const T *obj ) { + std::ostrstream os; + os << "Error: " << error; + obj->print( os ); + errors.push_back( std::string( os.str(), os.pcount() ) ); +} + +#endif // SEMANTICERROR_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Common/UnimplementedError.h =================================================================== --- src/Common/UnimplementedError.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Common/UnimplementedError.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,39 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// UnimplementedError.h -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue May 19 07:23:08 2015 +// Update Count : 1 +// + +#ifndef _UNIMPLEMENTEDERROR_H +#define _UNIMPLEMENTEDERROR_H + +#include + +class UnimplementedError : public std::exception { + public: + UnimplementedError(); + UnimplementedError( std::string what ) : what( what ) {} + ~UnimplementedError() throw () {} + + std::string get_what() const { return what; } + void set_what( std::string newValue ) { what = newValue; } + private: + std::string what; +}; + +#endif // _UNIMPLEMENTEDERROR_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Common/UniqueName.cc =================================================================== --- src/Common/UniqueName.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Common/UniqueName.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,34 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// UniqueName.cc -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue May 19 07:23:41 2015 +// Update Count : 1 +// + +#include +#include + +#include "UniqueName.h" + +UniqueName::UniqueName( const std::string &base ) : base( base ), count( 0 ) { +} + +std::string UniqueName::newName( const std::string &additional ) { + std::ostrstream os; + os << base << additional << count++; + return std::string( os.str(), os.pcount() ); +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Common/UniqueName.h =================================================================== --- src/Common/UniqueName.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Common/UniqueName.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,36 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// UniqueName.h -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue May 19 07:24:20 2015 +// Update Count : 1 +// + +#ifndef UNIQUENAME_H +#define UNIQUENAME_H + +#include + +class UniqueName { + public: + UniqueName( const std::string &base = "" ); + std::string newName( const std::string &additional = "" ); + private: + std::string base; + int count; +}; + +#endif // UNIQUENAME_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Common/module.mk =================================================================== --- src/Common/module.mk (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Common/module.mk (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,2 @@ +SRC += Common/SemanticError.cc \ + Common/UniqueName.cc Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Common/utility.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,206 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// utility.h -- +// +// Author : Richard C. Bilson +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue May 19 15:34:57 2015 +// Update Count : 3 +// + +#ifndef _UTILITY_H +#define _UTILITY_H + +#include +#include +#include +#include +#include +#include + +template< typename T > +static inline T * maybeClone( const T *orig ) { + if ( orig ) { + return orig->clone(); + } else { + return 0; + } // if +} + +template< typename T, typename U > +static inline T * maybeBuild( const U *orig ) { + if ( orig ) { + return orig->build(); + } else { + return 0; + } // if +} + +template< typename Input_iterator > +void printEnums( Input_iterator begin, Input_iterator end, const char * const *name_array, std::ostream &os ) { + for ( Input_iterator i = begin; i != end; ++i ) { + os << name_array[ *i ] << ' '; + } // for +} + +template< typename Container > +void deleteAll( Container &container ) { + for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) { + delete *i; + } // for +} + +template< typename Container > +void printAll( const Container &container, std::ostream &os, int indent = 0 ) { + for ( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) { + if ( *i ) { + os << std::string(indent, ' '); + (*i)->print( os, indent + 2 ); + os << std::endl; + } // if + } // for +} + +template< typename SrcContainer, typename DestContainer > +void cloneAll( const SrcContainer &src, DestContainer &dest ) { + typename SrcContainer::const_iterator in = src.begin(); + std::back_insert_iterator< DestContainer > out( dest ); + while ( in != src.end() ) { + *out++ = (*in++)->clone(); + } // while +} + +template< typename Container > +void assertAll( const Container &container ) { + int count = 0; + for ( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) { + if ( !(*i) ) { + std::cerr << count << " is null" << std::endl; + } // if + } // for +} + +static inline std::string assign_strptr( std::string *str ) { + if ( str == 0 ) { + return ""; + } else { + std::string tmp; + tmp = *str; + delete str; + return tmp; + } // if +} + +template< class T, typename ResultType, ResultType (T::* memfunc)() > +ResultType dispatch( T *pT ) { + return (pT->*memfunc)(); +} + +template < typename T > +std::list tail( std::list l ) { + if ( ! l.empty() ) { + std::list ret(++(l.begin()), l.end()); + return ret; + } // if +} + +template < typename T > +std::list flatten( std::list < std::list > l) { + typedef std::list Ts; + + Ts ret; + + switch ( l.size() ) { + case 0: + return ret; + case 1: + return l.front(); + default: + ret = flatten(tail(l)); + ret.insert(ret.begin(), l.front().begin(), l.front().end()); + return ret; + } // switch +} + +template < typename T > +std::string toString ( T value ) { + std::ostrstream os; + + os << value; // << std::ends; + os.freeze( false ); + + return std::string(os.str(), os.pcount()); +} + +template< class Constructed, typename Arg > +Constructed *ctor( Arg arg ) { + Constructed *c = new Constructed( arg ); + return c; +} + +template< class Constructed, typename Arg > +Constructed ctor_noptr( Arg arg ) { + return Constructed( arg ); +} + +template< typename T > +void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) { + // TIter should secretly be a typename std::list< T >::iterator + // ( g++ 3.2 issues a 'is implicitly a typename' warning if I make this explicit ) + typename std::list< T >::iterator next = pos; advance( next, 1 ); + + //if ( next != org.end() ) { + org.erase( pos ); + org.splice( next, with ); + //} + + return; +} + +template< typename T1, typename T2 > +T2 *cast_ptr( T1 *from ) { + return dynamic_cast< T2 * >( from ); +} + +template< class Exception, typename Arg > +void inline assert_throw( bool pred, Arg arg ) { + if (pred) throw Exception( arg ); +} + +template< typename T > +struct is_null_pointer { + bool operator()( const T *ptr ) { return ( ptr == 0 ); } +}; + +template< class InputIterator, class OutputIterator, class Predicate > +void filter(InputIterator begin, InputIterator end, OutputIterator out, Predicate pred) { + while ( begin++ != end ) + if ( pred(*begin) ) *out++ = *begin; + + return; +} + +template< class InputIterator1, class InputIterator2, class OutputIterator > +void zip( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out ) { + while ( b1 != e1 && b2 != e2 ) + *out++ = std::pair(*b1++, *b2++); +} + +template< class InputIterator1, class InputIterator2, class OutputIterator, class BinFunction > +void zipWith( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out, BinFunction func ) { + while ( b1 != e1 && b2 != e2 ) + *out++ = func(*b1++, *b2++); +} + +#endif // _UTILITY_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/ControlStruct/CaseRangeMutator.cc =================================================================== --- src/ControlStruct/CaseRangeMutator.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/ControlStruct/CaseRangeMutator.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,202 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// CaseRangeMutator.cc -- +// +// Author : Rodolfo G. Esteves +// Created On : Mon May 18 07:44:20 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue May 19 13:00:28 2015 +// Update Count : 3 +// + +#include +#include +#include +#include + +#include "utility.h" + +#include "SynTree/Statement.h" +#include "SynTree/Expression.h" +#include "SynTree/Constant.h" +#include "SynTree/Type.h" +#include "CaseRangeMutator.h" + +namespace ControlStruct { + Statement *CaseRangeMutator::mutate( ChooseStmt *chooseStmt ) { + // There shouldn't be any `choose' statements by now, throw an exception or something. + throw( 0 ) ; /* FIXME */ + } + + Statement *CaseRangeMutator::mutate( SwitchStmt *switchStmt ) { + std::list< Statement * > &cases = switchStmt->get_branches(); + + // a `for' would be more natural... all this contortions are because `replace' invalidates the iterator + std::list< Statement * >::iterator i = cases.begin(); + while ( i != cases.end() ) { + (*i )->acceptMutator( *this ); + + if ( ! newCaseLabels.empty() ) { + std::list< Statement * > newCases; + + // transform( newCaseLabels.begin(), newCaseLabels.end(), bnd1st( ptr_fun( ctor< CaseStmt, Label, Expression * > ) ) ); + + for ( std::list< Expression * >::iterator j = newCaseLabels.begin(); + j != newCaseLabels.end(); j++ ) { + std::list