Index: translator/Parser/DeclarationNode.cc =================================================================== --- translator/Parser/DeclarationNode.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) +++ translator/Parser/DeclarationNode.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) @@ -0,0 +1,1076 @@ +#include +#include +#include +#include +#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" }; +const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "bool", "complex", "imaginary" }; +const char *DeclarationNode::modifierName[] = { "signed", "unsigned", "short", "long" }; +const char *DeclarationNode::tyConName[] = { "struct", "union", "context" }; +const char *DeclarationNode::typeClassName[] = { "type", "dtype", "ftype" }; + +UniqueName DeclarationNode::anonymous( "__anonymous" ); + +extern LinkageSpec::Type linkage; /* defined in cfa.y */ + +DeclarationNode* +DeclarationNode::clone() const +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = maybeClone( type ); + newnode->name = name; + newnode->storageClasses = storageClasses; + newnode->bitfieldWidth = maybeClone( bitfieldWidth ); + newnode->hasEllipsis = hasEllipsis; + newnode->initializer = initializer; + newnode->next = maybeClone( next ); + newnode->linkage = linkage; + return newnode; +} + +DeclarationNode::DeclarationNode() + : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage ) +{ +} + +DeclarationNode::~DeclarationNode() +{ + delete type; + delete bitfieldWidth; + delete initializer; +} + +bool +DeclarationNode::get_hasEllipsis() const +{ + return hasEllipsis; +} + +const char *storageClassName[] = +{ + // order must correspond with DeclarationNode::StorageClass + "static", + "auto", + "extern", + "register", + "inline", + "fortran", +}; + +void +DeclarationNode::print( std::ostream &os, int indent ) const +{ + os << string(indent, ' '); + if( name == "" ) { +/// os << "An unnamed "; + } else { + os << name << ": a "; + } + if( linkage != LinkageSpec::Cforall ) { + os << LinkageSpec::toString( linkage ) << " "; + } + printEnums( storageClasses.begin(), storageClasses.end(), storageClassName, os ); + if( type ) { + type->print( os, indent ); + } else { + os << "untyped entity "; + } + if( bitfieldWidth ) { + os << endl << string(indent+2, ' ') << "with bitfield width "; + bitfieldWidth->printOneLine( os ); + } + + if( initializer != 0 ) { + os << endl << string(indent+2, ' ') << "with initializer "; + initializer->printOneLine( os ); + } + + os << endl; +} + +void +DeclarationNode::printList( std::ostream &os, int indent ) const +{ + ParseNode::printList( os, indent ); + if( hasEllipsis ) { + os << string( indent, ' ' ) << "and a variable number of other arguments" << endl; + } +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newFunction( std::string* name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->name = assign_strptr( name ); + + newnode->type = new TypeData( TypeData::Function ); + newnode->type->function->params = param; + newnode->type->function->newStyle = newStyle; + newnode->type->function->body = body; + if( body ) { + newnode->type->function->hasBody = true; + } + + if( ret ) { + newnode->type->base = ret->type; + ret->type = 0; + delete ret; + } + + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newQualifier( Qualifier q ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData(); + newnode->type->qualifiers.push_back( q ); + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newStorageClass( StorageClass sc ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->storageClasses.push_back( sc ); + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newBasicType( BasicType bt ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Basic ); + newnode->type->basic->typeSpec.push_back( bt ); + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newModifier( Modifier mod ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Basic ); + newnode->type->basic->modifiers.push_back( mod ); + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newForall( DeclarationNode* forall ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Unknown ); + newnode->type->forall = forall; + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newFromTypedef( std::string* name ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::SymbolicInst ); + newnode->type->symbolic->name = assign_strptr( name ); + newnode->type->symbolic->isTypedef = true; + newnode->type->symbolic->params = 0; + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Aggregate ); + newnode->type->aggregate->kind = kind; + newnode->type->aggregate->name = assign_strptr( name ); + if( newnode->type->aggregate->name == "" ) { + newnode->type->aggregate->name = DeclarationNode::anonymous.newName(); + } + newnode->type->aggregate->params = formals; + newnode->type->aggregate->actuals = actuals; + newnode->type->aggregate->members = fields; + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->name = assign_strptr( name ); + newnode->type = new TypeData( TypeData::Enum ); + newnode->type->enumeration->name = newnode->name; + if( newnode->type->enumeration->name == "" ) { + newnode->type->enumeration->name = DeclarationNode::anonymous.newName(); + } + newnode->type->enumeration->constants = constants; + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newEnumConstant( std::string* name, ExpressionNode *constant ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->name = assign_strptr( name ); + // do something with the constant + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newName( std::string* name ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->name = assign_strptr( name ); + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newFromTypeGen( std::string* name, ExpressionNode *params ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::SymbolicInst ); + newnode->type->symbolic->name = assign_strptr( name ); + newnode->type->symbolic->isTypedef = false; + newnode->type->symbolic->actuals = params; + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newTypeParam( TypeClass tc, std::string* name ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->name = assign_strptr( name ); + newnode->type = new TypeData( TypeData::Variable ); + newnode->type->variable->tyClass = tc; + newnode->type->variable->name = newnode->name; + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Aggregate ); + newnode->type->aggregate->kind = Context; + newnode->type->aggregate->params = params; + newnode->type->aggregate->members = asserts; + newnode->type->aggregate->name = assign_strptr( name ); + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newContextUse( std::string *name, ExpressionNode *params ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::AggregateInst ); + newnode->type->aggInst->aggregate = new TypeData( TypeData::Aggregate ); + newnode->type->aggInst->aggregate->aggregate->kind = Context; + newnode->type->aggInst->aggregate->aggregate->name = assign_strptr( name ); + newnode->type->aggInst->params = params; + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->name = assign_strptr( name ); + newnode->type = new TypeData( TypeData::Symbolic ); + newnode->type->symbolic->isTypedef = false; + newnode->type->symbolic->params = typeParams; + newnode->type->symbolic->name = newnode->name; + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newPointer( DeclarationNode *qualifiers ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Pointer ); + return newnode->addQualifiers( qualifiers ); +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Array ); + newnode->type->array->dimension = size; + newnode->type->array->isStatic = isStatic; + newnode->type->array->isVarLen = false; + return newnode->addQualifiers( qualifiers ); +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newVarArray( DeclarationNode *qualifiers ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Array ); + newnode->type->array->dimension = 0; + newnode->type->array->isStatic = false; + newnode->type->array->isVarLen = true; + return newnode->addQualifiers( qualifiers ); +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newBitfield( ExpressionNode *size ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->bitfieldWidth = size; + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newTuple( DeclarationNode *members ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Tuple ); + newnode->type->tuple->members = members; + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newTypeof( ExpressionNode *expr ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Typeof ); + newnode->type->typeexpr->expr = expr; + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newAttr( std::string *name, ExpressionNode *expr ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Attr ); + newnode->type->attr->name = assign_strptr( name ); + newnode->type->attr->expr = expr; + return newnode; +} + +/* static class method */ +DeclarationNode * +DeclarationNode::newAttr( std::string *name, DeclarationNode *type ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Attr ); + newnode->type->attr->name = assign_strptr( name ); + newnode->type->attr->type = type; + return newnode; +} + +static void +addQualifiersToType( TypeData *&src, TypeData *dst ) +{ + if( src && dst ) { + if( src->forall && dst->kind == TypeData::Function ) { + if( dst->forall ) { + dst->forall->appendList( src->forall ); + } else { + dst->forall = src->forall; + } + src->forall = 0; + } + if( dst->base ) { + addQualifiersToType( src, dst->base ); + } else if( dst->kind == TypeData::Function ) { + dst->base = src; + src = 0; + } else { + dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers ); + } + } +} + +DeclarationNode * +DeclarationNode::addQualifiers( DeclarationNode *q ) +{ + if( q ) { + storageClasses.splice( storageClasses.end(), q->storageClasses ); + if( q->type ) { + if( !type ) { + type = new TypeData; + } + addQualifiersToType( q->type, type ); + if( q->type && q->type->forall ) { + if( type->forall ) { + type->forall->appendList( q->type->forall ); + } else { + type->forall = q->type->forall; + } + q->type->forall = 0; + } + } + } + delete q; + return this; +} + +DeclarationNode * +DeclarationNode::copyStorageClasses( DeclarationNode *q ) +{ + storageClasses = q->storageClasses; + return this; +} + +static void +addTypeToType( TypeData *&src, TypeData *&dst ) +{ + if( src && dst ) { + if( src->forall && dst->kind == TypeData::Function ) { + if( dst->forall ) { + dst->forall->appendList( src->forall ); + } else { + dst->forall = src->forall; + } + src->forall = 0; + } + if( dst->base ) { + addTypeToType( src, dst->base ); + } else { + switch( dst->kind ) { + case TypeData::Unknown: + src->qualifiers.splice( src->qualifiers.end(), dst->qualifiers ); + dst = src; + src = 0; + break; + + case TypeData::Basic: + dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers ); + if( src->kind != TypeData::Unknown ) { + assert( src->kind == TypeData::Basic ); + dst->basic->modifiers.splice( dst->basic->modifiers.end(), src->basic->modifiers ); + dst->basic->typeSpec.splice( dst->basic->typeSpec.end(), src->basic->typeSpec ); + } + break; + + default: + switch( src->kind ) { + case TypeData::Aggregate: + case TypeData::Enum: + dst->base = new TypeData( TypeData::AggregateInst ); + dst->base->aggInst->aggregate = src; + if( src->kind == TypeData::Aggregate ) { + dst->base->aggInst->params = maybeClone( src->aggregate->actuals ); + } + dst->base->qualifiers.splice( dst->base->qualifiers.end(), src->qualifiers ); + src = 0; + break; + + default: + if( dst->forall ) { + dst->forall->appendList( src->forall ); + } else { + dst->forall = src->forall; + } + src->forall = 0; + dst->base = src; + src = 0; + } + } + } + } +} + +DeclarationNode * +DeclarationNode::addType( DeclarationNode *o ) +{ + if( o ) { + storageClasses.splice( storageClasses.end(), o->storageClasses ); + if ( o->type ) { + if( !type ) { + if( o->type->kind == TypeData::Aggregate || o->type->kind == TypeData::Enum ) { + type = new TypeData( TypeData::AggregateInst ); + type->aggInst->aggregate = o->type; + if( o->type->kind == TypeData::Aggregate ) { + type->aggInst->params = maybeClone( o->type->aggregate->actuals ); + } + type->qualifiers.splice( type->qualifiers.end(), o->type->qualifiers ); + } else { + type = o->type; + } + o->type = 0; + } else { + addTypeToType( o->type, type ); + } + } + if( o->bitfieldWidth ) { + bitfieldWidth = o->bitfieldWidth; + } + } + delete o; + return this; +} + +DeclarationNode * +DeclarationNode::addTypedef() +{ + TypeData *newtype = new TypeData( TypeData::Symbolic ); + newtype->symbolic->params = 0; + newtype->symbolic->isTypedef = true; + newtype->symbolic->name = name; + newtype->base = type; + type = newtype; + return this; +} + +DeclarationNode * +DeclarationNode::addAssertions( DeclarationNode* assertions ) +{ + assert( type ); + switch( type->kind ) { + case TypeData::Symbolic: + if( type->symbolic->assertions ) { + type->symbolic->assertions->appendList( assertions ); + } else { + type->symbolic->assertions = assertions; + } + break; + + case TypeData::Variable: + if( type->variable->assertions ) { + type->variable->assertions->appendList( assertions ); + } else { + type->variable->assertions = assertions; + } + break; + + default: + assert( false ); + } + + return this; +} + +DeclarationNode * +DeclarationNode::addName( std::string* newname ) +{ + name = assign_strptr( newname ); + return this; +} + +DeclarationNode * +DeclarationNode::addBitfield( ExpressionNode *size ) +{ + bitfieldWidth = size; + return this; +} + +DeclarationNode * +DeclarationNode::addVarArgs() +{ + assert( type ); + hasEllipsis = true; + return this; +} + +DeclarationNode * +DeclarationNode::addFunctionBody( StatementNode *body ) +{ + assert( type ); + assert( type->kind == TypeData::Function ); + assert( type->function->body == 0 ); + type->function->body = body; + type->function->hasBody = true; + return this; +} + +DeclarationNode * +DeclarationNode::addOldDeclList( DeclarationNode *list ) +{ + assert( type ); + assert( type->kind == TypeData::Function ); + assert( type->function->oldDeclList == 0 ); + type->function->oldDeclList = list; + return this; +} + +static void +setBase( TypeData *&type, TypeData *newType ) +{ + if( type ) { + TypeData *prevBase = type; + TypeData *curBase = type->base; + while( curBase != 0 ) { + prevBase = curBase; + curBase = curBase->base; + } + prevBase->base = newType; + } else { + type = newType; + } +} + +DeclarationNode * +DeclarationNode::addPointer( DeclarationNode *p ) +{ + if( p ) { + assert( p->type->kind == TypeData::Pointer ); + setBase( type, p->type ); + p->type = 0; + delete p; + } + return this; +} + +DeclarationNode * +DeclarationNode::addArray( DeclarationNode *a ) +{ + if( a ) { + assert( a->type->kind == TypeData::Array ); + setBase( type, a->type ); + a->type = 0; + delete a; + } + return this; +} + +DeclarationNode * +DeclarationNode::addNewPointer( DeclarationNode *p ) +{ + if( p ) { + assert( p->type->kind == TypeData::Pointer ); + if( type ) { + switch( type->kind ) { + case TypeData::Aggregate: + case TypeData::Enum: + p->type->base = new TypeData( TypeData::AggregateInst ); + p->type->base->aggInst->aggregate = type; + if( type->kind == TypeData::Aggregate ) { + p->type->base->aggInst->params = maybeClone( type->aggregate->actuals ); + } + p->type->base->qualifiers.splice( p->type->base->qualifiers.end(), type->qualifiers ); + break; + + default: + p->type->base = type; + } + type = 0; + } + delete this; + return p; + } else { + return this; + } +} + +static TypeData * +findLast( TypeData *a ) +{ + assert( a ); + TypeData *cur = a; + while( cur->base ) { + cur = cur->base; + } + return cur; +} + +DeclarationNode * +DeclarationNode::addNewArray( DeclarationNode *a ) +{ + if( a ) { + assert( a->type->kind == TypeData::Array ); + TypeData *lastArray = findLast( a->type ); + if( type ) { + switch( type->kind ) { + case TypeData::Aggregate: + case TypeData::Enum: + lastArray->base = new TypeData( TypeData::AggregateInst ); + lastArray->base->aggInst->aggregate = type; + if( type->kind == TypeData::Aggregate ) { + lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals ); + } + lastArray->base->qualifiers.splice( lastArray->base->qualifiers.end(), type->qualifiers ); + break; + + default: + lastArray->base = type; + } + type = 0; + } + delete this; + return a; + } else { + return this; + } +} + +DeclarationNode * +DeclarationNode::addParamList( DeclarationNode *params ) +{ + TypeData *ftype = new TypeData( TypeData::Function ); + ftype->function->params = params; + setBase( type, ftype ); + return this; +} + +static TypeData* +addIdListToType( TypeData *type, DeclarationNode *ids ) +{ + if( type ) { + if( type->kind != TypeData::Function ) { + type->base = addIdListToType( type->base, ids ); + } else { + type->function->idList = ids; + } + return type; + } else { + TypeData *newtype = new TypeData( TypeData::Function ); + newtype->function->idList = ids; + return newtype; + } +} + +DeclarationNode * +DeclarationNode::addIdList( DeclarationNode *ids ) +{ + type = addIdListToType( type, ids ); + return this; +} + +DeclarationNode * +DeclarationNode::addInitializer( InitializerNode *init ) +{ + //assert + initializer = init; + return this; +} + +DeclarationNode * +DeclarationNode::cloneBaseType( string *newName ) +{ + DeclarationNode *newnode = new DeclarationNode; + TypeData *srcType = type; + while( srcType->base ) { + srcType = srcType->base; + } + newnode->type = maybeClone( srcType ); + if( newnode->type->kind == TypeData::AggregateInst ) { + // don't duplicate members + if( newnode->type->aggInst->aggregate->kind == TypeData::Enum ) { + delete newnode->type->aggInst->aggregate->enumeration->constants; + newnode->type->aggInst->aggregate->enumeration->constants = 0; + } else { + assert( newnode->type->aggInst->aggregate->kind == TypeData::Aggregate ); + delete newnode->type->aggInst->aggregate->aggregate->members; + newnode->type->aggInst->aggregate->aggregate->members = 0; + } + } + newnode->type->forall = maybeClone( type->forall ); + newnode->storageClasses = storageClasses; + newnode->name = assign_strptr( newName ); + return newnode; +} + +DeclarationNode * +DeclarationNode::cloneBaseType( DeclarationNode *o ) +{ + if( o ) { + o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() ); + if ( type ) { + TypeData *srcType = type; + while( srcType->base ) { + srcType = srcType->base; + } + TypeData *newType = srcType->clone(); + if( newType->kind == TypeData::AggregateInst ) { + // don't duplicate members + if( newType->aggInst->aggregate->kind == TypeData::Enum ) { + delete newType->aggInst->aggregate->enumeration->constants; + newType->aggInst->aggregate->enumeration->constants = 0; + } else { + assert( newType->aggInst->aggregate->kind == TypeData::Aggregate ); + delete newType->aggInst->aggregate->aggregate->members; + newType->aggInst->aggregate->aggregate->members = 0; + } + } + newType->forall = maybeClone( type->forall ); + if( !o->type ) { + o->type = newType; + } else { + addTypeToType( newType, o->type ); + delete newType; + } + } + } + return o; +} + +DeclarationNode * +DeclarationNode::cloneType( string *newName ) +{ + DeclarationNode *newnode = new DeclarationNode; + newnode->type = maybeClone( type ); + newnode->storageClasses = storageClasses; + newnode->name = assign_strptr( newName ); + return newnode; +} + +DeclarationNode * +DeclarationNode::cloneType( DeclarationNode *o ) +{ + if( o ) { + o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() ); + if ( type ) { + TypeData *newType = type->clone(); + if( !o->type ) { + o->type = newType; + } else { + addTypeToType( newType, o->type ); + delete newType; + } + } + } + return o; +} + +DeclarationNode * +DeclarationNode::appendList( DeclarationNode *node ) +{ + if( node != 0 ) { + set_link( node ); + } + return this; +} + +DeclarationNode* +DeclarationNode::extractAggregate() const +{ + if( type ) { + TypeData *ret = type->extractAggregate(); + if( ret ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->type = ret; + return newnode; + } else { + return 0; + } + } else { + return 0; + } +} + +void buildList( const DeclarationNode *firstNode, std::list< Declaration* > &outputList ) +{ + SemanticError errors; + std::back_insert_iterator< std::list< Declaration* > > out( outputList ); + const DeclarationNode *cur = firstNode; + while( cur ) { + try { + if( DeclarationNode *extr = cur->extractAggregate() ) { + // handle the case where a structure declaration is contained within an object or type + // declaration + Declaration *decl = extr->build(); + if( decl ) { + *out++ = decl; + } + } + Declaration *decl = cur->build(); + if( decl ) { + *out++ = decl; + } + } catch( SemanticError &e ) { + errors.append( e ); + } + cur = dynamic_cast< DeclarationNode* >( cur->get_link() ); + } + if( !errors.isEmpty() ) { + throw errors; + } +} + +void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType* > &outputList ) +{ + SemanticError errors; + std::back_insert_iterator< std::list< DeclarationWithType* > > out( outputList ); + const DeclarationNode *cur = firstNode; + while( cur ) { + try { +/// if( DeclarationNode *extr = cur->extractAggregate() ) { +/// // handle the case where a structure declaration is contained within an object or type +/// // declaration +/// Declaration *decl = extr->build(); +/// if( decl ) { +/// *out++ = decl; +/// } +/// } + Declaration *decl = cur->build(); + if( decl ) { + if( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) { + *out++ = dwt; + } else if( StructDecl *agg = dynamic_cast< StructDecl* >( decl ) ) { + StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() ); + *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 ); + delete agg; + } else if( UnionDecl *agg = dynamic_cast< UnionDecl* >( decl ) ) { + UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() ); + *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 ); + } + } + } catch( SemanticError &e ) { + errors.append( e ); + } + cur = dynamic_cast< DeclarationNode* >( cur->get_link() ); + } + if( !errors.isEmpty() ) { + throw errors; + } +} + +void buildTypeList( const DeclarationNode *firstNode, std::list< Type* > &outputList ) +{ + SemanticError errors; + std::back_insert_iterator< std::list< Type* > > out( outputList ); + const DeclarationNode *cur = firstNode; + while( cur ) { + try { + *out++ = cur->buildType(); + } catch( SemanticError &e ) { + errors.append( e ); + } + cur = dynamic_cast< DeclarationNode* >( cur->get_link() ); + } + if( !errors.isEmpty() ) { + throw errors; + } +} + +Declaration * +DeclarationNode::build() const +{ + + if( !type ) { + if( buildInline() ) { + throw SemanticError( "invalid inline specification in declaration of ", this ); + } else { + return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ); + } + } else { + Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildInline(), linkage, maybeBuild< Initializer >(initializer) ); + return newDecl; + } + // we should never get here + assert( false ); + return 0; +} + +Type * +DeclarationNode::buildType() const +{ + + assert( type ); + + switch( type->kind ) { + case TypeData::Enum: + return new EnumInstType( type->buildQualifiers(), type->enumeration->name ); + + case TypeData::Aggregate: { + ReferenceToType *ret; + switch( type->aggregate->kind ) { + case DeclarationNode::Struct: + 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 ); + } + buildList( type->aggregate->actuals, ret->get_parameters() ); + return ret; + } + + case TypeData::Symbolic: { + TypeInstType *ret = new TypeInstType( type->buildQualifiers(), type->symbolic->name, false ); + buildList( type->symbolic->actuals, ret->get_parameters() ); + return ret; + } + + default: + return type->build(); + } +} + +Declaration::StorageClass +DeclarationNode::buildStorageClass() const +{ + static const Declaration::StorageClass scMap[] = { + Declaration::Static, + Declaration::Auto, + Declaration::Extern, + Declaration::Register, + Declaration::NoStorageClass, // inline + Declaration::Fortran + }; + + Declaration::StorageClass ret = Declaration::NoStorageClass; + for( std::list< StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) { + assert( unsigned( *i ) < sizeof( scMap ) / sizeof( scMap[0] ) ); + if( *i == Inline ) continue; + if( ret == Declaration::NoStorageClass ) { + ret = scMap[ *i ]; + } else { + throw SemanticError( "invalid combination of storage classes in declaration of ", this ); + } + } + return ret; +} + +bool +DeclarationNode::buildInline() const +{ + std::list< StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), Inline ); + if( first == storageClasses.end() ) { + return false; + } else { + std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline ); + if( next == storageClasses.end() ) { + return true; + } else { + throw SemanticError( "duplicate inline specification in declaration of ", this ); + } + } + // we should never get here + return false; +} Index: translator/Parser/ExpressionNode.cc =================================================================== --- translator/Parser/ExpressionNode.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) +++ translator/Parser/ExpressionNode.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) @@ -0,0 +1,804 @@ +/* -*- C++ -*- */ +#include +#include +#include + +#include "ParseNode.h" +#include "SynTree/Type.h" +#include "SynTree/Constant.h" +#include "SynTree/Expression.h" +#include "SynTree/Declaration.h" +#include "UnimplementedError.h" +#include "parseutility.h" +#include "utility.h" + +using namespace std; + +ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) { +} + +ExpressionNode::ExpressionNode(string *name_) : ParseNode( *name_ ), argName( 0 ) { + delete name_; +} + +ExpressionNode::ExpressionNode( const ExpressionNode &other ) + : ParseNode( other.name ) +{ + if( other.argName ) { + argName = other.argName->clone(); + } else { + argName = 0; + } +} + +ExpressionNode * ExpressionNode::set_asArgName( std::string *aName ) { + argName = new VarRefNode(aName); + return this; +} + +ExpressionNode * ExpressionNode::set_asArgName( ExpressionNode *aDesignator ) { + argName = aDesignator; + return this; +} + +void ExpressionNode::printDesignation( std::ostream &os, int indent ) const { + if( argName ) { + os << string(' ', indent) << "(designated by: "; + argName->printOneLine(os, indent ); + os << ")" << std::endl; + } +} + +NullExprNode::NullExprNode() +{ +} + +NullExprNode * +NullExprNode::clone() const +{ + return new NullExprNode(); +} + +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); + os << "null"; +} + +Expression * +NullExprNode::build() const +{ + return 0; +} + +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) +{ + if( inVal ) { + value = *inVal; + delete inVal; + } else { + value = ""; + } + + classify(value); +} + +ConstantNode::ConstantNode( const ConstantNode &other ) + : ExpressionNode( other ), type( other.type ), value( other.value ), sign( other.sign ), base( other.base ), longs( other.longs ), size( other.size ) +{ +} + +// for some reason, std::tolower doesn't work as an argument to std::transform in g++ 3.1 +inline char +tolower_hack( char c ) +{ + return std::tolower( c ); +} + +void ConstantNode::classify(std::string &str){ + switch(type){ + case Integer: + case Float: + { + std::string sfx(""); + char c; + int i = str.length() - 1; + + while( i >= 0 && !isxdigit(c = str.at(i--)) ) + sfx += c; + + value = str.substr( 0, i + 2 ); + + // get rid of underscores + 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 ){ + longs = 1; + } + + assert((longs >= 0) && (longs <= 2)); + + if( sfx.find("u") != string::npos ) + sign = false; + + break; + } + case Character: + { + // remove underscores from hex and oct escapes + if(str.substr(1,2) == "\\x") + value.erase(remove(value.begin(), value.end(), '_'), value.end()); + + break; + } + default: + // shouldn't be here + ; + } +} + +ConstantNode::Type ConstantNode::get_type(void) const { + return type; +} + +ConstantNode* +ConstantNode::append( std::string *newValue ) +{ + if( newValue ) { + if (type == String){ + std::string temp = *newValue; + value.resize( value.size() - 1 ); + value += newValue->substr(1, newValue->size()); + } else + value += *newValue; + + delete newValue; + } + return this; +} + +void ConstantNode::printOneLine(std::ostream &os, int indent ) const +{ + os << string(indent, ' '); + printDesignation(os); + + switch( type ) { + /* integers */ + case Integer: + os << value ; + break; + case Float: + os << value ; + break; + + case Character: + os << "'" << value << "'"; + break; + + case String: + os << '"' << value << '"'; + break; + } + + os << ' '; +} + +void ConstantNode::print(std::ostream &os, int indent ) const +{ + printOneLine( os, indent ); + os << endl; +} + +Expression *ConstantNode::build() const { + ::Type::Qualifiers q; + BasicType *bt; + + switch(get_type()){ + case Integer: + /* Cfr. standard 6.4.4.1 */ + //bt.set_kind(BasicType::SignedInt); + bt = new BasicType(q, BasicType::SignedInt); + break; + + case Float: + bt = new BasicType(q, BasicType::Float); + break; + + case Character: + bt = new BasicType(q, BasicType::Char); + break; + + case String: + // string should probably be a primitive type + ArrayType *at; + std::string value = get_value(); + 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(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 ) +{ +} + +Expression *VarRefNode::build() const { + return new NameExpr( get_name(), maybeBuild< Expression >( get_argName() ) ); +} + +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: "; + + os << "Variable: " << get_name(); + + os << endl; +} + + +OperatorNode::OperatorNode(Type t):type(t) {} + +OperatorNode::OperatorNode( const OperatorNode &other ) + : ExpressionNode( other ), type( other.type ) +{ +} + +OperatorNode::~OperatorNode() {} + +OperatorNode::Type OperatorNode::get_type(void) const{ + return type; +} + +void OperatorNode::printOneLine( std::ostream &os, int indent ) const +{ + printDesignation(os); + os << OpName[ type ] << ' '; +} + +void OperatorNode::print( std::ostream &os, int indent ) const{ + printDesignation(os); + os << '\r' << string(indent, ' ') << "Operator: " << OpName[type] << endl; + + return; +} + +std::string OperatorNode::get_typename(void) const{ + return string(OpName[ type ]); +} + +const char *OperatorNode::OpName[] = + { "TupleC", "Comma", "TupleFieldSel",// "TuplePFieldSel", //n-adic + // triadic + "Cond", "NCond", + // diadic + "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", + // monadic + "UnPlus", "UnMinus", "AddressOf", "PointTo", "Neg", "BitNeg", "Incr", "IncrPost", "Decr", "DecrPost", "LabelAddress" + }; + +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( const CompositeExprNode &other ) + : ExpressionNode( other ), function( maybeClone( other.function ) ) +{ + ParseNode *cur = other.arguments; + while( cur ) { + if( arguments ) { + arguments->set_link( cur->clone() ); + } else { + arguments = (ExpressionNode*)cur->clone(); + } + cur = cur->get_link(); + } +} + +CompositeExprNode::~CompositeExprNode() +{ + delete function; + delete arguments; +} + +// the names that users use to define operator functions +static const char *opFuncName[] = + { "", "", "", + "", "", + // diadic + "", "", "", "", "?+?", "?-?", "?*?", "?/?", "?%?", "", "", + "?|?", "?&?", "?^?", "", "?<>?", "??", "?<=?", + "?>=?", "?==?", "?!=?", "?=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", + "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?", "?[?]", "","","Range", + // monadic + "+?", "-?", "", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "LabAddress" + }; + +#include "utility.h" +Expression *CompositeExprNode::build() const { + OperatorNode *op; + std::list args; + + 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() )); + + } else { + + switch(op->get_type()){ + case OperatorNode::Incr: + case OperatorNode::Decr: + case OperatorNode::IncrPost: + case OperatorNode::DecrPost: + case OperatorNode::Assign: + case OperatorNode::MulAssn: + case OperatorNode::DivAssn: + case OperatorNode::ModAssn: + case OperatorNode::PlusAssn: + case OperatorNode::MinusAssn: + case OperatorNode::LSAssn: + case OperatorNode::RSAssn: + case OperatorNode::AndAssn: + case OperatorNode::ERAssn: + case OperatorNode::OrAssn: + // the rewrite rules for these expressions specify that the first argument has its address taken + assert( !args.empty() ); + args.front() = new AddressExpr( args.front() ); + break; + + default: + /* do nothing */ + ; + } + + switch(op->get_type()){ + + case OperatorNode::Incr: + case OperatorNode::Decr: + case OperatorNode::IncrPost: + case OperatorNode::DecrPost: + case OperatorNode::Assign: + case OperatorNode::MulAssn: + case OperatorNode::DivAssn: + case OperatorNode::ModAssn: + case OperatorNode::PlusAssn: + case OperatorNode::MinusAssn: + case OperatorNode::LSAssn: + case OperatorNode::RSAssn: + case OperatorNode::AndAssn: + case OperatorNode::ERAssn: + case OperatorNode::OrAssn: + case OperatorNode::Plus: + case OperatorNode::Minus: + case OperatorNode::Mul: + case OperatorNode::Div: + case OperatorNode::Mod: + case OperatorNode::BitOr: + case OperatorNode::BitAnd: + case OperatorNode::Xor: + case OperatorNode::LShift: + case OperatorNode::RShift: + case OperatorNode::LThan: + case OperatorNode::GThan: + case OperatorNode::LEThan: + case OperatorNode::GEThan: + case OperatorNode::Eq: + case OperatorNode::Neq: + case OperatorNode::Index: + case OperatorNode::Range: + case OperatorNode::UnPlus: + case OperatorNode::UnMinus: + case OperatorNode::PointTo: + case OperatorNode::Neg: + case OperatorNode::BitNeg: + case OperatorNode::LabelAddress: + return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args ); + + case OperatorNode::AddressOf: + assert( args.size() == 1 ); + assert( args.front() ); + + return new AddressExpr( args.front() ); + + case OperatorNode::Cast: + { + TypeValueNode * arg = dynamic_cast(get_args()); + assert( arg ); + + DeclarationNode *decl_node = arg->get_decl(); + ExpressionNode *expr_node = dynamic_cast(arg->get_link()); + + Type *targetType = decl_node->buildType(); + if( dynamic_cast< VoidType* >( targetType ) ) { + delete targetType; + return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) ); + } else { + return new CastExpr(expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) ); + } + } + + case OperatorNode::FieldSel: + { + 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; + } + /* else if ( memberTup != 0 ) + { + UntypedMemberExpr *ret = new UntypedMemberExpr(memberTup->get_name(), args.front()); + delete member; + return ret; + } */ + else + assert( false ); + } + + case OperatorNode::PFieldSel: + { + assert( args.size() == 2 ); + + NameExpr *member = dynamic_cast(args.back()); // modify for Tuples xxx + assert( member != 0 ); + + UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) ); + deref->get_args().push_back( args.front() ); + + UntypedMemberExpr *ret = new UntypedMemberExpr(member->get_name(), deref); + delete member; + return ret; + } + + case OperatorNode::AlignOf: + case OperatorNode::SizeOf: + { +/// 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()); + } + } + + case OperatorNode::Attr: + { + 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()); + } else { + return new AttrExpr(var->build(), args.back()); + } + } + + + case OperatorNode::CompLit: + throw UnimplementedError( "C99 compound literals" ); + + // the short-circuited operators + case OperatorNode::Or: + case 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); + std::list< Expression* >::const_iterator i = args.begin(); + Expression *arg1 = notZeroExpr( *i++ ); + Expression *arg2 = *i++; + Expression *arg3 = *i++; + return new ConditionalExpr( arg1, arg2, arg3 ); + } + + case OperatorNode::NCond: + throw UnimplementedError( "GNU 2-argument conditional expression" ); + + case OperatorNode::Comma: + { + assert(args.size() == 2); + std::list< Expression* >::const_iterator i = args.begin(); + Expression *ret = *i++; + while( i != args.end() ) { + ret = new CommaExpr( ret, *i++ ); + } + return ret; + } + + // Tuples + case OperatorNode::TupleC: + { + TupleExpr *ret = new TupleExpr(); + std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) ); + return ret; + } + + default: + // shouldn't happen + return 0; + } + } +} + +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() ) ) { + cur->printOneLine( os, indent ); + } + os << ") "; +} + +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, ' ') ; + if( arguments ) { + os << "... on arguments: " << endl; + arguments->printList(os, indent + ParseNode::indent_by); + } else + os << "... on no arguments: " << endl; +} + +void CompositeExprNode::set_function(ExpressionNode *f){ + function = f; +} + +void CompositeExprNode::set_args(ExpressionNode *args){ + arguments = args; +} + +ExpressionNode *CompositeExprNode::get_function(void) const { + return function; +} + +ExpressionNode *CompositeExprNode::get_args(void) const { + return arguments; +} + +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); + + return this; +} + +CommaExprNode::CommaExprNode( const CommaExprNode &other ) + : CompositeExprNode( other ) +{ +} + +ValofExprNode::ValofExprNode(StatementNode *s): body(s) {} + +ValofExprNode::ValofExprNode( const ValofExprNode &other ) + : ExpressionNode( other ), body( maybeClone( body ) ) +{ +} + +ValofExprNode::~ValofExprNode() { + delete body; +} + +void ValofExprNode::print( std::ostream &os, int indent ) const { + printDesignation(os); + os << string(indent, ' ') << "Valof Expression:" << std::endl; + get_body()->print(os, indent + 4); +} + +void ValofExprNode::printOneLine( std::ostream &, int indent ) const +{ + assert( false ); +} + +Expression *ValofExprNode::build() const { + return new UntypedValofExpr ( get_body()->build(), maybeBuild< Expression >( get_argName() ) ); +} + +ForCtlExprNode::ForCtlExprNode(ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr) + throw (SemanticError) + : condition(cond), change(incr) +{ + if(init_ == 0) + init = 0; + else { + DeclarationNode *decl; + 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); + else + throw SemanticError("Error in for control expression"); + } +} + +ForCtlExprNode::ForCtlExprNode( const ForCtlExprNode &other ) + : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) ) +{ +} + +ForCtlExprNode::~ForCtlExprNode(){ + delete init; + delete condition; + delete change; +} + +Expression *ForCtlExprNode::build() const { + // this shouldn't be used! + assert( false ); + return 0; +} + +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); +} + +void +ForCtlExprNode::printOneLine( std::ostream &, int indent ) const +{ + assert( false ); +} + +TypeValueNode::TypeValueNode(DeclarationNode *decl) + : decl( decl ) +{ +} + +TypeValueNode::TypeValueNode( const TypeValueNode &other ) + : ExpressionNode( other ), decl( maybeClone( other.decl ) ) +{ +} + +Expression * +TypeValueNode::build() const +{ + return new TypeExpr( decl->buildType() ); +} + +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 +{ + os << "Type:"; + get_decl()->print(os, indent + 2); +} + +ExpressionNode *flattenCommas( ExpressionNode *list ) +{ + if( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) + { + OperatorNode *op; + if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::Comma) ) + { + if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) ) + composite->add_arg( next ); + return flattenCommas( composite->get_args() ); + } + } + + if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) ) + list->set_next( flattenCommas( next ) ); + + return list; +} + +ExpressionNode *tupleContents( ExpressionNode *tuple ) +{ + if( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) { + OperatorNode *op = 0; + if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::TupleC) ) + return composite->get_args(); + } + return tuple; +} Index: translator/Parser/InitializerNode.cc =================================================================== --- translator/Parser/InitializerNode.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) +++ translator/Parser/InitializerNode.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) @@ -0,0 +1,103 @@ +#include "ParseNode.h" +#include "SynTree/Expression.h" +#include "SynTree/Initializer.h" +#include "utility.h" +#include "SemanticError.h" +// #include // for strtol +#include + + +InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des ) + : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ) +{ + if ( aggrp ) + kids = dynamic_cast< InitializerNode *>( get_link() ); + + if ( kids != 0 ) + set_link( 0 ); +} + +InitializerNode::InitializerNode( InitializerNode *init, bool aggrp, ExpressionNode *des ) + : aggregate( aggrp ), designator( des ), kids( 0 ) +{ + if (init != 0) + set_link(init); + + if ( aggrp ) + kids = dynamic_cast< InitializerNode *>( get_link() ); + + if ( kids != 0 ) + set_next( 0 ); +} + +InitializerNode::~InitializerNode() { + delete expr; +} + +void InitializerNode::print( std::ostream &os, int indent ) const { + os << std::string(indent, ' ') << "Initializer expression" << std::endl; +} + +void InitializerNode::printOneLine( std::ostream &os ) const { + if (!aggregate) + { + + if ( designator != 0 ) + { + os << "designated by: ("; + ExpressionNode *curdes = designator; + while( curdes != 0){ + curdes->printOneLine(os); + curdes = (ExpressionNode *)(curdes->get_link()); + if(curdes) os << ", "; + } + os << ")"; + } + + if (expr) expr->printOneLine(os); + } + else // It's an aggregate + { + os << "[--"; + if( next_init() != 0 ) + next_init()->printOneLine(os); + + if (aggregate) os << "--]"; + } + + InitializerNode * moreInit; + if ( get_link() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_link() ) ) != 0) ) + moreInit->printOneLine( os ); +} + +Initializer *InitializerNode::build() const { + // if ( get_expression() == 0 ) return 0; // XXX (?) + + if ( aggregate ) + { + assert( next_init() != 0 ); + + std::list< Initializer *> initlist; + buildList( next_init(), initlist ); + + std::list< Expression *> designlist; + if ( designator != 0 ) + buildList( designator, designlist ); + + return new ListInit( initlist, designlist ); + } + else + { + std::list< Expression *> designators; + + if ( designator != 0 ) + buildList( designator, designators ); + + if ( get_expression() != 0) + return new SingleInit( get_expression()->build(), designators ); + } + + return 0; +} + + Index: translator/Parser/LinkageSpec.cc =================================================================== --- translator/Parser/LinkageSpec.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) +++ translator/Parser/LinkageSpec.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) @@ -0,0 +1,111 @@ +/* + * This file is part of the Cforall project + * + * $Id: LinkageSpec.cc,v 1.3 2003/01/29 14:55:08 rcbilson Exp $ + * + */ + +#include +#include + +#include "LinkageSpec.h" +#include "SemanticError.h" + +/* static class method */ +LinkageSpec::Type +LinkageSpec::fromString( const std::string &stringSpec ) +{ + if( stringSpec == "\"Cforall\"" ) { + return Cforall; + } else if( stringSpec == "\"C\"" ) { + return C; + } else { + throw SemanticError( "Invalid linkage specifier " + stringSpec ); + } +} + +/* static class method */ +std::string +LinkageSpec::toString( LinkageSpec::Type linkage ) +{ + switch( linkage ) { + case Intrinsic: + return "intrinsic"; + + case Cforall: + return "Cforall"; + + case C: + return "C"; + + case AutoGen: + return "automatically generated"; + + case Compiler: + return "compiler built-in"; + } + assert( false ); + return ""; +} + +/* static class method */ +bool +LinkageSpec::isDecoratable( Type t ) +{ + switch( t ) { + case Intrinsic: + case Cforall: + case AutoGen: + return true; + + case C: + case Compiler: + return false; + } + assert( false ); + return false; +} + +/* static class method */ +bool +LinkageSpec::isGeneratable( Type t ) +{ + switch( t ) { + case Intrinsic: + case Cforall: + case AutoGen: + case C: + return true; + + case Compiler: + return false; + } + assert( false ); + return false; +} + +/* static class method */ +bool +LinkageSpec::isOverloadable( Type t ) +{ + return isDecoratable( t ); +} + +/* static class method */ +bool +LinkageSpec::isBuiltin( Type t ) +{ + switch( t ) { + case Cforall: + case AutoGen: + case C: + return false; + + case Intrinsic: + case Compiler: + return true; + } + assert( false ); + return false; +} + Index: translator/Parser/LinkageSpec.h =================================================================== --- translator/Parser/LinkageSpec.h (revision 51b734528489f81a5af985bfee9aa3b6625b9774) +++ translator/Parser/LinkageSpec.h (revision 51b734528489f81a5af985bfee9aa3b6625b9774) @@ -0,0 +1,33 @@ +/* + * This file is part of the Cforall project + * + * $Id: LinkageSpec.h,v 1.3 2003/01/29 14:55:08 rcbilson Exp $ + * + */ + +#ifndef LINKAGESPEC_H +#define LINKAGESPEC_H + +#include + +struct LinkageSpec +{ + enum Type + { + Intrinsic, // C built-in defined in prelude + Cforall, // ordinary + C, // not overloadable, not mangled + AutoGen, // built by translator (struct assignment) + Compiler // gcc internal + }; + + static Type fromString( const std::string& ); + static std::string toString( Type ); + + static bool isDecoratable( Type ); + static bool isGeneratable( Type ); + static bool isOverloadable( Type ); + static bool isBuiltin( Type ); +}; + +#endif /* #ifndef LINKAGESPEC_H */ Index: translator/Parser/ParseNode.cc =================================================================== --- translator/Parser/ParseNode.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) +++ translator/Parser/ParseNode.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) @@ -0,0 +1,94 @@ +/* -*- C++ -*- */ +#include "ParseNode.h" +using namespace std; + +// Builder +int ParseNode::indent_by = 4; + +ParseNode::ParseNode(void): next( 0 ) {}; +ParseNode::ParseNode (string _name) : name(_name), next( 0 ) {} + +ParseNode *ParseNode::set_name (string _name) { + name = _name; + + return this; +} + +ParseNode *ParseNode::set_name (string *_name) { + name = *_name; // deep copy + delete _name; + + return this; +} + +ParseNode::~ParseNode(void){ + delete next; +}; + +string ParseNode::get_name(void) { + return name; +} + +ParseNode *ParseNode::get_link(void) const { + return next; +} + +ParseNode *ParseNode::get_last(void) { + ParseNode * current = this; + + while(current->get_link() != 0) + current = current->get_link(); + + return current; +} + +ParseNode *ParseNode::set_link(ParseNode *_next){ + ParseNode *follow; + + if(_next == 0) return this; + + for(follow = this; follow->next != 0; follow = follow->next); + follow->next = _next; + + return this; +} + +const string ParseNode::get_name(void) const { + return name; +} + +void ParseNode::print(std::ostream &os, int indent) const +{ +} + + +void ParseNode::printList(std::ostream &os, int indent) const +{ + print( os, indent ); + + if( next ) { + next->printList( os, indent ); + } +} + +ParseNode &ParseNode::operator,(ParseNode &p){ + set_link(&p); + + return *this; +} + +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) + */ + + return &pn; +} + + +// Local Variables: // +// mode: C++ // +// compile-command: "gmake" // +// End: // Index: translator/Parser/ParseNode.h =================================================================== --- translator/Parser/ParseNode.h (revision 51b734528489f81a5af985bfee9aa3b6625b9774) +++ translator/Parser/ParseNode.h (revision 51b734528489f81a5af985bfee9aa3b6625b9774) @@ -0,0 +1,516 @@ +#ifndef PARSENODE_H +#define PARSENODE_H + +#include +#include +#include +#include + +#include "utility.h" +#include "SynTree/SynTree.h" +#include "SynTree/Declaration.h" +#include "SemanticError.h" +#include "UniqueName.h" + +class ExpressionNode; +class CompositeExprNode; +class CommaExprNode; +class StatementNode; +class CompoundStmtNode; +class DeclarationNode; +class InitializerNode; + +// 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 &); + +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; +}; + +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; +}; + +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; +}; + +class OperatorNode : public ExpressionNode { +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; } + +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; +}; + +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 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; +}; + +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; +}; + +class NullStmtNode : public CompoundStmtNode { +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; +}; + + + +template< typename SynTreeType, typename NodeType > +void +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; + } +} + +// 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 ); + +// in ExpressionNode.cc +ExpressionNode *flattenCommas( ExpressionNode *list ); +ExpressionNode *tupleContents( ExpressionNode *tuple ); + +#endif /* #ifndef PARSENODE_H */ + +// Local Variables: // +// mode: C++ // +// compile-command: "gmake" // +// End: // Index: translator/Parser/Parser.cc =================================================================== --- translator/Parser/Parser.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) +++ translator/Parser/Parser.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) @@ -0,0 +1,73 @@ +/* + * This file is part of the Cforall project + * + * $Id: Parser.cc,v 1.6 2002/11/15 20:07:18 rcbilson Exp $ + * + */ + +#include "Parser.h" +#include "TypedefTable.h" +#include "lex.h" +#include "cfa.tab.h" + +/* global variables in cfa.y */ +extern int yyparse(void); + +extern int yydebug; +extern LinkageSpec::Type linkage; + +extern TypedefTable typedefTable; +extern DeclarationNode *theTree; +/* end of globals */ + +Parser *Parser::theParser = 0; + +Parser::Parser(): parseTree( 0 ), parseStatus( 1 ) {} + +Parser::~Parser() +{ + delete parseTree; +} + +/* static class method */ +Parser & +Parser::get_parser() +{ + if( theParser == 0 ) { + theParser = new Parser; + } + return *theParser; +} + +void +Parser::parse( FILE *input ) +{ + extern FILE *yyin; + yyin = input; + extern int yylineno; + yylineno = 1; + typedefTable.enterScope(); + parseStatus = yyparse(); + parseTree = theTree; +} + +void +Parser::set_debug( bool debug ) +{ + yydebug = debug; +} + +void +Parser::set_linkage( LinkageSpec::Type linkage ) +{ + ::linkage = linkage; +} + + +void +Parser::freeTree() +{ + delete parseTree; + parseTree = 0; +} + Index: translator/Parser/Parser.h =================================================================== --- translator/Parser/Parser.h (revision 51b734528489f81a5af985bfee9aa3b6625b9774) +++ translator/Parser/Parser.h (revision 51b734528489f81a5af985bfee9aa3b6625b9774) @@ -0,0 +1,46 @@ +/* + * This file is part of the Cforall project + * + * A singleton class to encapsulate the bison-generated parser + * + * $Id: Parser.h,v 1.4 2002/09/09 16:47:14 rcbilson Exp $ + * + */ + +#ifndef PARSER_H +#define PARSER_H + +#include + +#include "Parser/ParseNode.h" +#include "LinkageSpec.h" + +class Parser +{ +public: + static Parser &get_parser(); + + /* do the actual parse */ + void parse( FILE *input ); + + /* accessors to return the result of the parse */ + DeclarationNode *get_parseTree() const { return parseTree; } + int get_parseStatus() const { return parseStatus; } + + /* mutators to control parse options */ + void set_debug( bool debug ); + void set_linkage( LinkageSpec::Type linkage ); + + /* free the parse tree without actually destroying the parser */ + void freeTree(); + + ~Parser(); + +private: + Parser(); + static Parser *theParser; + DeclarationNode *parseTree; + int parseStatus; +}; + +#endif /* #ifndef PARSER_H */ Index: translator/Parser/StatementNode.cc =================================================================== --- translator/Parser/StatementNode.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) +++ translator/Parser/StatementNode.cc (revision 51b734528489f81a5af985bfee9aa3b6625b9774) @@ -0,0 +1,437 @@ +/* -*- C++ -*- */ +#include +#include +#include + +#include "ParseNode.h" +#include "SynTree/Statement.h" +#include "SynTree/Expression.h" +#include "parseutility.h" +#include "utility.h" + +using namespace std; + +const char *StatementNode::StType[] = + { "Exp", "If", "Switch", "Case", "Default", "Choose", "Fallthru", + "While", "Do", "For", + "Goto", "Continue", "Break", "Return", "Throw", + "Try", "Catch", "Finally", "Asm", + "Decl" + }; + +StatementNode::StatementNode(void) : + ParseNode(), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {} + +StatementNode::StatementNode(string name_) : + ParseNode(name_), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {} + +StatementNode::StatementNode( DeclarationNode *decl ) : + type( Decl ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), isCatchRest ( false ) +{ + if( decl ) { + if( DeclarationNode *agg = decl->extractAggregate() ) { + this->decl = agg; + StatementNode *nextStmt = new StatementNode; + nextStmt->type = Decl; + nextStmt->decl = decl; + next = nextStmt; + if( decl->get_link() ) { + next->set_next( new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) ) ); + decl->set_next( 0 ); + } + } else { + if( decl->get_link() ) { + next = new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) ); + decl->set_next( 0 ); + } + this->decl = decl; + } + } +} + +StatementNode::StatementNode(Type t, ExpressionNode *ctrl_label, StatementNode *block_ ) : + type(t), control(ctrl_label), block(block_), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) +{ + if (t == Default) + control = 0; +} + +StatementNode::StatementNode(Type t, string *_target) : + type(t), control(0), block(0), labels( 0 ), target(_target), decl( 0 ), isCatchRest ( false ) {} + +StatementNode::~StatementNode(void){ + delete control; + delete block; + delete labels; + delete target; + delete decl; +} + +StatementNode * StatementNode::newCatchStmt(DeclarationNode *d, StatementNode *s, bool catchRestP ) { + StatementNode *ret = new StatementNode( StatementNode::Catch, 0, s ); + ret->addDeclaration( d ); + ret->setCatchRest( catchRestP ); + + return ret; +} + +std::string StatementNode::get_target() const{ + if(target) + return *target; + + return string(""); +} + +StatementNode * +StatementNode::clone() const +{ + StatementNode *newnode = new StatementNode( type, maybeClone( control ), maybeClone( block ) ); + if( target ) { + newnode->target = new string( *target ); + } else { + newnode->target = 0; + } + newnode->decl = maybeClone( decl ); + return newnode; +} + +void StatementNode::set_control(ExpressionNode *c){ + control = c; +} + +StatementNode * StatementNode::set_block(StatementNode *b){ + block = b; + + return this; +} + +ExpressionNode *StatementNode::get_control(void) const { + return control; +} + +StatementNode *StatementNode::get_block(void) const { + return block; +} + +StatementNode::Type StatementNode::get_type(void) const { + return type; +} + +StatementNode *StatementNode::add_label(std::string *l){ + if(l != 0){ + if(labels == 0) + labels = new std::list(); + + labels->push_front(*l); + delete l; + } + + return this; +} + +std::list *StatementNode::get_labels() const +{ return labels; } + +StatementNode *StatementNode::add_controlexp(ExpressionNode *e){ + + if(control && e) + control->add_to_list(e); // xxx - check this + + return this; +} + +StatementNode *StatementNode::append_block(StatementNode *stmt){ + if( stmt != 0) { + if( block == 0 ) + block = stmt; + else + block->set_link(stmt); + } + return this; +} + + +StatementNode *StatementNode::append_last_case(StatementNode *stmt){ + if( stmt != 0 ) { + StatementNode *next = (StatementNode *)get_link(); + if ( next && ( next->get_type() == StatementNode::Case || next->get_type() == StatementNode::Default) ) + next->append_last_case ( stmt ); + else + if( block == 0 ) + block = stmt; + else + block->set_link(stmt); + } + + return this; +} + +void StatementNode::print( std::ostream &os, int indent ) const { + + if(labels != 0) + if(!labels->empty()){ + std::list::const_iterator i; + + os << '\r' << string(indent, ' '); + for( i = labels->begin(); i != labels->end(); i++ ) + os << *i << ":"; + os << endl; + } + + switch( type ) { + case Decl: + decl->print( os, indent ); + break; + + case Exp: + if( control ) { + os << string( indent, ' ' ); + control->print( os, indent ); + os << endl; + } else + os << string( indent, ' ' ) << "Null Statement" << endl; + break; + + default: + os << '\r' << string(indent, ' ') << StatementNode::StType[type] << endl; + + if ( type == Catch ) { + if( decl ){ + os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Declaration: " << endl; + decl->print( os, indent + 2*ParseNode::indent_by); + } else if ( isCatchRest ) { + os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Catches the rest " << endl; + } else { + ; // should never reach here + } + } + + if( control ){ + os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Expression: " << endl; + control->printList( os, indent + 2*ParseNode::indent_by); + } + + if( block ){ + os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Branches of execution: " << endl; + block->printList( os, indent + 2*ParseNode::indent_by); + } + + if( target ){ + os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Target: " << get_target() << endl; + } + + break; + } +} + +Statement *StatementNode::build() const { + + std::list branches; + std::list exps; + std::list