Index: translator/CodeGen/GenType.cc =================================================================== --- translator/CodeGen/GenType.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/CodeGen/GenType.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -74,4 +74,7 @@ if ( qualifiers.isRestrict ) { os << "__restrict "; + } // if + if ( qualifiers.isAtomic ) { + os << "_Atomic "; } // if if ( isVarLen ) { @@ -180,4 +183,7 @@ typeString = "__restrict " + typeString; } // if + if ( type->get_isAtomic() ) { + typeString = "_Atomic " + typeString; + } // if } } // namespace CodeGen Index: translator/GenPoly/Box.cc =================================================================== --- translator/GenPoly/Box.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/GenPoly/Box.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -772,5 +772,5 @@ Expression *Pass1::mutate( AddressExpr *addrExpr ) { assert( !addrExpr->get_arg()->get_results().empty() ); - mutateExpression( addrExpr->get_arg() ); + addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) ); if ( isPolyType( addrExpr->get_arg()->get_results().front(), env, scopeTyVars ) ) { Expression *ret = addrExpr->get_arg(); Index: translator/GenPoly/ScrubTyVars.cc =================================================================== --- translator/GenPoly/ScrubTyVars.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/GenPoly/ScrubTyVars.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -4,49 +4,48 @@ #include "SynTree/Mutator.h" #include "SynTree/Type.h" +#include "SynTree/Expression.h" namespace GenPoly { + Type * ScrubTyVars::mutate( TypeInstType *typeInst ) { + TyVarMap::const_iterator tyVar = tyVars.find( typeInst->get_name() ); + if ( doAll || tyVar != tyVars.end() ) { + switch( tyVar->second ) { + case TypeDecl::Any: + case TypeDecl::Dtype: + { + PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) ); + delete typeInst; + return ret; + } + case TypeDecl::Ftype: + delete typeInst; + return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ); + } + } + return typeInst; + } -Type* -ScrubTyVars::mutate( TypeInstType *typeInst ) -{ - TyVarMap::const_iterator tyVar = tyVars.find( typeInst->get_name() ); - if( doAll || tyVar != tyVars.end() ) { - switch( tyVar->second ) { - case TypeDecl::Any: - case TypeDecl::Dtype: - { - PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) ); - delete typeInst; - return ret; + Expression * ScrubTyVars::mutate( SizeofExpr *szeof ) { + // sizeof( T ) => T parameter, which is the size of T + if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( szeof->get_type() ) ) { + Expression *expr = new NameExpr( typeInst->get_name() ); + return expr; + } else { + return Mutator::mutate( szeof ); + } } - - case TypeDecl::Ftype: - delete typeInst; - return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ); + + Type * ScrubTyVars::mutate( PointerType *pointer ) { + if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( pointer->get_base() ) ) { + if ( doAll || tyVars.find( typeInst->get_name() ) != tyVars.end() ) { + Type *ret = mutate( typeInst ); + ret->get_qualifiers() += pointer->get_qualifiers(); + pointer->set_base( 0 ); + delete pointer; + return ret; + } + } + return Mutator::mutate( pointer ); } - } - return typeInst; -} - -Type* -ScrubTyVars::mutate( PointerType *pointer ) -{ - if( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( pointer->get_base() ) ) { - if( doAll || tyVars.find( typeInst->get_name() ) != tyVars.end() ) { - Type *ret = mutate( typeInst ); -/// std::cout << "pointer is "; -/// pointer->print( std::cout ); -/// std::cout << std::endl << "ret is "; -/// ret->print( std::cout ); -/// std::cout << std::endl; - ret->get_qualifiers() += pointer->get_qualifiers(); - pointer->set_base( 0 ); - delete pointer; - return ret; - } - } - return Mutator::mutate( pointer ); -} - } // namespace GenPoly Index: translator/GenPoly/ScrubTyVars.h =================================================================== --- translator/GenPoly/ScrubTyVars.h (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/GenPoly/ScrubTyVars.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -1,9 +1,2 @@ -/* - * This file is part of the Cforall project - * - * $Id: ScrubTyVars.h,v 1.4 2005/08/29 20:14:13 rcbilson Exp $ - * - */ - #ifndef GENPOLY_SCRUBTYVARS_H #define GENPOLY_SCRUBTYVARS_H @@ -15,43 +8,36 @@ namespace GenPoly { + class ScrubTyVars : public Mutator { + public: + ScrubTyVars( bool doAll, const TyVarMap &tyVars ): doAll( doAll ), tyVars( tyVars ) {} + + template< typename SynTreeClass > + static SynTreeClass *scrub( SynTreeClass *target, const TyVarMap &tyVars ); + template< typename SynTreeClass > + static SynTreeClass *scrub( SynTreeClass *target ); + + virtual Type* mutate( TypeInstType *typeInst ); + Expression* mutate( SizeofExpr *szeof ); + virtual Type* mutate( PointerType *pointer ); + private: + bool doAll; + const TyVarMap &tyVars; + }; -class ScrubTyVars : public Mutator -{ -public: - ScrubTyVars( bool doAll, const TyVarMap &tyVars ): doAll( doAll ), tyVars( tyVars ) {} - - template< typename SynTreeClass > - static SynTreeClass *scrub( SynTreeClass *target, const TyVarMap &tyVars ); - template< typename SynTreeClass > - static SynTreeClass *scrub( SynTreeClass *target ); - - virtual Type* mutate( TypeInstType *typeInst ); - virtual Type* mutate( PointerType *pointer ); + /* static class method */ + template< typename SynTreeClass > + SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars ) { + ScrubTyVars scrubber( false, tyVars ); + return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) ); + } -private: - bool doAll; - const TyVarMap &tyVars; -}; - -/* static class method */ -template< typename SynTreeClass > -SynTreeClass * -ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars ) -{ - ScrubTyVars scrubber( false, tyVars ); - return static_cast< SynTreeClass* >( target->acceptMutator( scrubber ) ); -} - -/* static class method */ -template< typename SynTreeClass > -SynTreeClass * -ScrubTyVars::scrub( SynTreeClass *target ) -{ - TyVarMap tyVars; - ScrubTyVars scrubber( true, tyVars ); - return static_cast< SynTreeClass* >( target->acceptMutator( scrubber ) ); -} - + /* static class method */ + template< typename SynTreeClass > + SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target ) { + TyVarMap tyVars; + ScrubTyVars scrubber( true, tyVars ); + return static_cast< SynTreeClass* >( target->acceptMutator( scrubber ) ); + } } // namespace GenPoly -#endif /* #ifndef GENPOLY_SCRUBTYVARS_H */ +#endif // GENPOLY_SCRUBTYVARS_H Index: translator/InitTweak/InitModel.h =================================================================== --- translator/InitTweak/InitModel.h (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/InitTweak/InitModel.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -12,105 +12,99 @@ namespace InitTweak { + class InitModelBuilder : public AssociationBuilder, public Visitor { + public: + InitModelBuilder( Declaration * ); + ~InitModelBuilder(); - class InitModelBuilder : public AssociationBuilder, public Visitor { - public: - InitModelBuilder( Declaration * ); - ~InitModelBuilder(); + virtual Association *grab_assoc() { taken = true; return building; } + virtual Association *get_assoc() { return building; } + void set_assoc( Association *newAssoc ) { building = newAssoc; } - virtual Association *grab_assoc() { taken = true; return building; } - virtual Association *get_assoc() { return building; } - void set_assoc( Association *newAssoc ) { building = newAssoc; } + void init(); + static int interpretDimension( Expression *exp ) { + ConstantFolder folder( exp ); + try { + return folder.get_constant(); + } catch (...) { + throw SemanticError("Invalid array dimension"); + } + } - void init(); - static int interpretDimension( Expression *exp ) { - ConstantFolder folder( exp ); - try { - return folder.get_constant(); - } catch (...) { - throw SemanticError("Invalid array dimension"); - } - } + // types + virtual void visit( ArrayType * ); + virtual void visit( StructInstType * ); + virtual void visit( UnionInstType * ); + virtual void visit( EnumInstType * ); + virtual void visit( ContextInstType * ) { throw 0; } + virtual void visit( TypeInstType * ) { throw 0; } + // virtual void visit( TupleType *tupleType ); + // declarations + virtual void visit( StructDecl *); + virtual void visit( UnionDecl *); + virtual void visit( EnumDecl *); + private: + class ConstantFolder : public Visitor { + public: + ConstantFolder( Expression *_expr = 0 ): expr(_expr) {} + int get_constant() throw() { expr->accept( *this ); return value; } + void set_constant( Expression *newExp ) { expr = newExp; } + // Visitor interface + void visit( Expression * ) { throw 0; } + void visit( NameExpr * ) { throw 0; } + void visit( CastExpr * ) { throw 0; } + void visit( UntypedMemberExpr * ) { throw 0; } + void visit( VariableExpr * ) { throw 0; } + void visit( ConstantExpr * ); + void visit( SizeofExpr * ) { throw 0; } + void visit( AttrExpr * ) { throw 0; } + void visit( LogicalExpr * ) { throw 0; } + void visit( ConditionalExpr * ) { throw 0; } + void visit( CommaExpr * ) { throw 0; } + private: + Expression *expr; + int value; + }; - // types - virtual void visit( ArrayType * ); - virtual void visit( StructInstType * ); - virtual void visit( UnionInstType * ); - virtual void visit( EnumInstType * ); - virtual void visit( ContextInstType * ) { throw 0; } - virtual void visit( TypeInstType * ) { throw 0; } - // virtual void visit( TupleType *tupleType ); - // declarations - virtual void visit( StructDecl *); - virtual void visit( UnionDecl *); - virtual void visit( EnumDecl *); - - private: - class ConstantFolder : public Visitor { - public: - ConstantFolder( Expression *_expr = 0 ): expr(_expr) {} - int get_constant() throw() { expr->accept( *this ); return value; } - void set_constant( Expression *newExp ) { expr = newExp; } - // Visitor interface - void visit( Expression * ) { throw 0; } - void visit( NameExpr * ) { throw 0; } - void visit( CastExpr * ) { throw 0; } - void visit( UntypedMemberExpr * ) { throw 0; } - void visit( VariableExpr * ) { throw 0; } - void visit( ConstantExpr * ); - void visit( SizeofExpr * ) { throw 0; } - void visit( AttrExpr * ) { throw 0; } - void visit( LogicalExpr * ) { throw 0; } - void visit( ConditionalExpr * ) { throw 0; } - void visit( CommaExpr * ) { throw 0; } - private: - Expression *expr; - int value; + bool taken; + Declaration *decl; // ? + Association *building; }; - bool taken; - Declaration *decl; // ? - Association *building; - }; + class InitModelFiller : public AssociationFiller, public Visitor { + public: + InitModelFiller( Association *, Initializer *, bool _topLevel = false ); + ~InitModelFiller() { /* pointers in here are not owned by object (never created by object either) */ } + virtual Association *get_assoc() { return model; } + virtual void set_assoc( Association *newAssoc ) { model = newAssoc; } - class InitModelFiller : public AssociationFiller, public Visitor { - public: - InitModelFiller( Association *, Initializer *, bool _topLevel = false ); - ~InitModelFiller() { /* pointers in here are not owned by object (never created by object either) */ } - virtual Association *get_assoc() { return model; } - virtual void set_assoc( Association *newAssoc ) { model = newAssoc; } + void init(); + // Visitor interface + virtual void visit( SingleInit *singleInit ); + virtual void visit( ListInit *listInit ); + private: + Association *model; + Initializer *orgInit; + bool topLevel; + long int next; + }; - void init(); - // Visitor interface - virtual void visit( MemberInit *memberInit ) { throw 0; } - virtual void visit( ElementInit *elementInit ) { throw 0; } - virtual void visit( SingleInit *singleInit ); - virtual void visit( ListInit *listInit ); + class InitUnspooler : public AssociationVisitor { + public: + InitUnspooler() : init(0), taken( false ) {} + virtual ~InitUnspooler() { if (!taken && (init != 0)) { delete init; init = 0; } } + Initializer *get_initializer() { return init; } + Initializer *grab_initializer() { taken = true; return init; } - private: - Association *model; - Initializer *orgInit; - bool topLevel; - long int next; - }; - - class InitUnspooler : public AssociationVisitor { - public: - InitUnspooler() : init(0), taken( false ) {} - virtual ~InitUnspooler() { if (!taken && (init != 0)) { delete init; init = 0; } } - Initializer *get_initializer() { return init; } - Initializer *grab_initializer() { taken = true; return init; } - - virtual void visit( SingleName * ); - virtual void visit( PointAssociation * ); - virtual void visit( RangeAssociation * ) { std::cerr << "InitUnspooler - In a range assoc" << std::endl; return; } - - private: - Initializer *init; - bool taken; - }; + virtual void visit( SingleName * ); + virtual void visit( PointAssociation * ); + virtual void visit( RangeAssociation * ) { std::cerr << "InitUnspooler - In a range assoc" << std::endl; return; } + private: + Initializer *init; + bool taken; + }; } // namespace InitTweak -#endif // #define _INITTWEAK_MODEL_H_ +#endif // _INITTWEAK_MODEL_H_ /* Index: translator/Parser/DeclarationNode.cc =================================================================== --- translator/Parser/DeclarationNode.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/Parser/DeclarationNode.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -5,18 +5,12 @@ #include -#include "ParseNode.h" #include "TypeData.h" -#include "utility.h" -#include "SynTree/Declaration.h" #include "SynTree/Expression.h" -#include "SynTree/Initializer.h" -#include "SemanticError.h" -#include "UniqueName.h" -#include "LinkageSpec.h" + using namespace std; -/* these must remain in the same order as the corresponding DeclarationNode enumerations */ -const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue" }; +// These must remain in the same order as the corresponding DeclarationNode enumerations. +const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic" }; const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary" }; const char *DeclarationNode::modifierName[] = { "signed", "unsigned", "short", "long" }; @@ -67,7 +61,7 @@ os << string(indent, ' ' ); if ( name == "" ) { -/// os << "An unnamed "; + os << "unnamed: "; } else { - os << name << ": a "; + os << name << ": "; } @@ -862,16 +856,13 @@ ret = new StructInstType( type->buildQualifiers(), type->aggregate->name ); break; - case DeclarationNode::Union: ret = new UnionInstType( type->buildQualifiers(), type->aggregate->name ); break; - case DeclarationNode::Context: ret = new ContextInstType( type->buildQualifiers(), type->aggregate->name ); break; - default: assert( false ); - } + } // switch buildList( type->aggregate->actuals, ret->get_parameters() ); return ret; @@ -884,5 +875,5 @@ default: return type->build(); - } + } // switch } Index: translator/Parser/ExpressionNode.cc =================================================================== --- translator/Parser/ExpressionNode.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/Parser/ExpressionNode.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -16,5 +16,5 @@ ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) {} -ExpressionNode::ExpressionNode(string *name_) : ParseNode( *name_ ), argName( 0 ) { +ExpressionNode::ExpressionNode( string *name_) : ParseNode( *name_ ), argName( 0 ) { delete name_; } @@ -25,9 +25,9 @@ } else { argName = 0; - } + } // if } ExpressionNode * ExpressionNode::set_asArgName( std::string *aName ) { - argName = new VarRefNode(aName); + argName = new VarRefNode( aName ); return this; } @@ -40,8 +40,8 @@ void ExpressionNode::printDesignation( std::ostream &os, int indent ) const { if ( argName ) { - os << string(' ', indent) << "(designated by: "; - argName->printOneLine(os, indent ); + os << string(' ', indent ) << "(designated by: "; + argName->printOneLine( os, indent ); os << ")" << std::endl; - } + } // if } @@ -52,11 +52,11 @@ } -void NullExprNode::print(std::ostream & os, int indent) const { - printDesignation(os); +void NullExprNode::print( std::ostream & os, int indent ) const { + printDesignation( os ); os << "null expression"; } -void NullExprNode::printOneLine(std::ostream & os, int indent) const { - printDesignation(os); +void NullExprNode::printOneLine( std::ostream & os, int indent ) const { + printDesignation( os ); os << "null"; } @@ -66,15 +66,15 @@ } -CommaExprNode *ExpressionNode::add_to_list(ExpressionNode *exp){ - return new CommaExprNode(this, exp ); +CommaExprNode *ExpressionNode::add_to_list( ExpressionNode *exp ){ + return new CommaExprNode( this, exp ); } // enum ConstantNode::Type = { Integer, Float, Character, String, Range } -ConstantNode::ConstantNode(void) : ExpressionNode(), sign(true), longs(0), size(0) {} - -ConstantNode::ConstantNode(string *name_) : ExpressionNode(name_), sign(true), longs(0), size(0) {} - -ConstantNode::ConstantNode(Type t, string *inVal) : type(t), sign(true), longs(0), size(0) { +ConstantNode::ConstantNode( void ) : ExpressionNode(), sign( true ), longs(0), size(0) {} + +ConstantNode::ConstantNode( string *name_) : ExpressionNode( name_), sign( true ), longs(0), size(0) {} + +ConstantNode::ConstantNode( Type t, string *inVal ) : type( t ), sign( true ), longs(0), size(0) { if ( inVal ) { value = *inVal; @@ -82,7 +82,7 @@ } else { value = ""; - } - - classify(value); + } // if + + classify( value ); } @@ -96,6 +96,6 @@ } -void ConstantNode::classify(std::string &str){ - switch (type){ +void ConstantNode::classify( std::string &str ){ + switch ( type ){ case Integer: case Float: @@ -105,5 +105,5 @@ int i = str.length() - 1; - while ( i >= 0 && !isxdigit(c = str.at(i--)) ) + while ( i >= 0 && !isxdigit( c = str.at( i--)) ) sfx += c; @@ -111,15 +111,15 @@ // get rid of underscores - value.erase(remove(value.begin(), value.end(), '_'), value.end()); - - std::transform(sfx.begin(), sfx.end(), sfx.begin(), tolower_hack); + value.erase( remove( value.begin(), value.end(), '_'), value.end()); + + std::transform( sfx.begin(), sfx.end(), sfx.begin(), tolower_hack ); if ( sfx.find("ll") != string::npos ){ longs = 2; - } else if (sfx.find("l") != string::npos ){ + } else if ( sfx.find("l") != string::npos ){ longs = 1; - } - - assert((longs >= 0) && (longs <= 2)); + } // if + + assert(( longs >= 0) && ( longs <= 2)); if ( sfx.find("u") != string::npos ) @@ -131,6 +131,6 @@ { // remove underscores from hex and oct escapes - if (str.substr(1,2) == "\\x") - value.erase(remove(value.begin(), value.end(), '_'), value.end()); + if ( str.substr(1,2) == "\\x") + value.erase( remove( value.begin(), value.end(), '_'), value.end()); break; @@ -142,5 +142,5 @@ } -ConstantNode::Type ConstantNode::get_type(void) const { +ConstantNode::Type ConstantNode::get_type( void ) const { return type; } @@ -148,5 +148,5 @@ ConstantNode *ConstantNode::append( std::string *newValue ) { if ( newValue ) { - if (type == String){ + if ( type == String ){ std::string temp = *newValue; value.resize( value.size() - 1 ); @@ -156,11 +156,11 @@ delete newValue; - } + } // if return this; } -void ConstantNode::printOneLine(std::ostream &os, int indent ) const { - os << string(indent, ' '); - printDesignation(os); +void ConstantNode::printOneLine( std::ostream &os, int indent ) const { + os << string( indent, ' '); + printDesignation( os ); switch ( type ) { @@ -185,5 +185,5 @@ } -void ConstantNode::print(std::ostream &os, int indent ) const { +void ConstantNode::print( std::ostream &os, int indent ) const { printOneLine( os, indent ); os << endl; @@ -194,15 +194,15 @@ BasicType *bt; - switch (get_type()){ + switch ( get_type()){ case Integer: /* Cfr. standard 6.4.4.1 */ - //bt.set_kind(BasicType::SignedInt); - bt = new BasicType(q, BasicType::SignedInt); + //bt.set_kind( BasicType::SignedInt ); + bt = new BasicType( q, BasicType::SignedInt ); break; case Float: - bt = new BasicType(q, BasicType::Float); + bt = new BasicType( q, BasicType::Float ); break; case Character: - bt = new BasicType(q, BasicType::Char); + bt = new BasicType( q, BasicType::Char ); break; case String: @@ -210,16 +210,16 @@ ArrayType *at; std::string value = get_value(); - at = new ArrayType(q, new BasicType(q, BasicType::Char), - new ConstantExpr( Constant( new BasicType(q, BasicType::SignedInt), + at = new ArrayType( q, new BasicType( q, BasicType::Char ), + new ConstantExpr( Constant( new BasicType( q, BasicType::SignedInt ), toString( value.size() - 1 ) ) ), // account for '\0' false, false ); - return new ConstantExpr( Constant(at, value), maybeBuild< Expression >( get_argName() ) ); + return new ConstantExpr( Constant( at, value ), maybeBuild< Expression >( get_argName() ) ); } - return new ConstantExpr( Constant(bt, get_value()), maybeBuild< Expression >( get_argName() ) ); -} - -VarRefNode::VarRefNode() : isLabel(false) {} - -VarRefNode::VarRefNode(string *name_, bool labelp) : ExpressionNode(name_), isLabel(labelp) {} + return new ConstantExpr( Constant( bt, get_value()), maybeBuild< Expression >( get_argName() ) ); +} + +VarRefNode::VarRefNode() : isLabel( false ) {} + +VarRefNode::VarRefNode( string *name_, bool labelp ) : ExpressionNode( name_), isLabel( labelp ) {} VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) { @@ -230,17 +230,17 @@ } -void VarRefNode::printOneLine(std::ostream &os, int indent ) const { - printDesignation(os); +void VarRefNode::printOneLine( std::ostream &os, int indent ) const { + printDesignation( os ); os << get_name() << ' '; } -void VarRefNode::print(std::ostream &os, int indent ) const { - printDesignation(os); - os << '\r' << string(indent, ' ') << "Referencing: "; +void VarRefNode::print( std::ostream &os, int indent ) const { + printDesignation( os ); + os << '\r' << string( indent, ' ') << "Referencing: "; os << "Variable: " << get_name(); os << endl; } -OperatorNode::OperatorNode(Type t) : type(t) {} +OperatorNode::OperatorNode( Type t ) : type( t ) {} OperatorNode::OperatorNode( const OperatorNode &other ) : ExpressionNode( other ), type( other.type ) { @@ -249,21 +249,21 @@ OperatorNode::~OperatorNode() {} -OperatorNode::Type OperatorNode::get_type(void) const{ +OperatorNode::Type OperatorNode::get_type( void ) const{ return type; } void OperatorNode::printOneLine( std::ostream &os, int indent ) const { - printDesignation(os); + printDesignation( os ); os << OpName[ type ] << ' '; } void OperatorNode::print( std::ostream &os, int indent ) const{ - printDesignation(os); - os << '\r' << string(indent, ' ') << "Operator: " << OpName[type] << endl; + printDesignation( os ); + os << '\r' << string( indent, ' ') << "Operator: " << OpName[type] << endl; return; } -std::string OperatorNode::get_typename(void) const{ - return string(OpName[ type ]); +std::string OperatorNode::get_typename( void ) const{ + return string( OpName[ type ]); } @@ -282,17 +282,17 @@ }; -CompositeExprNode::CompositeExprNode(void) : ExpressionNode(), function( 0 ), arguments( 0 ) { -} - -CompositeExprNode::CompositeExprNode(string *name_) : ExpressionNode(name_), function( 0 ), arguments( 0 ) { -} - -CompositeExprNode::CompositeExprNode(ExpressionNode *f, ExpressionNode *args): - function(f), arguments(args) { -} - -CompositeExprNode::CompositeExprNode(ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2): - function(f), arguments(arg1) { - arguments->set_link(arg2); +CompositeExprNode::CompositeExprNode( void ) : ExpressionNode(), function( 0 ), arguments( 0 ) { +} + +CompositeExprNode::CompositeExprNode( string *name_) : ExpressionNode( name_), function( 0 ), arguments( 0 ) { +} + +CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *args ): + function( f ), arguments( args ) { +} + +CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2): + function( f ), arguments( arg1) { + arguments->set_link( arg2); } @@ -303,6 +303,6 @@ arguments->set_link( cur->clone() ); } else { - arguments = (ExpressionNode*)cur->clone(); - } + arguments = ( ExpressionNode*)cur->clone(); + } // if cur = cur->get_link(); } @@ -333,11 +333,11 @@ std::list args; - buildList(get_args(), args); - - if ( ! ( op = dynamic_cast(function)) ) { + buildList( get_args(), args ); + + if ( ! ( op = dynamic_cast( function )) ) { // a function as opposed to an operator - return new UntypedExpr(function->build(), args, maybeBuild< Expression >( get_argName() )); + return new UntypedExpr( function->build(), args, maybeBuild< Expression >( get_argName() )); } else { - switch (op->get_type()){ + switch ( op->get_type()){ case OperatorNode::Incr: case OperatorNode::Decr: @@ -412,9 +412,9 @@ case OperatorNode::Cast: { - TypeValueNode * arg = dynamic_cast(get_args()); + TypeValueNode * arg = dynamic_cast( get_args()); assert( arg ); DeclarationNode *decl_node = arg->get_decl(); - ExpressionNode *expr_node = dynamic_cast(arg->get_link()); + ExpressionNode *expr_node = dynamic_cast( arg->get_link()); Type *targetType = decl_node->buildType(); @@ -423,6 +423,6 @@ return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) ); } else { - return new CastExpr(expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) ); - } + return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) ); + } // if } case OperatorNode::FieldSel: @@ -430,20 +430,18 @@ assert( args.size() == 2 ); - NameExpr *member = dynamic_cast(args.back()); - // TupleExpr *memberTup = dynamic_cast(args.back()); - - if ( member != 0 ) - { - UntypedMemberExpr *ret = new UntypedMemberExpr(member->get_name(), args.front()); - delete member; - return ret; - } + NameExpr *member = dynamic_cast( args.back()); + // TupleExpr *memberTup = dynamic_cast( args.back()); + + if ( member != 0 ) { + UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front()); + delete member; + return ret; /* else if ( memberTup != 0 ) { - UntypedMemberExpr *ret = new UntypedMemberExpr(memberTup->get_name(), args.front()); + UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front()); delete member; return ret; } */ - else + } else assert( false ); } @@ -452,5 +450,5 @@ assert( args.size() == 2 ); - NameExpr *member = dynamic_cast(args.back()); // modify for Tuples xxx + NameExpr *member = dynamic_cast( args.back()); // modify for Tuples xxx assert( member != 0 ); @@ -458,5 +456,5 @@ deref->get_args().push_back( args.front() ); - UntypedMemberExpr *ret = new UntypedMemberExpr(member->get_name(), deref); + UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref ); delete member; return ret; @@ -465,23 +463,23 @@ case OperatorNode::SizeOf: { -/// bool isSizeOf = (op->get_type() == OperatorNode::SizeOf); - - if ( TypeValueNode * arg = dynamic_cast(get_args()) ) { - return new SizeofExpr(arg->get_decl()->buildType()); +/// bool isSizeOf = ( op->get_type() == OperatorNode::SizeOf ); + + if ( TypeValueNode * arg = dynamic_cast( get_args()) ) { + return new SizeofExpr( arg->get_decl()->buildType()); } else { - return new SizeofExpr(args.front()); - } + return new SizeofExpr( args.front()); + } // if } case OperatorNode::Attr: { - VarRefNode *var = dynamic_cast(get_args()); + VarRefNode *var = dynamic_cast( get_args()); assert( var ); if ( !get_args()->get_link() ) { - return new AttrExpr(var->build(), (Expression*)0); - } else if ( TypeValueNode * arg = dynamic_cast(get_args()->get_link()) ) { - return new AttrExpr(var->build(), arg->get_decl()->buildType()); + return new AttrExpr( var->build(), ( Expression*)0); + } else if ( TypeValueNode * arg = dynamic_cast( get_args()->get_link()) ) { + return new AttrExpr( var->build(), arg->get_decl()->buildType()); } else { - return new AttrExpr(var->build(), args.back()); - } + return new AttrExpr( var->build(), args.back()); + } // if } case OperatorNode::CompLit: @@ -490,9 +488,9 @@ case OperatorNode::Or: case OperatorNode::And: - assert(args.size() == 2); - return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), (op->get_type() == OperatorNode::And) ); + assert( args.size() == 2); + return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), ( op->get_type() == OperatorNode::And ) ); case OperatorNode::Cond: { - assert(args.size() == 3); + assert( args.size() == 3); std::list< Expression* >::const_iterator i = args.begin(); Expression *arg1 = notZeroExpr( *i++ ); @@ -505,5 +503,5 @@ case OperatorNode::Comma: { - assert(args.size() == 2); + assert( args.size() == 2); std::list< Expression* >::const_iterator i = args.begin(); Expression *ret = *i++; @@ -527,9 +525,9 @@ } -void CompositeExprNode::printOneLine(std::ostream &os, int indent) const { - printDesignation(os); +void CompositeExprNode::printOneLine( std::ostream &os, int indent ) const { + printDesignation( os ); os << "( "; function->printOneLine( os, indent ); - for( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) { + for ( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) { cur->printOneLine( os, indent ); } @@ -537,50 +535,50 @@ } -void CompositeExprNode::print(std::ostream &os, int indent) const { - printDesignation(os); - os << '\r' << string(indent, ' ') << "Application of: " << endl; +void CompositeExprNode::print( std::ostream &os, int indent ) const { + printDesignation( os ); + os << '\r' << string( indent, ' ') << "Application of: " << endl; function->print( os, indent + ParseNode::indent_by ); - os << '\r' << string(indent, ' ') ; + os << '\r' << string( indent, ' ') ; if ( arguments ) { os << "... on arguments: " << endl; - arguments->printList(os, indent + ParseNode::indent_by); + arguments->printList( os, indent + ParseNode::indent_by ); } else os << "... on no arguments: " << endl; } -void CompositeExprNode::set_function(ExpressionNode *f){ +void CompositeExprNode::set_function( ExpressionNode *f ){ function = f; } -void CompositeExprNode::set_args(ExpressionNode *args){ +void CompositeExprNode::set_args( ExpressionNode *args ){ arguments = args; } -ExpressionNode *CompositeExprNode::get_function(void) const { +ExpressionNode *CompositeExprNode::get_function( void ) const { return function; } -ExpressionNode *CompositeExprNode::get_args(void) const { +ExpressionNode *CompositeExprNode::get_args( void ) const { return arguments; } -void CompositeExprNode::add_arg(ExpressionNode *arg){ - if (arguments) - arguments->set_link(arg); +void CompositeExprNode::add_arg( ExpressionNode *arg ){ + if ( arguments ) + arguments->set_link( arg ); else - set_args(arg); -} - -CommaExprNode::CommaExprNode(): CompositeExprNode(new OperatorNode(OperatorNode::Comma)) {} - -CommaExprNode::CommaExprNode(ExpressionNode *exp) : CompositeExprNode( new OperatorNode(OperatorNode::Comma), exp ) { -} - -CommaExprNode::CommaExprNode(ExpressionNode *exp1, ExpressionNode *exp2) : CompositeExprNode(new OperatorNode(OperatorNode::Comma), exp1, exp2) { -} - -CommaExprNode *CommaExprNode::add_to_list(ExpressionNode *exp){ - add_arg(exp); + set_args( arg ); +} + +CommaExprNode::CommaExprNode(): CompositeExprNode( new OperatorNode( OperatorNode::Comma )) {} + +CommaExprNode::CommaExprNode( ExpressionNode *exp ) : CompositeExprNode( new OperatorNode( OperatorNode::Comma ), exp ) { +} + +CommaExprNode::CommaExprNode( ExpressionNode *exp1, ExpressionNode *exp2) : CompositeExprNode( new OperatorNode( OperatorNode::Comma ), exp1, exp2) { +} + +CommaExprNode *CommaExprNode::add_to_list( ExpressionNode *exp ){ + add_arg( exp ); return this; @@ -590,5 +588,5 @@ } -ValofExprNode::ValofExprNode(StatementNode *s): body(s) {} +ValofExprNode::ValofExprNode( StatementNode *s ): body( s ) {} ValofExprNode::ValofExprNode( const ValofExprNode &other ) : ExpressionNode( other ), body( maybeClone( body ) ) { @@ -600,7 +598,7 @@ void ValofExprNode::print( std::ostream &os, int indent ) const { - printDesignation(os); - os << string(indent, ' ') << "Valof Expression:" << std::endl; - get_body()->print(os, indent + 4); + printDesignation( os ); + os << string( indent, ' ') << "Valof Expression:" << std::endl; + get_body()->print( os, indent + 4); } @@ -613,5 +611,5 @@ } -ForCtlExprNode::ForCtlExprNode(ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr) throw (SemanticError) : condition(cond), change(incr) { +ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) { if ( init_ == 0 ) init = 0; @@ -620,8 +618,8 @@ ExpressionNode *exp; - if ((decl = dynamic_cast(init_)) != 0) - init = new StatementNode(decl); - else if ((exp = dynamic_cast(init_)) != 0) - init = new StatementNode(StatementNode::Exp, exp); + if (( decl = dynamic_cast( init_)) != 0) + init = new StatementNode( decl ); + else if (( exp = dynamic_cast( init_)) != 0) + init = new StatementNode( StatementNode::Exp, exp ); else throw SemanticError("Error in for control expression"); @@ -646,16 +644,16 @@ void ForCtlExprNode::print( std::ostream &os, int indent ) const{ - os << string(indent,' ') << "For Control Expression -- : " << endl; - - os << "\r" << string(indent + 2,' ') << "initialization: "; - if (init != 0) - init->print(os, indent + 4); - - os << "\n\r" << string(indent + 2,' ') << "condition: "; - if (condition != 0) - condition->print(os, indent + 4); - os << "\n\r" << string(indent + 2,' ') << "increment: "; - if (change != 0) - change->print(os, indent + 4); + os << string( indent,' ') << "For Control Expression -- : " << endl; + + os << "\r" << string( indent + 2,' ') << "initialization: "; + if ( init != 0) + init->print( os, indent + 4); + + os << "\n\r" << string( indent + 2,' ') << "condition: "; + if ( condition != 0) + condition->print( os, indent + 4); + os << "\n\r" << string( indent + 2,' ') << "increment: "; + if ( change != 0) + change->print( os, indent + 4); } @@ -664,5 +662,5 @@ } -TypeValueNode::TypeValueNode(DeclarationNode *decl) +TypeValueNode::TypeValueNode( DeclarationNode *decl ) : decl( decl ) { } @@ -676,12 +674,12 @@ } -void TypeValueNode::print(std::ostream &os, int indent) const { +void TypeValueNode::print( std::ostream &os, int indent ) const { os << std::string( indent, ' ' ) << "Type:"; - get_decl()->print(os, indent + 2); -} - -void TypeValueNode::printOneLine(std::ostream &os, int indent) const { + get_decl()->print( os, indent + 2); +} + +void TypeValueNode::printOneLine( std::ostream &os, int indent ) const { os << "Type:"; - get_decl()->print(os, indent + 2); + get_decl()->print( os, indent + 2); } @@ -690,5 +688,5 @@ { OperatorNode *op; - if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::Comma) ) + if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) ) { if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) ) @@ -707,5 +705,5 @@ if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) { OperatorNode *op = 0; - if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::TupleC) ) + if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::TupleC ) ) return composite->get_args(); } Index: translator/Parser/InitializerNode.cc =================================================================== --- translator/Parser/InitializerNode.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/Parser/InitializerNode.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -1,12 +1,9 @@ +#include +#include +using namespace std; + #include "ParseNode.h" #include "SynTree/Expression.h" #include "SynTree/Initializer.h" -#include "utility.h" -#include "SemanticError.h" -// #include // for strtol -#include - -#include -using namespace std; InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des ) Index: translator/Parser/ParseNode.cc =================================================================== --- translator/Parser/ParseNode.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/Parser/ParseNode.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -73,9 +73,9 @@ } -ParseNode *mkList(ParseNode &pn){ +ParseNode *mkList( ParseNode &pn ) { /* it just relies on `operator,' to take care of the "arguments" and provides a nice interface to an awful-looking address-of, rendering, for example (StatementNode *)(&(*$5 + *$7)) into (StatementNode *)mkList(($5, $7)) - (although "nice" is probably not the word) + (although "nice" is probably not the word) */ return &pn; Index: translator/Parser/ParseNode.h =================================================================== --- translator/Parser/ParseNode.h (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/Parser/ParseNode.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -2,5 +2,4 @@ #define PARSENODE_H -#include #include #include @@ -8,7 +7,5 @@ #include "utility.h" -#include "SynTree/SynTree.h" #include "SynTree/Declaration.h" -#include "SemanticError.h" #include "UniqueName.h" @@ -23,452 +20,440 @@ // Builder class ParseNode { -public: - ParseNode(void); - ParseNode (std::string); - virtual ~ParseNode(void); - - ParseNode *set_name (std::string) ; - ParseNode *set_name (std::string *) ; - - std::string get_name(void); - - ParseNode *get_link(void) const; - ParseNode *get_last(void); - ParseNode *set_link(ParseNode *); - void set_next( ParseNode *newlink ) { next = newlink; } - - virtual ParseNode *clone() const { return 0; }; - - const std::string get_name(void) const; - virtual void print( std::ostream &, int indent = 0 ) const; - virtual void printList( std::ostream &, int indent = 0 ) const; - - ParseNode &operator,(ParseNode &); - -protected: - std::string name; - ParseNode *next; - static int indent_by; -}; - -ParseNode *mkList(ParseNode &); + public: + ParseNode( void ); + ParseNode ( std::string ); + virtual ~ParseNode( void ); + + ParseNode *set_name ( std::string ) ; + ParseNode *set_name ( std::string * ) ; + + std::string get_name( void ); + + ParseNode *get_link( void ) const; + ParseNode *get_last( void ); + ParseNode *set_link( ParseNode * ); + void set_next( ParseNode *newlink ) { next = newlink; } + + virtual ParseNode *clone() const { return 0; }; + + const std::string get_name( void ) const; + virtual void print( std::ostream &, int indent = 0 ) const; + virtual void printList( std::ostream &, int indent = 0 ) const; + + ParseNode &operator,( ParseNode &); + protected: + std::string name; + ParseNode *next; + static int indent_by; +}; + +ParseNode *mkList( ParseNode & ); class ExpressionNode : public ParseNode { -public: - ExpressionNode(); - ExpressionNode(std::string *); - ExpressionNode( const ExpressionNode &other ); - virtual ~ExpressionNode() { /* can't delete asArgName because it might be referenced elsewhere */ }; - - virtual ExpressionNode *clone() const = 0; - - virtual CommaExprNode *add_to_list(ExpressionNode *); - - ExpressionNode *get_argName() const { return argName; } - ExpressionNode *set_asArgName( std::string *aName ); - ExpressionNode *set_asArgName( ExpressionNode *aDesignator ); - - virtual void print(std::ostream &, int indent = 0) const = 0; - virtual void printOneLine(std::ostream &, int indent = 0) const = 0; - - virtual Expression *build() const = 0; -protected: - void printDesignation (std::ostream &, int indent = 0) const; - -private: - ExpressionNode *argName; -}; - -// NullExprNode is used in tuples as a place-holder where a tuple component is omitted -// e.g., [ 2, , 3 ] -class NullExprNode : public ExpressionNode -{ -public: - NullExprNode(); - - virtual NullExprNode *clone() const; - - virtual void print(std::ostream &, int indent = 0) const; - virtual void printOneLine(std::ostream &, int indent = 0) const; - - virtual Expression *build() const; + public: + ExpressionNode(); + ExpressionNode( std::string * ); + ExpressionNode( const ExpressionNode &other ); + virtual ~ExpressionNode() { /* can't delete asArgName because it might be referenced elsewhere */ }; + + virtual ExpressionNode *clone() const = 0; + + virtual CommaExprNode *add_to_list( ExpressionNode * ); + + ExpressionNode *get_argName() const { return argName; } + ExpressionNode *set_asArgName( std::string *aName ); + ExpressionNode *set_asArgName( ExpressionNode *aDesignator ); + + virtual void print( std::ostream &, int indent = 0) const = 0; + virtual void printOneLine( std::ostream &, int indent = 0) const = 0; + + virtual Expression *build() const = 0; + protected: + void printDesignation ( std::ostream &, int indent = 0) const; + private: + ExpressionNode *argName; +}; + +// NullExprNode is used in tuples as a place-holder where a tuple component is omitted e.g., [ 2, , 3 ] +class NullExprNode : public ExpressionNode { + public: + NullExprNode(); + + virtual NullExprNode *clone() const; + + virtual void print( std::ostream &, int indent = 0) const; + virtual void printOneLine( std::ostream &, int indent = 0) const; + + virtual Expression *build() const; }; class ConstantNode : public ExpressionNode { -public: - enum Type { - Integer, Float, Character, String /* , Range, EnumConstant */ - }; - - ConstantNode(void); - ConstantNode(std::string *); - ConstantNode(Type, std::string *); - ConstantNode( const ConstantNode &other ); - - virtual ConstantNode *clone() const { return new ConstantNode( *this ); } - - Type get_type(void) const ; - virtual void print(std::ostream &, int indent = 0) const; - virtual void printOneLine(std::ostream &, int indent = 0) const; - - std::string get_value() const { return value; } - ConstantNode *append( std::string *newValue ); - - Expression *build() const; - -private: - void classify(std::string &); - Type type; - std::string value; - bool sign; - short base; - int longs, size; + public: + enum Type { + Integer, Float, Character, String /* , Range, EnumConstant */ + }; + + ConstantNode( void ); + ConstantNode( std::string * ); + ConstantNode( Type, std::string * ); + ConstantNode( const ConstantNode &other ); + + virtual ConstantNode *clone() const { return new ConstantNode( *this ); } + + Type get_type( void ) const ; + virtual void print( std::ostream &, int indent = 0) const; + virtual void printOneLine( std::ostream &, int indent = 0) const; + + std::string get_value() const { return value; } + ConstantNode *append( std::string *newValue ); + + Expression *build() const; + private: + void classify( std::string &); + Type type; + std::string value; + bool sign; + short base; + int longs, size; }; class VarRefNode : public ExpressionNode { -public: - VarRefNode(); - VarRefNode(std::string *, bool isLabel = false ); - VarRefNode( const VarRefNode &other ); - - virtual Expression *build() const ; - - virtual VarRefNode *clone() const { return new VarRefNode( *this ); } - - virtual void print(std::ostream &, int indent = 0) const; - virtual void printOneLine(std::ostream &, int indent = 0) const; -private: - bool isLabel; -}; - -class TypeValueNode : public ExpressionNode -{ -public: - TypeValueNode(DeclarationNode *); - TypeValueNode( const TypeValueNode &other ); - - DeclarationNode *get_decl() const { return decl; } - - virtual Expression *build() const ; - - virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); } - - virtual void print(std::ostream &, int indent = 0) const; - virtual void printOneLine(std::ostream &, int indent = 0) const; -private: - DeclarationNode *decl; + public: + VarRefNode(); + VarRefNode( std::string *, bool isLabel = false ); + VarRefNode( const VarRefNode &other ); + + virtual Expression *build() const ; + + virtual VarRefNode *clone() const { return new VarRefNode( *this ); } + + virtual void print( std::ostream &, int indent = 0) const; + virtual void printOneLine( std::ostream &, int indent = 0) const; + private: + bool isLabel; +}; + +class TypeValueNode : public ExpressionNode { + public: + TypeValueNode( DeclarationNode * ); + TypeValueNode( const TypeValueNode &other ); + + DeclarationNode *get_decl() const { return decl; } + + virtual Expression *build() const ; + + virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); } + + virtual void print( std::ostream &, int indent = 0) const; + virtual void printOneLine( std::ostream &, int indent = 0) const; + private: + DeclarationNode *decl; }; class OperatorNode : public ExpressionNode { -public: - enum Type { TupleC, Comma, TupleFieldSel, - Cond, NCond, - SizeOf, AlignOf, Attr, CompLit, Plus, Minus, Mul, Div, Mod, Or, And, + public: + enum Type { TupleC, Comma, TupleFieldSel, + Cond, NCond, + SizeOf, AlignOf, Attr, CompLit, Plus, Minus, Mul, Div, Mod, Or, And, BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq, Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn, Index, FieldSel, PFieldSel, Range, - UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress - }; - - OperatorNode(Type t); - OperatorNode( const OperatorNode &other ); - virtual ~OperatorNode(); - - virtual OperatorNode *clone() const { return new OperatorNode( *this ); } - - Type get_type(void) const; - std::string get_typename(void) const; - - virtual void print(std::ostream &, int indent = 0) const; - virtual void printOneLine(std::ostream &, int indent = 0) const; - - virtual Expression *build() const { return 0; } + UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress + }; + + OperatorNode( Type t ); + OperatorNode( const OperatorNode &other ); + virtual ~OperatorNode(); + + virtual OperatorNode *clone() const { return new OperatorNode( *this ); } + + Type get_type( void ) const; + std::string get_typename( void ) const; + + virtual void print( std::ostream &, int indent = 0) const; + virtual void printOneLine( std::ostream &, int indent = 0) const; + + virtual Expression *build() const { return 0; } + private: + Type type; + static const char *OpName[]; +}; + + +class CompositeExprNode : public ExpressionNode { + public: + CompositeExprNode( void ); + CompositeExprNode( std::string * ); + CompositeExprNode( ExpressionNode *f, ExpressionNode *args = 0 ); + CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 ); + CompositeExprNode( const CompositeExprNode &other ); + virtual ~CompositeExprNode(); + + virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); } + virtual Expression *build() const; + + virtual void print( std::ostream &, int indent = 0) const; + virtual void printOneLine( std::ostream &, int indent = 0) const; + + void set_function( ExpressionNode * ); + void set_args( ExpressionNode * ); + + void add_arg( ExpressionNode * ); + + ExpressionNode *get_function() const; + ExpressionNode *get_args() const; + private: + ExpressionNode *function; + ExpressionNode *arguments; +}; + +class CommaExprNode : public CompositeExprNode { + public: + CommaExprNode(); + CommaExprNode( ExpressionNode * ); + CommaExprNode( ExpressionNode *, ExpressionNode * ); + CommaExprNode( const CommaExprNode &other ); + + virtual CommaExprNode *add_to_list( ExpressionNode * ); + virtual CommaExprNode *clone() const { return new CommaExprNode( *this ); } +}; + +class ForCtlExprNode : public ExpressionNode { + public: + ForCtlExprNode( ParseNode *, ExpressionNode *, ExpressionNode * ) throw ( SemanticError ); + ForCtlExprNode( const ForCtlExprNode &other ); + ~ForCtlExprNode(); + + StatementNode *get_init() const { return init; } + ExpressionNode *get_condition() const { return condition; } + ExpressionNode *get_change() const { return change; } + + virtual ForCtlExprNode *clone() const { return new ForCtlExprNode( *this ); } + virtual Expression *build() const; + + virtual void print( std::ostream &, int indent = 0 ) const; + virtual void printOneLine( std::ostream &, int indent = 0 ) const; + private: + StatementNode *init; + ExpressionNode *condition; + ExpressionNode *change; +}; + +class ValofExprNode : public ExpressionNode { + public: + ValofExprNode(); + ValofExprNode( StatementNode *s = 0 ); + ValofExprNode( const ValofExprNode &other ); + ~ValofExprNode(); -private: - Type type; - static const char *OpName[]; -}; - - -class CompositeExprNode : public ExpressionNode { -public: - CompositeExprNode(void); - CompositeExprNode(std::string *); - CompositeExprNode(ExpressionNode *f, ExpressionNode *args = 0); - CompositeExprNode(ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2); - CompositeExprNode( const CompositeExprNode &other ); - virtual ~CompositeExprNode(); - - virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); } - virtual Expression *build() const; - - virtual void print(std::ostream &, int indent = 0) const; - virtual void printOneLine(std::ostream &, int indent = 0) const; - - void set_function(ExpressionNode *); - void set_args(ExpressionNode *); - - void add_arg(ExpressionNode *); - - ExpressionNode *get_function() const; - ExpressionNode *get_args() const; - -private: - ExpressionNode *function; - ExpressionNode *arguments; -}; - -class CommaExprNode : public CompositeExprNode { -public: - CommaExprNode(); - CommaExprNode(ExpressionNode *); - CommaExprNode(ExpressionNode *, ExpressionNode *); - CommaExprNode( const CommaExprNode &other ); - - virtual CommaExprNode *add_to_list(ExpressionNode *); - virtual CommaExprNode *clone() const { return new CommaExprNode( *this ); } -}; - -class ForCtlExprNode : public ExpressionNode { -public: - ForCtlExprNode(ParseNode *, ExpressionNode *, ExpressionNode *) throw (SemanticError); - ForCtlExprNode( const ForCtlExprNode &other ); - ~ForCtlExprNode(); - - StatementNode *get_init() const { return init; } - ExpressionNode *get_condition() const { return condition; } - ExpressionNode *get_change() const { return change; } - - virtual ForCtlExprNode *clone() const { return new ForCtlExprNode( *this ); } - virtual Expression *build() const; - - virtual void print( std::ostream &, int indent = 0 ) const; - virtual void printOneLine( std::ostream &, int indent = 0 ) const; -private: - StatementNode *init; - ExpressionNode *condition; - ExpressionNode *change; -}; - -class ValofExprNode : public ExpressionNode { -public: - ValofExprNode(); - ValofExprNode( StatementNode *s = 0 ); - ValofExprNode( const ValofExprNode &other ); - ~ValofExprNode(); - - virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); } - - StatementNode *get_body() const { return body; } - void print( std::ostream &, int indent = 0 ) const; - void printOneLine( std::ostream &, int indent = 0 ) const; - Expression *build() const; - -private: - StatementNode *body; + virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); } + + StatementNode *get_body() const { return body; } + void print( std::ostream &, int indent = 0 ) const; + void printOneLine( std::ostream &, int indent = 0 ) const; + Expression *build() const; + + private: + StatementNode *body; }; class TypeData; -class DeclarationNode : public ParseNode -{ -public: - enum Qualifier { Const, Restrict, Volatile, Lvalue }; - enum StorageClass { Static, Auto, Extern, Register, Inline, Fortran }; - enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary }; - enum Modifier { Signed, Unsigned, Short, Long }; - enum TyCon { Struct, Union, Context }; - enum TypeClass { Type, Dtype, Ftype }; - - static const char *qualifierName[]; - static const char *basicTypeName[]; - static const char *modifierName[]; - static const char *tyConName[]; - static const char *typeClassName[]; - - static DeclarationNode *newFunction( std::string* name, DeclarationNode *ret, DeclarationNode *param, - StatementNode *body, bool newStyle = false ); - static DeclarationNode *newQualifier( Qualifier ); - static DeclarationNode *newStorageClass( StorageClass ); - static DeclarationNode *newBasicType( BasicType ); - static DeclarationNode *newModifier( Modifier ); - static DeclarationNode *newForall( DeclarationNode* ); - static DeclarationNode *newFromTypedef( std::string* ); - static DeclarationNode *newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ); - static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants ); - static DeclarationNode *newEnumConstant( std::string* name, ExpressionNode *constant ); - static DeclarationNode *newName( std::string* ); - static DeclarationNode *newFromTypeGen( std::string*, ExpressionNode *params ); - static DeclarationNode *newTypeParam( TypeClass, std::string* ); - static DeclarationNode *newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts ); - static DeclarationNode *newContextUse( std::string *name, ExpressionNode *params ); - static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams ); - static DeclarationNode *newPointer( DeclarationNode *qualifiers ); - static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ); - static DeclarationNode *newVarArray( DeclarationNode *qualifiers ); - static DeclarationNode *newBitfield( ExpressionNode *size ); - static DeclarationNode *newTuple( DeclarationNode *members ); - static DeclarationNode *newTypeof( ExpressionNode *expr ); - static DeclarationNode *newAttr( std::string*, ExpressionNode *expr ); - static DeclarationNode *newAttr( std::string*, DeclarationNode *type ); - - DeclarationNode *addQualifiers( DeclarationNode* ); - DeclarationNode *copyStorageClasses( DeclarationNode* ); - DeclarationNode *addType( DeclarationNode* ); - DeclarationNode *addTypedef(); - DeclarationNode *addAssertions( DeclarationNode* ); - DeclarationNode *addName( std::string* ); - DeclarationNode *addBitfield( ExpressionNode *size ); - DeclarationNode *addVarArgs(); - DeclarationNode *addFunctionBody( StatementNode *body ); - DeclarationNode *addOldDeclList( DeclarationNode *list ); - DeclarationNode *addPointer( DeclarationNode *qualifiers ); - DeclarationNode *addArray( DeclarationNode *array ); - DeclarationNode *addNewPointer( DeclarationNode *pointer ); - DeclarationNode *addNewArray( DeclarationNode *array ); - DeclarationNode *addParamList( DeclarationNode *list ); - DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions - DeclarationNode *addInitializer( InitializerNode *init ); - - DeclarationNode *cloneType( std::string *newName ); - DeclarationNode *cloneType( DeclarationNode *existing ); - DeclarationNode *cloneType( int ) { return cloneType( (std::string*)0 ); } - DeclarationNode *cloneBaseType( std::string *newName ); - DeclarationNode *cloneBaseType( DeclarationNode *newdecl ); - - DeclarationNode *appendList( DeclarationNode * ); - - DeclarationNode *clone() const; - void print( std::ostream &, int indent = 0 ) const; - void printList( std::ostream &, int indent = 0 ) const; - - Declaration *build() const; - ::Type *buildType() const; - - bool get_hasEllipsis() const; - std::string get_name() const { return name; } - LinkageSpec::Type get_linkage() const { return linkage; } - DeclarationNode *extractAggregate() const; - - DeclarationNode(); - ~DeclarationNode(); -private: - Declaration::StorageClass buildStorageClass() const; - bool buildInline() const; - - TypeData *type; - std::string name; - std::list< StorageClass > storageClasses; - ExpressionNode *bitfieldWidth; - InitializerNode *initializer; - bool hasEllipsis; - LinkageSpec::Type linkage; - - static UniqueName anonymous; +class DeclarationNode : public ParseNode { + public: + enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic }; + enum StorageClass { Static, Auto, Extern, Register, Inline, Fortran }; + enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary }; + enum Modifier { Signed, Unsigned, Short, Long }; + enum TyCon { Struct, Union, Context }; + enum TypeClass { Type, Dtype, Ftype }; + + static const char *qualifierName[]; + static const char *basicTypeName[]; + static const char *modifierName[]; + static const char *tyConName[]; + static const char *typeClassName[]; + + static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, + StatementNode *body, bool newStyle = false ); + static DeclarationNode *newQualifier( Qualifier ); + static DeclarationNode *newStorageClass( StorageClass ); + static DeclarationNode *newBasicType( BasicType ); + static DeclarationNode *newModifier( Modifier ); + static DeclarationNode *newForall( DeclarationNode *); + static DeclarationNode *newFromTypedef( std::string *); + static DeclarationNode *newAggregate( TyCon kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ); + static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants ); + static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant ); + static DeclarationNode *newName( std::string *); + static DeclarationNode *newFromTypeGen( std::string*, ExpressionNode *params ); + static DeclarationNode *newTypeParam( TypeClass, std::string *); + static DeclarationNode *newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts ); + static DeclarationNode *newContextUse( std::string *name, ExpressionNode *params ); + static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams ); + static DeclarationNode *newPointer( DeclarationNode *qualifiers ); + static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ); + static DeclarationNode *newVarArray( DeclarationNode *qualifiers ); + static DeclarationNode *newBitfield( ExpressionNode *size ); + static DeclarationNode *newTuple( DeclarationNode *members ); + static DeclarationNode *newTypeof( ExpressionNode *expr ); + static DeclarationNode *newAttr( std::string*, ExpressionNode *expr ); + static DeclarationNode *newAttr( std::string*, DeclarationNode *type ); + + DeclarationNode *addQualifiers( DeclarationNode *); + DeclarationNode *copyStorageClasses( DeclarationNode *); + DeclarationNode *addType( DeclarationNode *); + DeclarationNode *addTypedef(); + DeclarationNode *addAssertions( DeclarationNode *); + DeclarationNode *addName( std::string *); + DeclarationNode *addBitfield( ExpressionNode *size ); + DeclarationNode *addVarArgs(); + DeclarationNode *addFunctionBody( StatementNode *body ); + DeclarationNode *addOldDeclList( DeclarationNode *list ); + DeclarationNode *addPointer( DeclarationNode *qualifiers ); + DeclarationNode *addArray( DeclarationNode *array ); + DeclarationNode *addNewPointer( DeclarationNode *pointer ); + DeclarationNode *addNewArray( DeclarationNode *array ); + DeclarationNode *addParamList( DeclarationNode *list ); + DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions + DeclarationNode *addInitializer( InitializerNode *init ); + + DeclarationNode *cloneType( std::string *newName ); + DeclarationNode *cloneType( DeclarationNode *existing ); + DeclarationNode *cloneType( int ) { return cloneType( ( std::string *)0 ); } + DeclarationNode *cloneBaseType( std::string *newName ); + DeclarationNode *cloneBaseType( DeclarationNode *newdecl ); + + DeclarationNode *appendList( DeclarationNode *); + + DeclarationNode *clone() const; + void print( std::ostream &, int indent = 0 ) const; + void printList( std::ostream &, int indent = 0 ) const; + + Declaration *build() const; + ::Type *buildType() const; + + bool get_hasEllipsis() const; + std::string get_name() const { return name; } + LinkageSpec::Type get_linkage() const { return linkage; } + DeclarationNode *extractAggregate() const; + + DeclarationNode(); + ~DeclarationNode(); + private: + Declaration::StorageClass buildStorageClass() const; + bool buildInline() const; + + TypeData *type; + std::string name; + std::list< StorageClass > storageClasses; + ExpressionNode *bitfieldWidth; + InitializerNode *initializer; + bool hasEllipsis; + LinkageSpec::Type linkage; + + static UniqueName anonymous; }; class StatementNode : public ParseNode { -public: - enum Type { Exp, If, Switch, Case, Default, Choose, Fallthru, - While, Do, For, - Goto, Continue, Break, Return, Throw, - Try, Catch, Finally, Asm, - Decl - }; - - StatementNode( void ); - StatementNode( std::string ); - StatementNode( Type, ExpressionNode *e = 0, StatementNode *s = 0 ); - StatementNode( Type, std::string *target ); - StatementNode( DeclarationNode *decl ); - - - ~StatementNode(void); - - static StatementNode * newCatchStmt(DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false ); - - void set_control(ExpressionNode *); - StatementNode * set_block(StatementNode *); - - ExpressionNode *get_control() const ; - StatementNode *get_block() const; - StatementNode::Type get_type(void) const; - - StatementNode *add_label(std::string *); - std::list *get_labels() const; - - void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; } - void setCatchRest( bool newVal ) { isCatchRest = newVal; } - - std::string get_target() const; - - StatementNode *add_controlexp(ExpressionNode *); - StatementNode *append_block(StatementNode *); - StatementNode *append_last_case(StatementNode *); - - void print( std::ostream &, int indent = 0) const; - - virtual StatementNode *clone() const; - - virtual Statement *build() const; - -private: - static const char *StType[]; - Type type; - ExpressionNode *control; - StatementNode *block; - std::list *labels; - std::string *target; // target label for jump statements - DeclarationNode *decl; - - bool isCatchRest; + public: + enum Type { Exp, If, Switch, Case, Default, Choose, Fallthru, + While, Do, For, + Goto, Continue, Break, Return, Throw, + Try, Catch, Finally, Asm, + Decl + }; + + StatementNode( void ); + StatementNode( std::string ); + StatementNode( Type, ExpressionNode *e = 0, StatementNode *s = 0 ); + StatementNode( Type, std::string *target ); + StatementNode( DeclarationNode *decl ); + + + ~StatementNode( void ); + + static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false ); + + void set_control( ExpressionNode * ); + StatementNode * set_block( StatementNode * ); + + ExpressionNode *get_control() const ; + StatementNode *get_block() const; + StatementNode::Type get_type( void ) const; + + StatementNode *add_label( std::string * ); + std::list *get_labels() const; + + void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; } + void setCatchRest( bool newVal ) { isCatchRest = newVal; } + + std::string get_target() const; + + StatementNode *add_controlexp( ExpressionNode * ); + StatementNode *append_block( StatementNode * ); + StatementNode *append_last_case( StatementNode * ); + + void print( std::ostream &, int indent = 0) const; + + virtual StatementNode *clone() const; + + virtual Statement *build() const; + private: + static const char *StType[]; + Type type; + ExpressionNode *control; + StatementNode *block; + std::list *labels; + std::string *target; // target label for jump statements + DeclarationNode *decl; + + bool isCatchRest; }; class CompoundStmtNode : public StatementNode { -public: - CompoundStmtNode(void); - CompoundStmtNode(std::string *); - CompoundStmtNode(StatementNode *); - ~CompoundStmtNode(); - - void add_statement(StatementNode *); - - void print( std::ostream &, int indent = 0 ) const; - - virtual Statement *build() const; - -private: - StatementNode *first, *last; + public: + CompoundStmtNode( void ); + CompoundStmtNode( std::string * ); + CompoundStmtNode( StatementNode * ); + ~CompoundStmtNode(); + + void add_statement( StatementNode * ); + + void print( std::ostream &, int indent = 0 ) const; + + virtual Statement *build() const; + private: + StatementNode *first, *last; }; class NullStmtNode : public CompoundStmtNode { -public: - Statement *build() const; - void print(std::ostream &, int indent = 0) const; + public: + Statement *build() const; + void print( std::ostream &, int indent = 0) const; }; class InitializerNode : public ParseNode { -public: - InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode *des = 0 ); - InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 ); - ~InitializerNode(); - - ExpressionNode *get_expression() const { return expr; } - - InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; } - ExpressionNode *get_designators() const { return designator; } - - InitializerNode *next_init() const { return kids; } - - void print( std::ostream &, int indent = 0 ) const; - void printOneLine( std::ostream & ) const; - - virtual Initializer *build() const; - -private: - ExpressionNode *expr; - bool aggregate; - ExpressionNode *designator; // may be list - InitializerNode *kids; + public: + InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode *des = 0 ); + InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 ); + ~InitializerNode(); + + ExpressionNode *get_expression() const { return expr; } + + InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; } + ExpressionNode *get_designators() const { return designator; } + + InitializerNode *next_init() const { return kids; } + + void print( std::ostream &, int indent = 0 ) const; + void printOneLine( std::ostream & ) const; + + virtual Initializer *build() const; + private: + ExpressionNode *expr; + bool aggregate; + ExpressionNode *designator; // may be list + InitializerNode *kids; }; @@ -477,31 +462,31 @@ template< typename SynTreeType, typename NodeType > void -buildList( const NodeType *firstNode, std::list< SynTreeType* > &outputList ) +buildList( const NodeType *firstNode, std::list< SynTreeType *> &outputList ) { - SemanticError errors; - std::back_insert_iterator< std::list< SynTreeType* > > out( outputList ); - const NodeType *cur = firstNode; - - while( cur ) { - try { - SynTreeType *result = dynamic_cast< SynTreeType* >( cur->build() ); - if( result ) { - *out++ = result; - } else { - } - } catch( SemanticError &e ) { - errors.append( e ); - } - cur = dynamic_cast< NodeType* >( cur->get_link() ); - } - if( !errors.isEmpty() ) { - throw errors; - } + SemanticError errors; + std::back_insert_iterator< std::list< SynTreeType *> > out( outputList ); + const NodeType *cur = firstNode; + + while ( cur ) { + try { + SynTreeType *result = dynamic_cast< SynTreeType *>( cur->build() ); + if ( result ) { + *out++ = result; + } else { + } // if + } catch( SemanticError &e ) { + errors.append( e ); + } // try + cur = dynamic_cast< NodeType *>( cur->get_link() ); + } // while + if ( !errors.isEmpty() ) { + throw errors; + } // if } // in DeclarationNode.cc -void buildList( const DeclarationNode *firstNode, std::list< Declaration* > &outputList ); -void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType* > &outputList ); -void buildTypeList( const DeclarationNode *firstNode, std::list< Type* > &outputList ); +void buildList( const DeclarationNode *firstNode, std::list< Declaration *> &outputList ); +void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList ); +void buildTypeList( const DeclarationNode *firstNode, std::list< Type *> &outputList ); // in ExpressionNode.cc @@ -509,5 +494,5 @@ ExpressionNode *tupleContents( ExpressionNode *tuple ); -#endif /* #ifndef PARSENODE_H */ +#endif // PARSENODE_H // Local Variables: // Index: translator/Parser/TypeData.cc =================================================================== --- translator/Parser/TypeData.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/Parser/TypeData.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -541,4 +541,7 @@ case DeclarationNode::Lvalue: q.isLvalue = true; + break; + case DeclarationNode::Atomic: + q.isAtomic = true; break; } Index: translator/Parser/TypeData.h =================================================================== --- translator/Parser/TypeData.h (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/Parser/TypeData.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -3,10 +3,7 @@ #include + #include "ParseNode.h" -#include "SynTree/SynTree.h" #include "SynTree/Type.h" -#include "SynTree/Declaration.h" -#include "SemanticError.h" -#include "LinkageSpec.h" struct TypeData { Index: translator/Parser/cfa.y =================================================================== --- translator/Parser/cfa.y (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/Parser/cfa.y (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -10,6 +10,6 @@ * Created On : Sat Sep 1 20:22:55 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Sat Jan 17 09:23:45 2015 - * Update Count : 908 + * Last Modified On : Wed Apr 15 15:11:16 2015 + * Update Count : 913 */ @@ -1144,5 +1144,5 @@ declaration_specifier declarator asm_name_opt initializer_opt { - typedefTable.addToEnclosingScope( TypedefTable::ID); + typedefTable.addToEnclosingScope( TypedefTable::ID ); $$ = ($2->addType( $1 ))->addInitializer($4); } @@ -1201,4 +1201,6 @@ | LVALUE /* CFA */ { $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); } + | ATOMIC + { $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); } | FORALL '(' { Index: translator/Parser/parseutility.cc =================================================================== --- translator/Parser/parseutility.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/Parser/parseutility.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -1,9 +1,2 @@ -/* - * This file is part of the Cforall project - * - * $Id: parseutility.cc,v 1.2 2005/08/29 20:14:15 rcbilson Exp $ - * - */ - #include "parseutility.h" #include "SynTree/Type.h" @@ -11,7 +4,5 @@ -Expression * -notZeroExpr( Expression *orig ) -{ +Expression *notZeroExpr( Expression *orig ) { UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) ); comparison->get_args().push_back( orig ); Index: translator/Parser/parseutility.h =================================================================== --- translator/Parser/parseutility.h (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/Parser/parseutility.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -1,9 +1,2 @@ -/* - * This file is part of the Cforall project - * - * $Id: parseutility.h,v 1.2 2005/08/29 20:14:15 rcbilson Exp $ - * - */ - #ifndef PARSER_PARSEUTILITY_H #define PARSER_PARSEUTILITY_H @@ -13,3 +6,3 @@ Expression *notZeroExpr( Expression *orig ); -#endif /* #ifndef PARSER_PARSEUTILITY_H */ +#endif // PARSER_PARSEUTILITY_H Index: translator/ResolvExpr/AlternativeFinder.cc =================================================================== --- translator/ResolvExpr/AlternativeFinder.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/ResolvExpr/AlternativeFinder.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -756,10 +756,15 @@ alternatives.push_back( Alternative( sizeofExpr->clone(), env, Cost::zero ) ); } else { + // find all alternatives for the argument to sizeof AlternativeFinder finder( indexer, env ); finder.find( sizeofExpr->get_expr() ); - if ( finder.alternatives.size() != 1 ) { + // find the lowest cost alternative among the alternatives, otherwise ambiguous + AltList winners; + findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) ); + if ( winners.size() != 1 ) { throw SemanticError( "Ambiguous expression in sizeof operand: ", sizeofExpr->get_expr() ); } - Alternative &choice = finder.alternatives.front(); + // return the lowest cost alternative for the argument + Alternative &choice = winners.front(); alternatives.push_back( Alternative( new SizeofExpr( choice.expr->clone() ), choice.env, Cost::zero ) ); } Index: translator/ResolvExpr/Resolver.cc =================================================================== --- translator/ResolvExpr/Resolver.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/ResolvExpr/Resolver.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -44,4 +44,5 @@ acceptAll( translationUnit, resolver ); #if 0 + resolver.print( cerr ); for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) { (*i)->print( std::cerr ); @@ -241,4 +242,22 @@ void Resolver::visit( SingleInit *singleInit ) { if ( singleInit->get_value() ) { +#if 0 + if (NameExpr * ne = dynamic_cast(singleInit->get_value())) { + string n = ne->get_name(); + if (n == "0") { + initContext = new BasicType(Type::Qualifiers(), + BasicType::SignedInt); + } else { + DeclarationWithType * decl = lookupId(n); + initContext = decl->get_type(); + } + } else if (ConstantExpr * e = + dynamic_cast(singleInit->get_value())) { + Constant *c = e->get_constant(); + initContext = c->get_type(); + } else { + assert(0); + } +#endif CastExpr *castExpr = new CastExpr( singleInit->get_value(), initContext->clone() ); Expression *newExpr = findSingleExpression( castExpr, *this ); @@ -250,7 +269,12 @@ void Resolver::visit( ListInit *listInit ) { + Visitor::visit(listInit); +#if 0 if ( ArrayType *at = dynamic_cast(initContext) ) { - initContext = at->get_base(); - Visitor::visit( listInit ); + std::list::iterator iter( listInit->begin_initializers() ); + for ( ; iter != listInit->end_initializers(); ++iter ) { + initContext = at->get_base(); + (*iter)->accept( *this ); + } // for } else if ( StructInstType *st = dynamic_cast(initContext) ) { StructDecl *baseStruct = st->get_baseStruct(); @@ -295,4 +319,5 @@ (*listInit->begin_initializers())->accept( *this ); } // if +#endif } } // namespace ResolvExpr Index: translator/SymTab/IdTable.cc =================================================================== --- translator/SymTab/IdTable.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SymTab/IdTable.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -82,7 +82,13 @@ } } - for( InnerTableType::const_iterator i = declTable.begin(); i != declTable.end(); ++i ) { + // ensure the set of routines with C linkage cannot be overloaded + for( InnerTableType::iterator i = declTable.begin(); i != declTable.end(); ++i ) { if( !i->second.empty() && i->second.top().first->get_linkage() == LinkageSpec::C && declTable.size() > 1 ) { - throw SemanticError( "invalid overload of C function ", i->second.top().first ); + InnerTableType::iterator j = i; + for( j++; j != declTable.end(); ++j ) { + if( !j->second.empty() && j->second.top().first->get_linkage() == LinkageSpec::C ) { + throw SemanticError( "invalid overload of C function " ); + } + } } } @@ -103,7 +109,46 @@ } +DeclarationWithType* IdTable::lookupId( const std::string &id) const { + DeclarationWithType* result = 0; + int depth = -1; + + OuterTableType::const_iterator outer = table.find( id ); + if( outer == table.end() ) return 0; + const InnerTableType &declTable = outer->second; + for( InnerTableType::const_iterator it = declTable.begin(); it != declTable.end(); ++it ) { + const std::stack< DeclEntry >& entry = it->second; + if( !entry.empty() && entry.top().second > depth ) { + result = entry.top().first; + depth = entry.top().second; + } + } + return result; +} + void IdTable::dump( std::ostream &os ) const { + for( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) { + for( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) { +#if 0 + const std::stack< DeclEntry >& entry = inner->second; + if( !entry.empty() ) { // && entry.top().second == scopeLevel ) { + os << outer->first << " (" << inner->first << ") (" << entry.top().second << ")" << std::endl; + } else { + os << outer->first << " (" << inner->first << ") ( entry-empty)" << std::endl; + } +#endif +#if 0 + std::stack stack = inner->second; + os << "dumping a stack" << std::endl; + while (!stack.empty()) { + DeclEntry d = stack.top(); + os << outer->first << " (" << inner->first << ") (" << d.second << ") " << std::endl; + stack.pop(); + } +#endif + } + } +#if 0 for( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) { for( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) { @@ -114,4 +159,5 @@ } } +#endif } Index: translator/SymTab/IdTable.h =================================================================== --- translator/SymTab/IdTable.h (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SymTab/IdTable.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -1,9 +1,2 @@ -/* - * This file is part of the Cforall project - * - * $Id: IdTable.h,v 1.4 2005/08/29 20:14:17 rcbilson Exp $ - * - */ - #ifndef SYMTAB_IDTABLE_H #define SYMTAB_IDTABLE_H @@ -17,27 +10,25 @@ namespace SymTab { + class IdTable { + public: + IdTable(); + + void enterScope(); + void leaveScope(); + void addDecl( DeclarationWithType *decl ); + void lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const; + DeclarationWithType* lookupId( const std::string &id) const; + + void dump( std::ostream &os ) const; // debugging -class IdTable -{ -public: - IdTable(); - - void enterScope(); - void leaveScope(); - void addDecl( DeclarationWithType *decl ); - void lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const; - - void dump( std::ostream &os ) const; // debugging + private: + typedef std::pair< DeclarationWithType*, int > DeclEntry; + typedef std::map< std::string, std::stack< DeclEntry > > InnerTableType; + typedef std::map< std::string, InnerTableType > OuterTableType; - private: - typedef std::pair< DeclarationWithType*, int > DeclEntry; - typedef std::map< std::string, std::stack< DeclEntry > > InnerTableType; - typedef std::map< std::string, InnerTableType > OuterTableType; - - OuterTableType table; - int scopeLevel; -}; - + OuterTableType table; + int scopeLevel; + }; } // namespace SymTab -#endif /* #ifndef SYMTAB_IDTABLE_H */ +#endif // SYMTAB_IDTABLE_H Index: translator/SymTab/Indexer.cc =================================================================== --- translator/SymTab/Indexer.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SymTab/Indexer.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -162,4 +162,8 @@ } + DeclarationWithType* Indexer::lookupId( const std::string &id) const { + return idTable.lookupId(id); + } + NamedTypeDecl *Indexer::lookupType( const std::string &id ) const { return typeTable.lookup( id ); @@ -216,4 +220,20 @@ void Indexer::print( std::ostream &os, int indent ) const { + using std::cerr; + using std::endl; + + cerr << "===idTable===" << endl; + idTable.dump( os ); + cerr << "===typeTable===" << endl; + typeTable.dump( os ); + cerr << "===structTable===" << endl; + structTable.dump( os ); + cerr << "===enumTable===" << endl; + enumTable.dump( os ); + cerr << "===unionTable===" << endl; + unionTable.dump( os ); + cerr << "===contextTable===" << endl; + contextTable.dump( os ); +#if 0 idTable.dump( os ); typeTable.dump( os ); @@ -222,4 +242,5 @@ unionTable.dump( os ); contextTable.dump( os ); +#endif } } // namespace SymTab Index: translator/SymTab/Indexer.h =================================================================== --- translator/SymTab/Indexer.h (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SymTab/Indexer.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -39,4 +39,5 @@ void lookupId( const std::string &id, std::list< DeclarationWithType* >& ) const; + DeclarationWithType* lookupId( const std::string &id) const; NamedTypeDecl *lookupType( const std::string &id ) const; StructDecl *lookupStruct( const std::string &id ) const; @@ -58,3 +59,3 @@ } // namespace SymTab -#endif /* #ifndef SYMTAB_INDEXER_H */ +#endif // SYMTAB_INDEXER_H Index: translator/SymTab/Mangler.cc =================================================================== --- translator/SymTab/Mangler.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SymTab/Mangler.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -226,4 +226,7 @@ mangleName << "L"; } + if ( type->get_isAtomic() ) { + mangleName << "A"; + } } } // SymTab Index: translator/SymTab/Validate.cc =================================================================== --- translator/SymTab/Validate.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SymTab/Validate.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -278,5 +278,5 @@ ObjectDecl *obj = dynamic_cast< ObjectDecl * >( *i ); assert( obj ); - obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false ), enumDecl->get_name() ) ); + obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false ), enumDecl->get_name() ) ); } // for Parent::visit( enumDecl ); Index: translator/SynTree/Initializer.cc =================================================================== --- translator/SynTree/Initializer.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SynTree/Initializer.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -39,17 +39,4 @@ } -MemberInit::MemberInit( Expression *_value, std::string _member ) : member ( _member ), value ( _value ) {} - -MemberInit::~MemberInit() {} - -MemberInit * MemberInit::clone() const { - return new MemberInit( *this ); -} - -void MemberInit::print( std::ostream &os, int indent ) { - os << "Member Initializer"; - value->print( os, indent+2 ); -} - ListInit::ListInit( std::list &_initializers, std::list &_designators ) : initializers( _initializers ), designators( _designators ) { Index: translator/SynTree/Initializer.h =================================================================== --- translator/SynTree/Initializer.h (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SynTree/Initializer.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -61,44 +61,4 @@ }; -// MemberInit represents an initializer for a member of an aggregate object (e.g., struct q { int a; } x = { a : 4 } ) -class MemberInit : public Initializer { - public: - MemberInit( Expression *value, std::string member = std::string("") ); - virtual ~MemberInit(); - - std::string get_member() { return member; } - void set_member( std::string newValue ) { member = newValue; } - Expression *get_value() { return value; } - void set_value( Expression *newValue ) { value = newValue; } - - virtual MemberInit *clone() const; - virtual void accept( Visitor &v ) { v.visit( this ); } - virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); } - virtual void print( std::ostream &os, int indent = 0 ); - private: - std::string member; - Expression *value; -}; - -// ElementInit represents an initializer of an element of an array (e.g., [10] int x = { [7] : 4 } -class ElementInit : public Initializer { - public: - ElementInit( Expression *value ); - virtual ~ElementInit(); - - int get_index() { return index; } - void set_index( int newValue ) { index = newValue; } - Expression *get_value() { return value; } - void set_value( Expression *newValue ) { value = newValue; } - - virtual ElementInit *clone() const; - virtual void accept( Visitor &v ) { v.visit( this ); } - virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); } - virtual void print( std::ostream &os, int indent = 0 ); - private: - int index; - Expression *value; -}; - // ListInit represents an initializer that is composed recursively of a list of initializers; this is used to initialize // an array or aggregate Index: translator/SynTree/Mutator.cc =================================================================== --- translator/SynTree/Mutator.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SynTree/Mutator.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -368,14 +368,4 @@ } -Initializer *Mutator::mutate( MemberInit *memberInit ) { - memberInit->set_value( memberInit->get_value()->acceptMutator( *this ) ); - return memberInit; -} - -Initializer *Mutator::mutate( ElementInit *elementInit ) { - elementInit->set_value( elementInit->get_value()->acceptMutator( *this ) ); - return elementInit; -} - Initializer *Mutator::mutate( SingleInit *singleInit ) { singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) ); Index: translator/SynTree/Mutator.h =================================================================== --- translator/SynTree/Mutator.h (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SynTree/Mutator.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -72,6 +72,4 @@ virtual Type* mutate( AttrType *attrType ); - virtual Initializer* mutate( MemberInit *memberInit ); - virtual Initializer* mutate( ElementInit *elementInit ); virtual Initializer* mutate( SingleInit *singleInit ); virtual Initializer* mutate( ListInit *listInit ); Index: translator/SynTree/SynTree.h =================================================================== --- translator/SynTree/SynTree.h (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SynTree/SynTree.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -89,6 +89,4 @@ class Initializer; -class MemberInit; -class ElementInit; class SingleInit; class ListInit; Index: translator/SynTree/Type.cc =================================================================== --- translator/SynTree/Type.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SynTree/Type.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -57,3 +57,6 @@ os << "lvalue "; } // if + if ( tq.isAtomic ) { + os << "_Atomic "; + } // if } Index: translator/SynTree/Type.h =================================================================== --- translator/SynTree/Type.h (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SynTree/Type.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -10,6 +10,6 @@ public: struct Qualifiers { - Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ) {} - Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ) {} + Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ) {} + Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ) {} Qualifiers &operator+=( const Qualifiers &other ); @@ -27,4 +27,5 @@ bool isRestrict; bool isLvalue; + bool isAtomic; }; @@ -38,8 +39,10 @@ bool get_isRestrict() { return tq.isRestrict; } bool get_isLvalue() { return tq.isLvalue; } + bool get_isAtomic() { return tq.isAtomic; } void set_isConst( bool newValue ) { tq.isConst = newValue; } void set_iisVolatile( bool newValue ) { tq.isVolatile = newValue; } void set_isRestrict( bool newValue ) { tq.isRestrict = newValue; } void set_isLvalue( bool newValue ) { tq.isLvalue = newValue; } + void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; } std::list& get_forall() { return forall; } @@ -380,4 +383,5 @@ isRestrict |= other.isRestrict; isLvalue |= other.isLvalue; + isAtomic |= other.isAtomic; return *this; } @@ -387,4 +391,5 @@ if ( other.isVolatile ) isVolatile = 0; if ( other.isRestrict ) isRestrict = 0; + if ( other.isAtomic ) isAtomic = 0; return *this; } @@ -398,7 +403,8 @@ inline bool Type::Qualifiers::operator==( const Qualifiers &other ) { return isConst == other.isConst - && isVolatile == other.isVolatile - && isRestrict == other.isRestrict; -/// && isLvalue == other.isLvalue; + && isVolatile == other.isVolatile + && isRestrict == other.isRestrict +// && isLvalue == other.isLvalue + && isAtomic == other.isAtomic; } @@ -406,6 +412,7 @@ return isConst != other.isConst || isVolatile != other.isVolatile - || isRestrict != other.isRestrict; -/// && isLvalue == other.isLvalue; + || isRestrict != other.isRestrict +// || isLvalue != other.isLvalue + || isAtomic != other.isAtomic; } @@ -413,6 +420,7 @@ return isConst <= other.isConst && isVolatile <= other.isVolatile - && isRestrict <= other.isRestrict; -/// && isLvalue >= other.isLvalue; + && isRestrict <= other.isRestrict +// && isLvalue >= other.isLvalue + && isAtomic == other.isAtomic; } @@ -420,6 +428,7 @@ return isConst >= other.isConst && isVolatile >= other.isVolatile - && isRestrict >= other.isRestrict; -/// && isLvalue <= other.isLvalue; + && isRestrict >= other.isRestrict +// && isLvalue <= other.isLvalue + && isAtomic == other.isAtomic; } Index: translator/SynTree/Visitor.cc =================================================================== --- translator/SynTree/Visitor.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SynTree/Visitor.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -309,12 +309,4 @@ } -void Visitor::visit(MemberInit *memberInit) { - memberInit->get_value()->accept( *this ); -} - -void Visitor::visit(ElementInit *elementInit) { - elementInit->get_value()->accept( *this ); -} - void Visitor::visit(SingleInit *singleInit) { singleInit->get_value()->accept( *this ); Index: translator/SynTree/Visitor.h =================================================================== --- translator/SynTree/Visitor.h (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/SynTree/Visitor.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -72,6 +72,4 @@ virtual void visit( AttrType *attrType ); - virtual void visit( MemberInit *memberInit ); - virtual void visit( ElementInit *elementInit ); virtual void visit( SingleInit *singleInit ); virtual void visit( ListInit *listInit ); Index: translator/Tests/Parser/Constant0-1.c =================================================================== --- translator/Tests/Parser/Constant0-1.c (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/Tests/Parser/Constant0-1.c (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -5,11 +5,11 @@ int 0; const int 0; -static const int 0; +//static const int 0; int 1; const int 1; -static const int 1; +//static const int 1; int 0, 1; const int 0, 1; -static const int 0, 1; +//static const int 0, 1; struct { int i; } 0; const struct { int i; } 1; @@ -27,9 +27,14 @@ * int x, 0; const * int x, 0; -static const * int x, 0; +//static const * int x, 0; * struct { int i; } 0; const * struct { int i; } 0; static const * struct { int i; } 0; -static * int x, 0; -static const * int x, 0; +//static * int x, 0; +//static const * int x, 0; const * * int x, 0; + +int main() { +//int 1, * 0; +//* int x, 0; +} Index: translator/examples/constants.c =================================================================== --- translator/examples/constants.c (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) +++ translator/examples/constants.c (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -0,0 +1,18 @@ +int foo() { + 1_234_Ul; + -0_177; + 0x_ff_FF_ff_FF; + +9_223_372_036_854_775_807; + 12.123_333_E_27; + 0X_1.ff_ff_ff_ff_ff_fff_P_1023; + '\0'; + '\1_2_3'; + L_'\x_ff_ee'; + L"a_bc\u_00_40xyz\xff_AA"; + "a_bc\\ + u_00_40xyz"; +} + +// Local Variables: // +// compile-command: "../../bin/cfa -std=c99 constants.c" // +// End: // Index: translator/examples/control_structures.c =================================================================== --- translator/examples/control_structures.c (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) +++ translator/examples/control_structures.c (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -0,0 +1,49 @@ +int main() { + L1: { + L2: switch ( 3_333_333 ) { // underscores in constant + case 1,2,3: // 4~8, 4...8 not working + L3: for ( ;; ) { + L4: for ( ;; ) { + break L1; // labelled break + break L2; + break L3; + break L4; +#if 0 + continue L1; // labelled continue + continue L2; + continue L3; + continue L4; +#endif + } // for + } // for + break; + default: + break L1; + } // switch + 3; + int i, j; + choose ( 7 ) { + case 1,2,3: + i = 3; + fallthru; + case 4,5,6: + j = 3; + default: ; + } // choose + } // block + +#if 0 + try { + int i = 3; + } catch( int ) { + } catch( double ) { + } catch( ... ) { + } finally { + } // try +#endif + +} // main + +// Local Variables: // +// compile-command: "../../bin/cfa control_structures.c" // +// End: // Index: translator/examples/includes.c =================================================================== --- translator/examples/includes.c (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/examples/includes.c (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -34,4 +34,5 @@ #include #else +#include // FAILS -- includes locale.h #endif // 0 Index: translator/examples/min.c =================================================================== --- translator/examples/min.c (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/examples/min.c (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -10,5 +10,5 @@ int main() { char c; - c = min( 'a', 'z' ); + c = min( 'z', 'a' ); printf( "minimum %d\n", c ); int i; Index: translator/examples/square.c =================================================================== --- translator/examples/square.c (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/examples/square.c (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -12,3 +12,4 @@ int main() { printf( "result of square of 5 is %d\n", square( 5 ) ); + printf( "result of square of 5 is %f\n", square( 5.0 ) ); } Index: translator/examples/sum.c =================================================================== --- translator/examples/sum.c (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/examples/sum.c (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -7,10 +7,11 @@ T ?+?( T, T ); T ?++( T * ); - [T] ?+=?( T *, T ); + T ?+=?( T *, T ); }; forall( type T | sumable( T ) ) T sum( int n, T a[] ) { - T total = 0; // instantiate T, select 0 + T total; // instantiate T, select 0 + total = 0; for ( int i = 0; i < n; i += 1 ) total = total + a[i]; // select + @@ -18,7 +19,14 @@ } +// Required to satisfy sumable as char does not have addition. +const char 0; +char ?+?( char op1, char op2 ) { return op1 + op2; } +char ?++( char *op ) { return *op + 1; } + +const double 0; // TEMPORARY, incorrect use of int 0 + int main() { const int size = 10, low = 0, High = 10; - int si, ai[10]; // size + int si = 0, ai[10]; // size int i; for ( i = low; i < High; i += 1 ) { @@ -28,5 +36,11 @@ printf( "sum from %d to %d is %d, check %d\n", low, High, sum( size, ai ), si ); - double sd, ad[10]; // size + +// char ci[10]; +// char c = sum( size, ci ); +// float fi[10]; +// float f = sum( size, fi ); + + double sd = 0.0, ad[10]; // size for ( i = low; i < High; i += 1 ) { double d = i / (double)size; Index: translator/main.cc =================================================================== --- translator/main.cc (revision ad17ba6a8a138b346278ade9cfca43fa9e7c84e1) +++ translator/main.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) @@ -48,5 +48,5 @@ bool debugp = false, treep = false, astp = false, manglep = false, symtabp = false, validp = false; bool preludep = true, protop = false, libp = false; - bool exprp = false; + bool exprp = false, codegenp = false; int c; FILE *input, *prelude, *builtins; @@ -55,5 +55,5 @@ opterr = 0; - while ( (c = getopt( argc, argv, "dtsgmvxcenprlD:" )) != -1 ) { + while ( (c = getopt( argc, argv, "dtsgmvxcenprlDz:" )) != -1 ) { switch (c) { case 'd': @@ -89,4 +89,7 @@ exprp = true; break; + case 'z': + codegenp = true; + break; case 'n': /* don't read preamble */ @@ -234,4 +237,23 @@ return 0; } // if + + if ( codegenp ) { + // print the tree right before code generation... + // InitTweak::mutate( translationUnit ); + // InitTweak::tweak( translationUnit ); + //printAll( translationUnit, std::cout ); + + // std::cerr << "finished tweaking" << std::endl; + SymTab::validate( translationUnit, false ); + ControlStruct::mutate( translationUnit ); + CodeGen::fixNames( translationUnit ); + ResolvExpr::resolve( translationUnit ); + GenPoly::copyParams( translationUnit ); + GenPoly::convertSpecializations( translationUnit ); + GenPoly::convertLvalue( translationUnit ); + GenPoly::box( translationUnit ); + printAll( translationUnit, std::cout ); + return 0; + } // if //std::cerr << "before validate" << std::endl;