Index: translator/SymTab/Mangler.cc =================================================================== --- translator/SymTab/Mangler.cc (revision 3c70d383ff7630d9cdc9dd98340ba26c715dfeaa) +++ translator/SymTab/Mangler.cc (revision ea3eb06e82e92717315fe1ac99f424263976bfdd) @@ -1,9 +1,2 @@ -/* - * This file is part of the Cforall project - * - * $Id: Mangler.cc,v 1.13 2005/08/29 20:14:18 rcbilson Exp $ - * - */ - #include #include @@ -22,9 +15,6 @@ namespace SymTab { - -Mangler::Mangler() - : nextVarNum( 0 ), isTopLevel( true ) -{ -} + Mangler::Mangler() : nextVarNum( 0 ), isTopLevel( true ) + {} //Mangler::Mangler( const Mangler & ) @@ -32,246 +22,208 @@ //{ //} -Mangler::Mangler( const Mangler &rhs ) - : mangleName() -{ - varNums = rhs.varNums; - nextVarNum = rhs.nextVarNum; - isTopLevel = rhs.isTopLevel; -} - -void -Mangler::mangleDecl(DeclarationWithType *declaration) -{ - bool wasTopLevel = isTopLevel; - if( isTopLevel ) { - varNums.clear(); - nextVarNum = 0; - isTopLevel = false; - } - mangleName << "__"; - CodeGen::OperatorInfo opInfo; - if( operatorLookup( declaration->get_name(), opInfo ) ) { - mangleName << opInfo.outputName; - } else { - mangleName << declaration->get_name(); - } - mangleName << "__"; - maybeAccept( declaration->get_type(), *this ); - isTopLevel = wasTopLevel; -} - -void -Mangler::visit(ObjectDecl *declaration) -{ - mangleDecl( declaration ); -} - -void -Mangler::visit(FunctionDecl *declaration) -{ - mangleDecl( declaration ); -} - -void -Mangler::visit(VoidType *voidType) -{ - printQualifiers( voidType ); - mangleName << "v"; -} - -void -Mangler::visit(BasicType *basicType) -{ - static const char *btLetter[] = { - "b", // Bool - "c", // Char - "Sc", // SignedChar - "Uc", // UnsignedChar - "s", // ShortSignedInt - "Us", // ShortUnsignedInt - "i", // SignedInt - "Ui", // UnsignedInt - "l", // LongSignedInt - "Ul", // LongUnsignedInt - "q", // LongLongSignedInt - "Uq", // LongLongUnsignedInt - "f", // Float - "d", // Double - "r", // LongDouble - "Xf", // FloatComplex - "Xd", // DoubleComplex - "Xr", // LongDoubleComplex - "If", // FloatImaginary - "Id", // DoubleImaginary - "Ir", // LongDoubleImaginary - }; + Mangler::Mangler( const Mangler &rhs ) : mangleName() { + varNums = rhs.varNums; + nextVarNum = rhs.nextVarNum; + isTopLevel = rhs.isTopLevel; + } + + void Mangler::mangleDecl( DeclarationWithType *declaration ) { + bool wasTopLevel = isTopLevel; + if ( isTopLevel ) { + varNums.clear(); + nextVarNum = 0; + isTopLevel = false; + } + mangleName << "__"; + CodeGen::OperatorInfo opInfo; + if ( operatorLookup( declaration->get_name(), opInfo ) ) { + mangleName << opInfo.outputName; + } else { + mangleName << declaration->get_name(); + } + mangleName << "__"; + maybeAccept( declaration->get_type(), *this ); + isTopLevel = wasTopLevel; + } + + void Mangler::visit( ObjectDecl *declaration ) { + mangleDecl( declaration ); + } + + void Mangler::visit( FunctionDecl *declaration ) { + mangleDecl( declaration ); + } + + void Mangler::visit( VoidType *voidType ) { + printQualifiers( voidType ); + mangleName << "v"; + } + + void Mangler::visit( BasicType *basicType ) { + static const char *btLetter[] = { + "b", // Bool + "c", // Char + "Sc", // SignedChar + "Uc", // UnsignedChar + "s", // ShortSignedInt + "Us", // ShortUnsignedInt + "i", // SignedInt + "Ui", // UnsignedInt + "l", // LongSignedInt + "Ul", // LongUnsignedInt + "q", // LongLongSignedInt + "Uq", // LongLongUnsignedInt + "f", // Float + "d", // Double + "r", // LongDouble + "Xf", // FloatComplex + "Xd", // DoubleComplex + "Xr", // LongDoubleComplex + "If", // FloatImaginary + "Id", // DoubleImaginary + "Ir", // LongDoubleImaginary + }; - printQualifiers( basicType ); - mangleName << btLetter[ basicType->get_kind() ]; -} - -void -Mangler::visit(PointerType *pointerType) -{ - printQualifiers( pointerType ); - mangleName << "P"; - maybeAccept( pointerType->get_base(), *this ); -} - -void -Mangler::visit(ArrayType *arrayType) -{ - // TODO: encode dimension - printQualifiers( arrayType ); - mangleName << "A0"; - maybeAccept( arrayType->get_base(), *this ); -} - -namespace { - inline std::list< Type* > - getTypes( const std::list< DeclarationWithType* > decls ) - { - std::list< Type* > ret; - std::transform( decls.begin(), decls.end(), std::back_inserter( ret ), - std::mem_fun( &DeclarationWithType::get_type ) ); - return ret; - } -} - -void -Mangler::visit(FunctionType *functionType) -{ - printQualifiers( functionType ); - mangleName << "F"; - std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() ); - acceptAll( returnTypes, *this ); - mangleName << "_"; - std::list< Type* > paramTypes = getTypes( functionType->get_parameters() ); - acceptAll( paramTypes, *this ); - mangleName << "_"; -} - -void -Mangler::mangleRef(ReferenceToType *refType, std::string prefix) -{ - printQualifiers( refType ); - mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name(); -} - -void -Mangler::visit(StructInstType *aggregateUseType) -{ - mangleRef( aggregateUseType, "s" ); -} - -void -Mangler::visit(UnionInstType *aggregateUseType) -{ - mangleRef( aggregateUseType, "u" ); -} - -void -Mangler::visit(EnumInstType *aggregateUseType) -{ - mangleRef( aggregateUseType, "e" ); -} - -void -Mangler::visit(TypeInstType *typeInst) -{ - VarMapType::iterator varNum = varNums.find( typeInst->get_name() ); - if( varNum == varNums.end() ) { - mangleRef( typeInst, "t" ); - } else { - printQualifiers( typeInst ); - std::ostrstream numStream; - numStream << varNum->second.first; - mangleName << (numStream.pcount() + 1); - switch( (TypeDecl::Kind)varNum->second.second ) { - case TypeDecl::Any: - mangleName << "t"; - break; - case TypeDecl::Dtype: - mangleName << "d"; - break; - case TypeDecl::Ftype: - mangleName << "f"; - break; - } - mangleName << std::string( numStream.str(), numStream.pcount() ); - } -} - -void -Mangler::visit(TupleType *tupleType) -{ - printQualifiers( tupleType ); - mangleName << "T"; - acceptAll( tupleType->get_types(), *this ); - mangleName << "_"; -} - -void -Mangler::visit(TypeDecl *decl) -{ - static const char *typePrefix[] = { "BT", "BD", "BF" }; - mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name(); -} - -void -printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) -{ - for( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) { - os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl; - } -} - -void -Mangler::printQualifiers( Type *type ) -{ - if( !type->get_forall().empty() ) { - std::list< std::string > assertionNames; - int tcount = 0, dcount = 0, fcount = 0; - mangleName << "A"; - for( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) { - switch( (*i)->get_kind() ) { - case TypeDecl::Any: - tcount++; - break; - case TypeDecl::Dtype: - dcount++; - break; - case TypeDecl::Ftype: - fcount++; - break; - } - varNums[ (*i)->get_name() ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() ); - for( std::list< DeclarationWithType* >::iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) { - Mangler sub_mangler; - sub_mangler.nextVarNum = nextVarNum; - sub_mangler.isTopLevel = false; - sub_mangler.varNums = varNums; - (*assert)->accept( sub_mangler ); - assertionNames.push_back( std::string( sub_mangler.mangleName.str(), sub_mangler.mangleName.pcount() ) ); - } - } - mangleName << tcount << "_" << dcount << "_" << fcount << "_"; - std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) ); - mangleName << "_"; - } - if( type->get_isConst() ) { - mangleName << "C"; - } - if( type->get_isVolatile() ) { - mangleName << "V"; - } - if( type->get_isRestrict() ) { - mangleName << "R"; - } - if( type->get_isLvalue() ) { - mangleName << "L"; - } -} - - -} // namespace SymTab + printQualifiers( basicType ); + mangleName << btLetter[ basicType->get_kind() ]; + } + + void Mangler::visit( PointerType *pointerType ) { + printQualifiers( pointerType ); + mangleName << "P"; + maybeAccept( pointerType->get_base(), *this ); + } + + void Mangler::visit( ArrayType *arrayType ) { + // TODO: encode dimension + printQualifiers( arrayType ); + mangleName << "A0"; + maybeAccept( arrayType->get_base(), *this ); + } + + namespace { + inline std::list< Type* > + getTypes( const std::list< DeclarationWithType* > decls ) + { + std::list< Type* > ret; + std::transform( decls.begin(), decls.end(), std::back_inserter( ret ), + std::mem_fun( &DeclarationWithType::get_type ) ); + return ret; + } + } + + void Mangler::visit( FunctionType *functionType ) { + printQualifiers( functionType ); + mangleName << "F"; + std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() ); + acceptAll( returnTypes, *this ); + mangleName << "_"; + std::list< Type* > paramTypes = getTypes( functionType->get_parameters() ); + acceptAll( paramTypes, *this ); + mangleName << "_"; + } + + void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) { + printQualifiers( refType ); + mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name(); + } + + void Mangler::visit( StructInstType *aggregateUseType ) { + mangleRef( aggregateUseType, "s" ); + } + + void Mangler::visit( UnionInstType *aggregateUseType ) { + mangleRef( aggregateUseType, "u" ); + } + + void Mangler::visit( EnumInstType *aggregateUseType ) { + mangleRef( aggregateUseType, "e" ); + } + + void Mangler::visit( TypeInstType *typeInst ) { + VarMapType::iterator varNum = varNums.find( typeInst->get_name() ); + if ( varNum == varNums.end() ) { + mangleRef( typeInst, "t" ); + } else { + printQualifiers( typeInst ); + std::ostrstream numStream; + numStream << varNum->second.first; + mangleName << (numStream.pcount() + 1); + switch ( (TypeDecl::Kind )varNum->second.second ) { + case TypeDecl::Any: + mangleName << "t"; + break; + case TypeDecl::Dtype: + mangleName << "d"; + break; + case TypeDecl::Ftype: + mangleName << "f"; + break; + } + mangleName << std::string( numStream.str(), numStream.pcount() ); + } + } + + void Mangler::visit( TupleType *tupleType ) { + printQualifiers( tupleType ); + mangleName << "T"; + acceptAll( tupleType->get_types(), *this ); + mangleName << "_"; + } + + void Mangler::visit( TypeDecl *decl ) { + static const char *typePrefix[] = { "BT", "BD", "BF" }; + mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name(); + } + + void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) { + for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) { + os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl; + } + } + + void Mangler::printQualifiers( Type *type ) { + if ( !type->get_forall().empty() ) { + std::list< std::string > assertionNames; + int tcount = 0, dcount = 0, fcount = 0; + mangleName << "A"; + for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) { + switch ( (*i)->get_kind() ) { + case TypeDecl::Any: + tcount++; + break; + case TypeDecl::Dtype: + dcount++; + break; + case TypeDecl::Ftype: + fcount++; + break; + } + varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() ); + for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) { + Mangler sub_mangler; + sub_mangler.nextVarNum = nextVarNum; + sub_mangler.isTopLevel = false; + sub_mangler.varNums = varNums; + (*assert)->accept( sub_mangler ); + assertionNames.push_back( std::string( sub_mangler.mangleName.str(), sub_mangler.mangleName.pcount() ) ); + } + } + mangleName << tcount << "_" << dcount << "_" << fcount << "_"; + std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) ); + mangleName << "_"; + } + if ( type->get_isConst() ) { + mangleName << "C"; + } + if ( type->get_isVolatile() ) { + mangleName << "V"; + } + if ( type->get_isRestrict() ) { + mangleName << "R"; + } + if ( type->get_isLvalue() ) { + mangleName << "L"; + } + } +} // SymTab Index: translator/SymTab/Mangler.h =================================================================== --- translator/SymTab/Mangler.h (revision 3c70d383ff7630d9cdc9dd98340ba26c715dfeaa) +++ translator/SymTab/Mangler.h (revision ea3eb06e82e92717315fe1ac99f424263976bfdd) @@ -1,9 +1,2 @@ -/* - * This file is part of the Cforall project - * - * $Id: Mangler.h,v 1.6 2005/08/29 20:14:18 rcbilson Exp $ - * - */ - #ifndef SYMTAB_MANGLER_H #define SYMTAB_MANGLER_H @@ -14,56 +7,49 @@ namespace SymTab { - -class Mangler : public Visitor -{ -public: - template< typename SynTreeClass > - static std::string mangle( SynTreeClass *decl ); // interface to clients + class Mangler : public Visitor { + public: + template< typename SynTreeClass > + static std::string mangle( SynTreeClass *decl ); // interface to clients /// using Visitor::visit; - virtual void visit(ObjectDecl *declaration); - virtual void visit(FunctionDecl *declaration); - virtual void visit(TypeDecl *declaration); + virtual void visit( ObjectDecl *declaration ); + virtual void visit( FunctionDecl *declaration ); + virtual void visit( TypeDecl *declaration ); - virtual void visit(VoidType *voidType); - virtual void visit(BasicType *basicType); - virtual void visit(PointerType *pointerType); - virtual void visit(ArrayType *arrayType); - virtual void visit(FunctionType *functionType); - virtual void visit(StructInstType *aggregateUseType); - virtual void visit(UnionInstType *aggregateUseType); - virtual void visit(EnumInstType *aggregateUseType); - virtual void visit(TypeInstType *aggregateUseType); - virtual void visit(TupleType *tupleType); + virtual void visit( VoidType *voidType ); + virtual void visit( BasicType *basicType ); + virtual void visit( PointerType *pointerType ); + virtual void visit( ArrayType *arrayType ); + virtual void visit( FunctionType *functionType ); + virtual void visit( StructInstType *aggregateUseType ); + virtual void visit( UnionInstType *aggregateUseType ); + virtual void visit( EnumInstType *aggregateUseType ); + virtual void visit( TypeInstType *aggregateUseType ); + virtual void visit( TupleType *tupleType ); - std::string get_mangleName() { return std::string( mangleName.str(), mangleName.pcount() ); } + std::string get_mangleName() { return std::string( mangleName.str(), mangleName.pcount() ); } + private: + std::ostrstream mangleName; + typedef std::map< std::string, std::pair< int, int > > VarMapType; + VarMapType varNums; + int nextVarNum; + bool isTopLevel; + + Mangler(); + Mangler( const Mangler & ); + + void mangleDecl( DeclarationWithType *declaration ); + void mangleRef( ReferenceToType *refType, std::string prefix ); + + void printQualifiers( Type *type ); + }; // Mangler -private: - std::ostrstream mangleName; - typedef std::map< std::string, std::pair< int, int > > VarMapType; - VarMapType varNums; - int nextVarNum; - bool isTopLevel; - - Mangler(); - Mangler( const Mangler & ); - - void mangleDecl(DeclarationWithType *declaration); - void mangleRef(ReferenceToType *refType, std::string prefix); - - void printQualifiers( Type *type ); -}; + template< typename SynTreeClass > + std::string Mangler::mangle( SynTreeClass *decl ) { + Mangler mangler; + maybeAccept( decl, mangler ); + return mangler.get_mangleName(); + } +} // SymTab -/* static class method */ -template< typename SynTreeClass > -std::string -Mangler::mangle( SynTreeClass *decl ) -{ - Mangler mangler; - maybeAccept( decl, mangler ); - return mangler.get_mangleName(); -} - -} // namespace SymTab - -#endif /* #ifndef SYMTAB_MANGLER_H */ +#endif // SYMTAB_MANGLER_H Index: translator/SymTab/StackTable.cc =================================================================== --- translator/SymTab/StackTable.cc (revision 3c70d383ff7630d9cdc9dd98340ba26c715dfeaa) +++ translator/SymTab/StackTable.cc (revision ea3eb06e82e92717315fe1ac99f424263976bfdd) @@ -1,9 +1,2 @@ -/* - * This file is part of the Cforall project - * - * $Id: StackTable.cc,v 1.3 2002/09/19 21:02:44 rcbilson Exp $ - * - */ - #include @@ -11,77 +4,60 @@ namespace SymTab { + template< typename Element, typename ConflictFunction > + StackTable< Element, ConflictFunction >::StackTable() : scopeLevel( 0 ) + {} -template< typename Element, typename ConflictFunction > -StackTable< Element, ConflictFunction >::StackTable() - : scopeLevel( 0 ) -{ -} + template< typename Element, typename ConflictFunction > + void StackTable< Element, ConflictFunction >::enterScope() { + scopeLevel++; + } -template< typename Element, typename ConflictFunction > -void -StackTable< Element, ConflictFunction >::enterScope() -{ - scopeLevel++; -} + template< typename Element, typename ConflictFunction > + void StackTable< Element, ConflictFunction >::leaveScope() { + for ( typename TableType::iterator it = table.begin(); it != table.end(); ++it ) { + std::stack< Entry >& entry = it->second; + if ( !entry.empty() && entry.top().second == scopeLevel ) { + entry.pop(); + } + } + scopeLevel--; + assert( scopeLevel >= 0 ); + } -template< typename Element, typename ConflictFunction > -void -StackTable< Element, ConflictFunction >::leaveScope() -{ - for( typename TableType::iterator it = table.begin(); it != table.end(); ++it ) { - std::stack< Entry >& entry = it->second; - if( !entry.empty() && entry.top().second == scopeLevel ) { - entry.pop(); + template< typename Element, typename ConflictFunction > + void StackTable< Element, ConflictFunction >::add( Element *type ) { + std::stack< Entry >& entry = table[ type->get_name() ]; + if ( !entry.empty() && entry.top().second == scopeLevel ) { + entry.top().first = conflictFunction( entry.top().first, type ); + } else { + entry.push( Entry( type, scopeLevel ) ); + } } - } - - scopeLevel--; - assert( scopeLevel >= 0 ); -} -template< typename Element, typename ConflictFunction > -void -StackTable< Element, ConflictFunction >::add( Element *type ) -{ - std::stack< Entry >& entry = table[ type->get_name() ]; - if( !entry.empty() && entry.top().second == scopeLevel ) { - entry.top().first = conflictFunction( entry.top().first, type ); - } else { - entry.push( Entry( type, scopeLevel ) ); - } -} + template< typename Element, typename ConflictFunction > + void StackTable< Element, ConflictFunction >::add( std::string fwdDeclName ) { + add( new Element( fwdDeclName ) ); + } -template< typename Element, typename ConflictFunction > -void -StackTable< Element, ConflictFunction >::add( std::string fwdDeclName ) -{ - add( new Element( fwdDeclName ) ); -} + template< typename Element, typename ConflictFunction > + Element *StackTable< Element, ConflictFunction >::lookup( std::string id ) const { + typename TableType::const_iterator it = table.find( id ); + if ( it == table.end() ) { + return 0; + } else if ( !it->second.empty() ) { + return it->second.top().first; + } else { + return 0; + } + } -template< typename Element, typename ConflictFunction > -Element * -StackTable< Element, ConflictFunction >::lookup( std::string id ) const -{ - typename TableType::const_iterator it = table.find( id ); - if( it == table.end() ) { - return 0; - } else if( !it->second.empty() ) { - return it->second.top().first; - } else { - return 0; - } -} - -template< typename Element, typename ConflictFunction > -void -StackTable< Element, ConflictFunction >::dump( std::ostream &os ) const -{ - for( typename TableType::const_iterator it = table.begin(); it != table.end(); ++it ) { - const std::stack< Entry >& entry = it->second; - if( !entry.empty() && entry.top().second == scopeLevel ) { - os << it->first << std::endl; + template< typename Element, typename ConflictFunction > + void StackTable< Element, ConflictFunction >::dump( std::ostream &os ) const { + for ( typename TableType::const_iterator it = table.begin(); it != table.end(); ++it ) { + const std::stack< Entry >& entry = it->second; + if ( !entry.empty() && entry.top().second == scopeLevel ) { + os << it->first << std::endl; + } + } } - } -} - -} // namespace SymTab +} // SymTab Index: translator/SymTab/StackTable.h =================================================================== --- translator/SymTab/StackTable.h (revision 3c70d383ff7630d9cdc9dd98340ba26c715dfeaa) +++ translator/SymTab/StackTable.h (revision ea3eb06e82e92717315fe1ac99f424263976bfdd) @@ -1,9 +1,2 @@ -/* - * This file is part of the Cforall project - * - * $Id: StackTable.h,v 1.2 2002/09/19 21:02:44 rcbilson Exp $ - * - */ - #ifndef SYMTAB_STACKTABLE_H #define SYMTAB_STACKTABLE_H @@ -15,31 +8,27 @@ namespace SymTab { + template< typename Element, typename ConflictFunction > + class StackTable { + public: + StackTable(); -template< typename Element, typename ConflictFunction > -class StackTable -{ -public: - StackTable(); + void enterScope(); + void leaveScope(); + void add( Element *type ); + void add( std::string fwdDeclName ); + Element *lookup( std::string id ) const; - void enterScope(); - void leaveScope(); - void add( Element *type ); - void add( std::string fwdDeclName ); - Element *lookup( std::string id ) const; - - void dump( std::ostream &os ) const; // debugging + void dump( std::ostream &os ) const; // debugging + private: + typedef std::pair< Element*, int > Entry; + typedef std::map< std::string, std::stack< Entry > > TableType; -private: - typedef std::pair< Element*, int > Entry; - typedef std::map< std::string, std::stack< Entry > > TableType; - - ConflictFunction conflictFunction; - TableType table; - int scopeLevel; -}; - -} // namespace SymTab + ConflictFunction conflictFunction; + TableType table; + int scopeLevel; + }; +} // SymTab #include "StackTable.cc" -#endif /* #ifndef SYMTAB_STACKTABLE_H */ +#endif // SYMTAB_STACKTABLE_H Index: anslator/examples/factorial.c =================================================================== --- translator/examples/factorial.c (revision 3c70d383ff7630d9cdc9dd98340ba26c715dfeaa) +++ (revision ) @@ -1,18 +1,0 @@ -//#include - -int -factorial( int n ) -{ - if( n ) { - return factorial( n - 1 ); - } else { - return 1; - } -} - -int -main() -{ - printf( "result is %d\n", factorial( 6 ) ); - return 0; -} Index: translator/examples/forward.c =================================================================== --- translator/examples/forward.c (revision 3c70d383ff7630d9cdc9dd98340ba26c715dfeaa) +++ translator/examples/forward.c (revision ea3eb06e82e92717315fe1ac99f424263976bfdd) @@ -7,6 +7,5 @@ struct q *x; -void f() -{ - *x; +void f() { + *x; } Index: translator/examples/huge.c =================================================================== --- translator/examples/huge.c (revision 3c70d383ff7630d9cdc9dd98340ba26c715dfeaa) +++ translator/examples/huge.c (revision ea3eb06e82e92717315fe1ac99f424263976bfdd) @@ -1,7 +1,6 @@ -int huge (int n, forall (type T) T (*f) (T)) -{ - if (n <= 0) - return f(0); +int huge( int n, forall( type T ) T (*f)( T ) ) { + if ( n <= 0 ) + return f( 0 ); else - return huge (n-1, f(f)); + return huge( n - 1, f( f ) ); } Index: translator/examples/identity.c =================================================================== --- translator/examples/identity.c (revision 3c70d383ff7630d9cdc9dd98340ba26c715dfeaa) +++ translator/examples/identity.c (revision ea3eb06e82e92717315fe1ac99f424263976bfdd) @@ -1,4 +1,2 @@ -// './cfa identity.c' - extern "C" { int printf( const char *fmt, ... ); Index: translator/examples/new.c =================================================================== --- translator/examples/new.c (revision 3c70d383ff7630d9cdc9dd98340ba26c715dfeaa) +++ translator/examples/new.c (revision ea3eb06e82e92717315fe1ac99f424263976bfdd) @@ -1,15 +1,13 @@ -// "./cfa-cpp -c new.c" - forall( type T ) void f( T *t ) { - t--; - *t; - ++t; - t += 2; - t + 2; - --t; - t -= 2; - t - 4; - t[7]; - 7[t]; + t--; + *t; + ++t; + t += 2; + t + 2; + --t; + t -= 2; + t - 4; + t[7]; + 7[t]; } Index: translator/examples/quad.c =================================================================== --- translator/examples/quad.c (revision 3c70d383ff7630d9cdc9dd98340ba26c715dfeaa) +++ translator/examples/quad.c (revision ea3eb06e82e92717315fe1ac99f424263976bfdd) @@ -1,6 +1,2 @@ -// "./cfa quad.c" -// "./cfa -CFA quad.c > quad_out.c" -// "gcc31 -g quad_out.c LibCfa/libcfa.a" - extern "C" { #include Index: translator/examples/test.c =================================================================== --- translator/examples/test.c (revision 3c70d383ff7630d9cdc9dd98340ba26c715dfeaa) +++ translator/examples/test.c (revision ea3eb06e82e92717315fe1ac99f424263976bfdd) @@ -1,20 +1,13 @@ -// "cfa -c -o test.o test.c" -// "cfa -CFA test.c > test_out.c" -// "gcc31 -c test_out.c -o test.o" - #include "fstream.h" #include "vector_int.h" -int -main() -{ - ofstream *sout = ofstream_stdout(); - vector_int vec = vector_int_allocate(); - int index; - switch(1) { - case 1: - sout << vec[ index ]; - } - sout << "\n"; - return 0; +int main() { + ofstream *sout = ofstream_stdout(); + vector_int vec = vector_int_allocate(); + int index; + switch(1) { + case 1: + sout << vec[ index ]; + } + sout << "\n"; } Index: translator/examples/vector_test.c =================================================================== --- translator/examples/vector_test.c (revision 3c70d383ff7630d9cdc9dd98340ba26c715dfeaa) +++ translator/examples/vector_test.c (revision ea3eb06e82e92717315fe1ac99f424263976bfdd) @@ -1,7 +1,2 @@ -// "cfa -c -o vector_test.o vector_test.c" -// "cfa -CFA vector_test.c > vector_test_out.c" -// "cfa -E vector_test.c > vector_test_out.c" -// "gcc31 -c vector_test_out.c -o vector_test.o" - #include "fstream.h" #include "vector_int.h"