Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Parser/DeclarationNode.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,918 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// DeclarationNode.cc -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 12:34:05 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu May 21 09:28:54 2015 +// Update Count : 13 +// + +#include +#include +#include +#include +#include + +#include "TypeData.h" +#include "SynTree/Expression.h" + + +using namespace std; + +// These must remain in the same order as the corresponding DeclarationNode enumerations. +const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic" }; +const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary" }; +const char *DeclarationNode::modifierName[] = { "signed", "unsigned", "short", "long" }; +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 + "extern", + "static", + "auto", + "register", + "inline", + "fortran", +}; + +void DeclarationNode::print( std::ostream &os, int indent ) const { + os << string(indent, ' ' ); + if ( name == "" ) { + os << "unnamed: "; + } else { + os << name << ": "; + } + + 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; + } +} + +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; +} + +DeclarationNode *DeclarationNode::newQualifier( Qualifier q ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData(); + newnode->type->qualifiers.push_back( q ); + return newnode; +} + +DeclarationNode *DeclarationNode::newStorageClass( StorageClass sc ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->storageClasses.push_back( sc ); + return newnode; +} + +DeclarationNode *DeclarationNode::newBasicType( BasicType bt ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Basic ); + newnode->type->basic->typeSpec.push_back( bt ); + return newnode; +} + +DeclarationNode *DeclarationNode::newModifier( Modifier mod ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Basic ); + newnode->type->basic->modifiers.push_back( mod ); + return newnode; +} + +DeclarationNode *DeclarationNode::newForall( DeclarationNode* forall ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Unknown ); + newnode->type->forall = forall; + return newnode; +} + +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; +} + +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; +} + +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; +} + +DeclarationNode *DeclarationNode::newEnumConstant( std::string* name, ExpressionNode *constant ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->name = assign_strptr( name ); + // do something with the constant + return newnode; +} + +DeclarationNode *DeclarationNode::newName( std::string* name ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->name = assign_strptr( name ); + return newnode; +} + +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; +} + +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; +} + +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; +} + +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; +} + +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; +} + +DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Pointer ); + return newnode->addQualifiers( qualifiers ); +} + +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 ); +} + +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 ); +} + +DeclarationNode *DeclarationNode::newBitfield( ExpressionNode *size ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->bitfieldWidth = size; + return newnode; +} + +DeclarationNode *DeclarationNode::newTuple( DeclarationNode *members ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Tuple ); + newnode->type->tuple->members = members; + return newnode; +} + +DeclarationNode *DeclarationNode::newTypeof( ExpressionNode *expr ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Typeof ); + newnode->type->typeexpr->expr = expr; + return newnode; +} + +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; +} + +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; + } // if + } // if + 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; + } // if + } // if + Declaration *decl = cur->build(); + if ( decl ) { + *out++ = decl; + } // if + } catch( SemanticError &e ) { + errors.append( e ); + } // try + cur = dynamic_cast< DeclarationNode* >( cur->get_link() ); + } // while + if ( ! errors.isEmpty() ) { + throw errors; + } // if +} + +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 ); + } // if + } // if + } catch( SemanticError &e ) { + errors.append( e ); + } // try + cur = dynamic_cast< DeclarationNode* >( cur->get_link() ); + } // while + if ( ! errors.isEmpty() ) { + throw errors; + } // if +} + +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 ); + } // try + cur = dynamic_cast< DeclarationNode* >( cur->get_link() ); + } // while + if ( ! errors.isEmpty() ) { + throw errors; + } // if +} + +Declaration *DeclarationNode::build() const { + if ( type ) { + Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildInline(), linkage, maybeBuild< Initializer >(initializer) ); + return newDecl; + } // if + if ( ! buildInline() ) { + return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ); + } // if + throw SemanticError( "invalid inline specification in declaration of ", this ); +} + +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 ); + } // switch + 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(); + } // switch +} + +Declaration::StorageClass DeclarationNode::buildStorageClass() const { + static const Declaration::StorageClass scMap[] = { + Declaration::Extern, + Declaration::Static, + Declaration::Auto, + Declaration::Register, + Declaration::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 ) { + throw SemanticError( "invalid combination of storage classes in declaration of ", this ); + } + ret = scMap[ *i ]; + } + 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; + std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline ); + if ( next == storageClasses.end() ) return true; + throw SemanticError( "duplicate inline specification in declaration of ", this ); +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Parser/ExpressionNode.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,732 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ExpressionNode.cc -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 13:17:07 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat May 16 13:19:35 2015 +// Update Count : 2 +// + +#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; + } // if +} + +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; + } // if +} + +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 = ""; + } // if + + 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; + } // if + + 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; + } // if + 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(); + } // if + 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() ) ); + } // if + } + 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()); + } // if + } + 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()); + } // if + } + 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; +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Parser/InitializerNode.cc =================================================================== --- src/Parser/InitializerNode.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Parser/InitializerNode.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,111 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// InitializerNode.cc -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 13:20:24 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat May 16 13:21:40 2015 +// Update Count : 2 +// + +#include +#include +using namespace std; + +#include "ParseNode.h" +#include "SynTree/Expression.h" +#include "SynTree/Initializer.h" + +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 ) + : expr( 0 ), 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 << ", "; + } // while + os << ")"; + } // if + if ( expr ) expr->printOneLine(os); + } else { // It's an aggregate + os << "[--"; + if ( next_init() != 0 ) + next_init()->printOneLine(os); + if (aggregate) os << "--]"; + } // if + + 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 ); + } // if + + 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 ); + } // if + + return 0; +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Parser/LinkageSpec.cc =================================================================== --- src/Parser/LinkageSpec.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Parser/LinkageSpec.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,99 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// LinkageSpec.cc -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 13:22:09 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat May 16 13:23:21 2015 +// Update Count : 2 +// + +#include +#include + +#include "LinkageSpec.h" +#include "SemanticError.h" + +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 ); + } +} + +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 ""; +} + +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; +} + +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; +} + +bool LinkageSpec::isOverloadable( Type t ) { + return isDecoratable( t ); +} + +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; +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Parser/LinkageSpec.h =================================================================== --- src/Parser/LinkageSpec.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Parser/LinkageSpec.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,45 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// LinkageSpec.h -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 13:24:28 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat May 16 13:26:14 2015 +// Update Count : 3 +// + +#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 // LINKAGESPEC_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Parser/ParseNode.cc =================================================================== --- src/Parser/ParseNode.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Parser/ParseNode.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,101 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ParseNode.cc -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 13:26:29 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue May 19 16:48:30 2015 +// Update Count : 3 +// + +#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: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Parser/ParseNode.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,515 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ParseNode.h -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 13:28:16 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat May 16 13:30:24 2015 +// Update Count : 3 +// + +#ifndef PARSENODE_H +#define PARSENODE_H + +#include +#include +#include + +#include "utility.h" +#include "SynTree/Declaration.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() {} // cannot 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, Atomic, Attribute }; + enum StorageClass { Extern, Static, Auto, 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 { + } // if + } catch( SemanticError &e ) { + errors.append( e ); + } // try + cur = dynamic_cast< NodeType *>( cur->get_link() ); + } // while + if ( ! errors.isEmpty() ) { + throw errors; + } // if +} + +// in DeclarationNode.cc +void buildList( const DeclarationNode *firstNode, std::list< Declaration *> &outputList ); +void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList ); +void buildTypeList( const DeclarationNode *firstNode, std::list< Type *> &outputList ); + +// in ExpressionNode.cc +ExpressionNode *flattenCommas( ExpressionNode *list ); +ExpressionNode *tupleContents( ExpressionNode *tuple ); + +#endif // PARSENODE_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Parser/Parser.cc =================================================================== --- src/Parser/Parser.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Parser/Parser.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,70 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Parser.cc -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 14:54:28 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat May 16 14:55:59 2015 +// Update Count : 2 +// + +#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; + +Parser *Parser::theParser = 0; + +Parser::Parser(): parseTree( 0 ), parseStatus( 1 ) {} + +Parser::~Parser() { + delete parseTree; +} + +Parser &Parser::get_parser() { + if ( theParser == 0 ) { + theParser = new Parser; + } // if + 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; +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Parser/Parser.h =================================================================== --- src/Parser/Parser.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Parser/Parser.h (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,56 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Parser.h -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 14:56:50 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat May 16 14:58:56 2015 +// Update Count : 2 +// + +#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 // PARSER_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Parser/StatementNode.cc =================================================================== --- src/Parser/StatementNode.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) +++ src/Parser/StatementNode.cc (revision 843054c23fcb725d2486e5e42e91b3741bc523b8) @@ -0,0 +1,404 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// StatementNode.cc -- +// +// Author : Rodolfo G. Esteves +// Created On : Sat May 16 14:59:41 2015 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat May 16 15:10:45 2015 +// Update Count : 7 +// + +#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() : 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() { + 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() const { + return control; +} + +StatementNode *StatementNode::get_block() const { + return block; +} + +StatementNode::Type StatementNode::get_type() 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