Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 5e644d3ef72d65dc187491097854dec3ad90c16e) +++ src/Parser/DeclarationNode.cc (revision 8f6f47d7dda0117750908df7f55ff6a7f7349277) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Aug 28 22:12:44 2016 -// Update Count : 278 +// Last Modified On : Mon Aug 29 15:55:12 2016 +// Update Count : 311 // @@ -129,11 +129,11 @@ newnode->type = new TypeData( TypeData::Function ); - newnode->type->function->params = param; - newnode->type->function->newStyle = newStyle; - newnode->type->function->body = body; + newnode->type->function.params = param; + newnode->type->function.newStyle = newStyle; + newnode->type->function.body = body; typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID ); if ( body ) { - newnode->type->function->hasBody = true; + newnode->type->function.hasBody = true; } // if @@ -175,5 +175,5 @@ DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Basic ); - newnode->type->basic->typeSpec.push_back( bt ); + newnode->type->basic.typeSpec.push_back( bt ); return newnode; } // DeclarationNode::newBasicType @@ -182,21 +182,14 @@ DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Basic ); - newnode->type->basic->modifiers.push_back( mod ); + newnode->type->basic.modifiers.push_back( mod ); return newnode; } // DeclarationNode::newModifier -DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->type = new TypeData( TypeData::Builtin ); - newnode->type->builtin->type = bt; - return newnode; -} // DeclarationNode::newBuiltinType - 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; + newnode->type->symbolic.name = assign_strptr( name ); + newnode->type->symbolic.isTypedef = true; + newnode->type->symbolic.params = 0; return newnode; } // DeclarationNode::newFromTypedef @@ -205,12 +198,12 @@ 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 == "" ) { // anonymous aggregate ? - newnode->type->aggregate->name = anonymous.newName(); - } // if - newnode->type->aggregate->actuals = actuals; - newnode->type->aggregate->fields = fields; - newnode->type->aggregate->body = body; + newnode->type->aggregate.kind = kind; + newnode->type->aggregate.name = assign_strptr( name ); + if ( newnode->type->aggregate.name == "" ) { // anonymous aggregate ? + newnode->type->aggregate.name = anonymous.newName(); + } // if + newnode->type->aggregate.actuals = actuals; + newnode->type->aggregate.fields = fields; + newnode->type->aggregate.body = body; return newnode; } // DeclarationNode::newAggregate @@ -220,9 +213,9 @@ newnode->name = assign_strptr( name ); newnode->type = new TypeData( TypeData::Enum ); - newnode->type->enumeration->name = newnode->name; - if ( newnode->type->enumeration->name == "" ) { // anonymous enumeration ? - newnode->type->enumeration->name = DeclarationNode::anonymous.newName(); - } // if - newnode->type->enumeration->constants = constants; + newnode->type->enumeration.name = newnode->name; + if ( newnode->type->enumeration.name == "" ) { // anonymous enumeration ? + newnode->type->enumeration.name = DeclarationNode::anonymous.newName(); + } // if + newnode->type->enumeration.constants = constants; return newnode; } // DeclarationNode::newEnum @@ -245,7 +238,7 @@ 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; + newnode->type->symbolic.name = assign_strptr( name ); + newnode->type->symbolic.isTypedef = false; + newnode->type->symbolic.actuals = params; return newnode; } // DeclarationNode::newFromTypeGen @@ -255,6 +248,6 @@ newnode->name = assign_strptr( name ); newnode->type = new TypeData( TypeData::Variable ); - newnode->type->variable->tyClass = tc; - newnode->type->variable->name = newnode->name; + newnode->type->variable.tyClass = tc; + newnode->type->variable.name = newnode->name; return newnode; } // DeclarationNode::newTypeParam @@ -263,8 +256,8 @@ DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Aggregate ); - newnode->type->aggregate->kind = Trait; - newnode->type->aggregate->params = params; - newnode->type->aggregate->fields = asserts; - newnode->type->aggregate->name = assign_strptr( name ); + newnode->type->aggregate.kind = Trait; + newnode->type->aggregate.params = params; + newnode->type->aggregate.fields = asserts; + newnode->type->aggregate.name = assign_strptr( name ); return newnode; } // DeclarationNode::newTrait @@ -273,8 +266,8 @@ DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::AggregateInst ); - newnode->type->aggInst->aggregate = new TypeData( TypeData::Aggregate ); - newnode->type->aggInst->aggregate->aggregate->kind = Trait; - newnode->type->aggInst->aggregate->aggregate->name = assign_strptr( name ); - newnode->type->aggInst->params = params; + newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate ); + newnode->type->aggInst.aggregate->aggregate.kind = Trait; + newnode->type->aggInst.aggregate->aggregate.name = assign_strptr( name ); + newnode->type->aggInst.params = params; return newnode; } // DeclarationNode::newTraitUse @@ -284,7 +277,7 @@ 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; + newnode->type->symbolic.isTypedef = false; + newnode->type->symbolic.params = typeParams; + newnode->type->symbolic.name = newnode->name; return newnode; } // DeclarationNode::newTypeDecl @@ -299,10 +292,10 @@ DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Array ); - newnode->type->array->dimension = size; - newnode->type->array->isStatic = isStatic; - if ( newnode->type->array->dimension == 0 || newnode->type->array->dimension->isExpressionType() ) { - newnode->type->array->isVarLen = false; + newnode->type->array.dimension = size; + newnode->type->array.isStatic = isStatic; + if ( newnode->type->array.dimension == 0 || newnode->type->array.dimension->isExpressionType() ) { + newnode->type->array.isVarLen = false; } else { - newnode->type->array->isVarLen = true; + newnode->type->array.isVarLen = true; } // if return newnode->addQualifiers( qualifiers ); @@ -312,7 +305,7 @@ 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; + newnode->type->array.dimension = 0; + newnode->type->array.isStatic = false; + newnode->type->array.isVarLen = true; return newnode->addQualifiers( qualifiers ); } @@ -327,5 +320,5 @@ DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Tuple ); - newnode->type->tuple->members = members; + newnode->type->tuple = members; return newnode; } @@ -334,13 +327,20 @@ DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Typeof ); - newnode->type->typeexpr->expr = expr; - return newnode; -} + newnode->type->typeexpr = expr; + return newnode; +} + +DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Builtin ); + newnode->builtin = bt; + return newnode; +} // DeclarationNode::newBuiltinType 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; + newnode->type->attr.name = assign_strptr( name ); + newnode->type->attr.expr = expr; return newnode; } @@ -349,6 +349,6 @@ DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Attr ); - newnode->type->attr->name = assign_strptr( name ); - newnode->type->attr->type = type; + newnode->type->attr.name = assign_strptr( name ); + newnode->type->attr.type = type; return newnode; } @@ -407,7 +407,7 @@ } else { if ( type->kind == TypeData::Aggregate ) { - type->aggregate->params = q->type->forall; + type->aggregate.params = q->type->forall; // change implicit typedef from TYPEDEFname to TYPEGENname - typedefTable.changeKind( type->aggregate->name, TypedefTable::TG ); + typedefTable.changeKind( type->aggregate.name, TypedefTable::TG ); } else { type->forall = q->type->forall; @@ -457,6 +457,6 @@ 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 ); + dst->basic.modifiers.splice( dst->basic.modifiers.end(), src->basic.modifiers ); + dst->basic.typeSpec.splice( dst->basic.typeSpec.end(), src->basic.typeSpec ); } // if break; @@ -466,7 +466,7 @@ case TypeData::Enum: dst->base = new TypeData( TypeData::AggregateInst ); - dst->base->aggInst->aggregate = src; + dst->base->aggInst.aggregate = src; if ( src->kind == TypeData::Aggregate ) { - dst->base->aggInst->params = maybeClone( src->aggregate->actuals ); + dst->base->aggInst.params = maybeClone( src->aggregate.actuals ); } // if dst->base->qualifiers |= src->qualifiers; @@ -495,7 +495,7 @@ if ( o->type->kind == TypeData::Aggregate || o->type->kind == TypeData::Enum ) { type = new TypeData( TypeData::AggregateInst ); - type->aggInst->aggregate = o->type; + type->aggInst.aggregate = o->type; if ( o->type->kind == TypeData::Aggregate ) { - type->aggInst->params = maybeClone( o->type->aggregate->actuals ); + type->aggInst.params = maybeClone( o->type->aggregate.actuals ); } // if type->qualifiers |= o->type->qualifiers; @@ -523,7 +523,7 @@ DeclarationNode *DeclarationNode::addTypedef() { TypeData *newtype = new TypeData( TypeData::Symbolic ); - newtype->symbolic->params = 0; - newtype->symbolic->isTypedef = true; - newtype->symbolic->name = name; + newtype->symbolic.params = 0; + newtype->symbolic.isTypedef = true; + newtype->symbolic.name = name; newtype->base = type; type = newtype; @@ -535,15 +535,15 @@ switch ( type->kind ) { case TypeData::Symbolic: - if ( type->symbolic->assertions ) { - type->symbolic->assertions->appendList( assertions ); + if ( type->symbolic.assertions ) { + type->symbolic.assertions->appendList( assertions ); } else { - type->symbolic->assertions = assertions; + type->symbolic.assertions = assertions; } // if break; case TypeData::Variable: - if ( type->variable->assertions ) { - type->variable->assertions->appendList( assertions ); + if ( type->variable.assertions ) { + type->variable.assertions->appendList( assertions ); } else { - type->variable->assertions = assertions; + type->variable.assertions = assertions; } // if break; @@ -574,7 +574,7 @@ assert( type ); assert( type->kind == TypeData::Function ); - assert( type->function->body == 0 ); - type->function->body = body; - type->function->hasBody = true; + assert( type->function.body == 0 ); + type->function.body = body; + type->function.hasBody = true; return this; } @@ -583,6 +583,6 @@ assert( type ); assert( type->kind == TypeData::Function ); - assert( type->function->oldDeclList == 0 ); - type->function->oldDeclList = list; + assert( type->function.oldDeclList == 0 ); + type->function.oldDeclList = list; return this; } @@ -630,7 +630,7 @@ case TypeData::Enum: p->type->base = new TypeData( TypeData::AggregateInst ); - p->type->base->aggInst->aggregate = type; + p->type->base->aggInst.aggregate = type; if ( type->kind == TypeData::Aggregate ) { - p->type->base->aggInst->params = maybeClone( type->aggregate->actuals ); + p->type->base->aggInst.params = maybeClone( type->aggregate.actuals ); } // if p->type->base->qualifiers |= type->qualifiers; @@ -667,7 +667,7 @@ case TypeData::Enum: lastArray->base = new TypeData( TypeData::AggregateInst ); - lastArray->base->aggInst->aggregate = type; + lastArray->base->aggInst.aggregate = type; if ( type->kind == TypeData::Aggregate ) { - lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals ); + lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals ); } // if lastArray->base->qualifiers |= type->qualifiers; @@ -687,5 +687,5 @@ DeclarationNode *DeclarationNode::addParamList( DeclarationNode *params ) { TypeData *ftype = new TypeData( TypeData::Function ); - ftype->function->params = params; + ftype->function.params = params; setBase( type, ftype ); return this; @@ -697,10 +697,10 @@ type->base = addIdListToType( type->base, ids ); } else { - type->function->idList = ids; + type->function.idList = ids; } // if return type; } else { TypeData *newtype = new TypeData( TypeData::Function ); - newtype->function->idList = ids; + newtype->function.idList = ids; return newtype; } // if @@ -727,11 +727,11 @@ 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; + 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->fields; - newnode->type->aggInst->aggregate->aggregate->fields = 0; + assert( newnode->type->aggInst.aggregate->kind == TypeData::Aggregate ); + delete newnode->type->aggInst.aggregate->aggregate.fields; + newnode->type->aggInst.aggregate->aggregate.fields = 0; } // if } // if @@ -753,11 +753,11 @@ 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; + 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->fields; - newType->aggInst->aggregate->aggregate->fields = 0; + assert( newType->aggInst.aggregate->kind == TypeData::Aggregate ); + delete newType->aggInst.aggregate->aggregate.fields; + newType->aggInst.aggregate->aggregate.fields = 0; } // if } // if @@ -909,26 +909,26 @@ switch ( type->kind ) { case TypeData::Enum: - return new EnumInstType( buildQualifiers( type ), type->enumeration->name ); + return new EnumInstType( buildQualifiers( type ), type->enumeration.name ); case TypeData::Aggregate: { ReferenceToType *ret; - switch ( type->aggregate->kind ) { + switch ( type->aggregate.kind ) { case DeclarationNode::Struct: - ret = new StructInstType( buildQualifiers( type ), type->aggregate->name ); + ret = new StructInstType( buildQualifiers( type ), type->aggregate.name ); break; case DeclarationNode::Union: - ret = new UnionInstType( buildQualifiers( type ), type->aggregate->name ); + ret = new UnionInstType( buildQualifiers( type ), type->aggregate.name ); break; case DeclarationNode::Trait: - ret = new TraitInstType( buildQualifiers( type ), type->aggregate->name ); + ret = new TraitInstType( buildQualifiers( type ), type->aggregate.name ); break; default: assert( false ); } // switch - buildList( type->aggregate->actuals, ret->get_parameters() ); + buildList( type->aggregate.actuals, ret->get_parameters() ); return ret; } case TypeData::Symbolic: { - TypeInstType *ret = new TypeInstType( buildQualifiers( type ), type->symbolic->name, false ); - buildList( type->symbolic->actuals, ret->get_parameters() ); + TypeInstType *ret = new TypeInstType( buildQualifiers( type ), type->symbolic.name, false ); + buildList( type->symbolic.actuals, ret->get_parameters() ); return ret; } Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 5e644d3ef72d65dc187491097854dec3ad90c16e) +++ src/Parser/ParseNode.h (revision 8f6f47d7dda0117750908df7f55ff6a7f7349277) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Aug 28 21:14:51 2016 -// Update Count : 575 +// Last Modified On : Mon Aug 29 10:19:01 2016 +// Update Count : 579 // @@ -290,4 +290,6 @@ // bool buildFuncSpecifier( StorageClass key ) const; + BuiltinType builtin; + TypeData *type; std::string name; Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 5e644d3ef72d65dc187491097854dec3ad90c16e) +++ src/Parser/TypeData.cc (revision 8f6f47d7dda0117750908df7f55ff6a7f7349277) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Aug 28 18:28:58 2016 -// Update Count : 223 +// Last Modified On : Mon Aug 29 15:54:55 2016 +// Update Count : 266 // @@ -33,63 +33,63 @@ break; case Basic: - basic = new Basic_t; + // basic = new Basic_t; break; case Array: - array = new Array_t; - array->dimension = 0; - array->isVarLen = false; - array->isStatic = false; + // array = new Array_t; + array.dimension = 0; + array.isVarLen = false; + array.isStatic = false; break; case Function: - function = new Function_t; - function->params = 0; - function->idList = 0; - function->oldDeclList = 0; - function->body = 0; - function->hasBody = false; - function->newStyle = false; + // function = new Function_t; + function.params = 0; + function.idList = 0; + function.oldDeclList = 0; + function.body = 0; + function.hasBody = false; + function.newStyle = false; break; case Aggregate: - aggregate = new Aggregate_t; - aggregate->params = 0; - aggregate->actuals = 0; - aggregate->fields = 0; + // aggregate = new Aggregate_t; + aggregate.params = 0; + aggregate.actuals = 0; + aggregate.fields = 0; break; case AggregateInst: - aggInst = new AggInst_t; - aggInst->aggregate = 0; - aggInst->params = 0; + // aggInst = new AggInst_t; + aggInst.aggregate = 0; + aggInst.params = 0; break; case Enum: - enumeration = new Enumeration_t; - enumeration->constants = 0; + // enumeration = new Enumeration_t; + enumeration.constants = 0; break; case Symbolic: case SymbolicInst: - symbolic = new Symbolic_t; - symbolic->params = 0; - symbolic->actuals = 0; - symbolic->assertions = 0; + // symbolic = new Symbolic_t; + symbolic.params = 0; + symbolic.actuals = 0; + symbolic.assertions = 0; break; case Variable: - variable = new Variable_t; - variable->tyClass = DeclarationNode::Type; - variable->assertions = 0; + // variable = new Variable_t; + variable.tyClass = DeclarationNode::Type; + variable.assertions = 0; break; case Tuple: - tuple = new Tuple_t; - tuple->members = 0; + // tuple = new Tuple_t; + tuple = nullptr; break; case Typeof: - typeexpr = new Typeof_t; - typeexpr->expr = 0; + // typeexpr = new Typeof_t; + typeexpr = nullptr; break; case Builtin: - builtin = new Builtin_t; + // builtin = new Builtin_t; break; case Attr: - attr = new Attr_t; - attr->expr = 0; - attr->type = 0; + // attr = new Attr_t; + attr.expr = nullptr; + attr.type = nullptr; break; } // switch @@ -107,58 +107,58 @@ break; case Basic: - delete basic; + // delete basic; break; case Array: - delete array->dimension; - delete array; + delete array.dimension; + // delete array; break; case Function: - delete function->params; - delete function->idList; - delete function->oldDeclList; - delete function->body; - delete function; + delete function.params; + delete function.idList; + delete function.oldDeclList; + delete function.body; + // delete function; break; case Aggregate: - delete aggregate->params; - delete aggregate->actuals; - delete aggregate->fields; - delete aggregate; + delete aggregate.params; + delete aggregate.actuals; + delete aggregate.fields; + // delete aggregate; break; case AggregateInst: - delete aggInst->aggregate; - delete aggInst->params; - delete aggInst; + delete aggInst.aggregate; + delete aggInst.params; + // delete aggInst; break; case Enum: - delete enumeration->constants; - delete enumeration; + delete enumeration.constants; + // delete enumeration; break; case Symbolic: case SymbolicInst: - delete symbolic->params; - delete symbolic->actuals; - delete symbolic->assertions; - delete symbolic; + delete symbolic.params; + delete symbolic.actuals; + delete symbolic.assertions; + // delete symbolic; break; case Variable: - delete variable->assertions; - delete variable; + delete variable.assertions; + // delete variable; break; case Tuple: - delete tuple->members; + // delete tuple->members; delete tuple; break; case Typeof: - delete typeexpr->expr; + // delete typeexpr->expr; delete typeexpr; break; case Builtin: - delete builtin; + // delete builtin; break; case Attr: - delete attr->expr; - delete attr->type; - delete attr; + delete attr.expr; + delete attr.type; + // delete attr; break; } // switch @@ -178,61 +178,61 @@ break; case Basic: - newtype->basic->typeSpec = basic->typeSpec; - newtype->basic->modifiers = basic->modifiers; + newtype->basic.typeSpec = basic.typeSpec; + newtype->basic.modifiers = basic.modifiers; break; case Array: - newtype->array->dimension = maybeClone( array->dimension ); - newtype->array->isVarLen = array->isVarLen; - newtype->array->isStatic = array->isStatic; + newtype->array.dimension = maybeClone( array.dimension ); + newtype->array.isVarLen = array.isVarLen; + newtype->array.isStatic = array.isStatic; break; case Function: - newtype->function->params = maybeClone( function->params ); - newtype->function->idList = maybeClone( function->idList ); - newtype->function->oldDeclList = maybeClone( function->oldDeclList ); - newtype->function->body = maybeClone( function->body ); - newtype->function->hasBody = function->hasBody; - newtype->function->newStyle = function->newStyle; + newtype->function.params = maybeClone( function.params ); + newtype->function.idList = maybeClone( function.idList ); + newtype->function.oldDeclList = maybeClone( function.oldDeclList ); + newtype->function.body = maybeClone( function.body ); + newtype->function.hasBody = function.hasBody; + newtype->function.newStyle = function.newStyle; break; case Aggregate: - newtype->aggregate->params = maybeClone( aggregate->params ); - newtype->aggregate->actuals = maybeClone( aggregate->actuals ); - newtype->aggregate->fields = maybeClone( aggregate->fields ); - newtype->aggregate->name = aggregate->name; - newtype->aggregate->kind = aggregate->kind; - newtype->aggregate->body = aggregate->body; + newtype->aggregate.params = maybeClone( aggregate.params ); + newtype->aggregate.actuals = maybeClone( aggregate.actuals ); + newtype->aggregate.fields = maybeClone( aggregate.fields ); + newtype->aggregate.name = aggregate.name; + newtype->aggregate.kind = aggregate.kind; + newtype->aggregate.body = aggregate.body; break; case AggregateInst: - newtype->aggInst->aggregate = maybeClone( aggInst->aggregate ); - newtype->aggInst->params = maybeClone( aggInst->params ); + newtype->aggInst.aggregate = maybeClone( aggInst.aggregate ); + newtype->aggInst.params = maybeClone( aggInst.params ); break; case Enum: - newtype->enumeration->name = enumeration->name; - newtype->enumeration->constants = maybeClone( enumeration->constants ); + newtype->enumeration.name = enumeration.name; + newtype->enumeration.constants = maybeClone( enumeration.constants ); break; case Symbolic: case SymbolicInst: - newtype->symbolic->params = maybeClone( symbolic->params ); - newtype->symbolic->actuals = maybeClone( symbolic->actuals ); - newtype->symbolic->assertions = maybeClone( symbolic->assertions ); - newtype->symbolic->isTypedef = symbolic->isTypedef; - newtype->symbolic->name = symbolic->name; + newtype->symbolic.params = maybeClone( symbolic.params ); + newtype->symbolic.actuals = maybeClone( symbolic.actuals ); + newtype->symbolic.assertions = maybeClone( symbolic.assertions ); + newtype->symbolic.isTypedef = symbolic.isTypedef; + newtype->symbolic.name = symbolic.name; break; case Variable: - newtype->variable->assertions = maybeClone( variable->assertions ); - newtype->variable->name = variable->name; - newtype->variable->tyClass = variable->tyClass; + newtype->variable.assertions = maybeClone( variable.assertions ); + newtype->variable.name = variable.name; + newtype->variable.tyClass = variable.tyClass; break; case Tuple: - newtype->tuple->members = maybeClone( tuple->members ); + newtype->tuple = maybeClone( tuple ); break; case Typeof: - newtype->typeexpr->expr = maybeClone( typeexpr->expr ); + newtype->typeexpr = maybeClone( typeexpr ); break; case Builtin: - newtype->builtin->type = builtin->type; + // newtype->builtin = builtin; break; case Attr: - newtype->attr->expr = maybeClone( attr->expr ); - newtype->attr->type = maybeClone( attr->type ); + newtype->attr.expr = maybeClone( attr.expr ); + newtype->attr.type = maybeClone( attr.type ); break; } // switch @@ -268,15 +268,15 @@ break; case Basic: - printEnums( basic->modifiers.begin(), basic->modifiers.end(), DeclarationNode::modifierName, os ); - printEnums( basic->typeSpec.begin(), basic->typeSpec.end(), DeclarationNode::basicTypeName, os ); + printEnums( basic.modifiers.begin(), basic.modifiers.end(), DeclarationNode::modifierName, os ); + printEnums( basic.typeSpec.begin(), basic.typeSpec.end(), DeclarationNode::basicTypeName, os ); break; case Array: - if ( array->isStatic ) { + if ( array.isStatic ) { os << "static "; } // if - if ( array->dimension ) { + if ( array.dimension ) { os << "array of "; - array->dimension->printOneLine( os, indent ); - } else if ( array->isVarLen ) { + array.dimension->printOneLine( os, indent ); + } else if ( array.isVarLen ) { os << "variable-length array of "; } else { @@ -289,17 +289,17 @@ case Function: os << "function" << endl; - if ( function->params ) { + if ( function.params ) { os << string( indent + 2, ' ' ) << "with parameters " << endl; - function->params->printList( os, indent + 4 ); + function.params->printList( os, indent + 4 ); } else { os << string( indent + 2, ' ' ) << "with no parameters " << endl; } // if - if ( function->idList ) { + if ( function.idList ) { os << string( indent + 2, ' ' ) << "with old-style identifier list " << endl; - function->idList->printList( os, indent + 4 ); - } // if - if ( function->oldDeclList ) { + function.idList->printList( os, indent + 4 ); + } // if + if ( function.oldDeclList ) { os << string( indent + 2, ' ' ) << "with old-style declaration list " << endl; - function->oldDeclList->printList( os, indent + 4 ); + function.oldDeclList->printList( os, indent + 4 ); } // if os << string( indent + 2, ' ' ) << "returning "; @@ -310,68 +310,68 @@ } // if os << endl; - if ( function->hasBody ) { + if ( function.hasBody ) { os << string( indent + 2, ' ' ) << "with body " << endl; } // if - if ( function->body ) { - function->body->printList( os, indent + 2 ); + if ( function.body ) { + function.body->printList( os, indent + 2 ); } // if break; case Aggregate: - os << DeclarationNode::aggregateName[ aggregate->kind ] << ' ' << aggregate->name << endl; - if ( aggregate->params ) { + os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << aggregate.name << endl; + if ( aggregate.params ) { os << string( indent + 2, ' ' ) << "with type parameters " << endl; - aggregate->params->printList( os, indent + 4 ); - } // if - if ( aggregate->actuals ) { + aggregate.params->printList( os, indent + 4 ); + } // if + if ( aggregate.actuals ) { os << string( indent + 2, ' ' ) << "instantiated with actual parameters " << endl; - aggregate->actuals->printList( os, indent + 4 ); - } // if - if ( aggregate->fields ) { + aggregate.actuals->printList( os, indent + 4 ); + } // if + if ( aggregate.fields ) { os << string( indent + 2, ' ' ) << "with members " << endl; - aggregate->fields->printList( os, indent + 4 ); - } // if - if ( aggregate->body ) { + aggregate.fields->printList( os, indent + 4 ); + } // if + if ( aggregate.body ) { os << string( indent + 2, ' ' ) << " with body " << endl; } // if break; case AggregateInst: - if ( aggInst->aggregate ) { + if ( aggInst.aggregate ) { os << "instance of " ; - aggInst->aggregate->print( os, indent ); + aggInst.aggregate->print( os, indent ); } else { os << "instance of an unspecified aggregate "; } // if - if ( aggInst->params ) { + if ( aggInst.params ) { os << string( indent + 2, ' ' ) << "with parameters " << endl; - aggInst->params->printList( os, indent + 2 ); + aggInst.params->printList( os, indent + 2 ); } // if break; case Enum: os << "enumeration "; - if ( enumeration->constants ) { + if ( enumeration.constants ) { os << "with constants" << endl; - enumeration->constants->printList( os, indent + 2 ); + enumeration.constants->printList( os, indent + 2 ); } // if break; case SymbolicInst: - os << "instance of type " << symbolic->name; - if ( symbolic->actuals ) { + os << "instance of type " << symbolic.name; + if ( symbolic.actuals ) { os << " with parameters" << endl; - symbolic->actuals->printList( os, indent + 2 ); + symbolic.actuals->printList( os, indent + 2 ); } // if break; case Symbolic: - if ( symbolic->isTypedef ) { + if ( symbolic.isTypedef ) { os << "typedef definition "; } else { os << "type definition "; } // if - if ( symbolic->params ) { + if ( symbolic.params ) { os << endl << string( indent + 2, ' ' ) << "with parameters" << endl; - symbolic->params->printList( os, indent + 2 ); - } // if - if ( symbolic->assertions ) { + symbolic.params->printList( os, indent + 2 ); + } // if + if ( symbolic.assertions ) { os << endl << string( indent + 2, ' ' ) << "with assertions" << endl; - symbolic->assertions->printList( os, indent + 4 ); + symbolic.assertions->printList( os, indent + 4 ); os << string( indent + 2, ' ' ); } // if @@ -382,8 +382,8 @@ break; case Variable: - os << DeclarationNode::typeClassName[ variable->tyClass ] << " variable "; - if ( variable->assertions ) { + os << DeclarationNode::typeClassName[ variable.tyClass ] << " variable "; + if ( variable.assertions ) { os << endl << string( indent + 2, ' ' ) << "with assertions" << endl; - variable->assertions->printList( os, indent + 4 ); + variable.assertions->printList( os, indent + 4 ); os << string( indent + 2, ' ' ); } // if @@ -391,22 +391,22 @@ case Tuple: os << "tuple "; - if ( tuple->members ) { + if ( tuple ) { os << "with members " << endl; - tuple->members->printList( os, indent + 2 ); + tuple->printList( os, indent + 2 ); } // if break; case Typeof: os << "type-of expression "; - if ( typeexpr->expr ) { - typeexpr->expr->print( os, indent + 2 ); + if ( typeexpr ) { + typeexpr->print( os, indent + 2 ); } // if break; case Attr: - os << "attribute type decl " << attr->name << " applied to "; - if ( attr->expr ) { - attr->expr->print( os, indent + 2 ); - } // if - if ( attr->type ) { - attr->type->print( os, indent + 2 ); + os << "attribute type decl " << attr.name << " applied to "; + if ( attr.expr ) { + attr.expr->print( os, indent + 2 ); + } // if + if ( attr.type ) { + attr.type->print( os, indent + 2 ); } // if break; @@ -494,16 +494,16 @@ switch ( td->kind ) { case TypeData::Aggregate: - if ( ! toplevel && td->aggregate->fields ) { + if ( ! toplevel && td->aggregate.fields ) { ret = td->clone(); } // if break; case TypeData::Enum: - if ( ! toplevel && td->enumeration->constants ) { + if ( ! toplevel && td->enumeration.constants ) { ret = td->clone(); } // if break; case TypeData::AggregateInst: - if ( td->aggInst->aggregate ) { - ret = typeextractAggregate( td->aggInst->aggregate, false ); + if ( td->aggInst.aggregate ) { + ret = typeextractAggregate( td->aggInst.aggregate, false ); } // if break; @@ -535,9 +535,9 @@ BasicType::Kind ret; - for ( std::list< DeclarationNode::BasicType >::const_iterator i = td->basic->typeSpec.begin(); i != td->basic->typeSpec.end(); ++i ) { + for ( std::list< DeclarationNode::BasicType >::const_iterator i = td->basic.typeSpec.begin(); i != td->basic.typeSpec.end(); ++i ) { if ( ! init ) { init = true; if ( *i == DeclarationNode::Void ) { - if ( td->basic->typeSpec.size() != 1 || ! td->basic->modifiers.empty() ) { + if ( td->basic.typeSpec.size() != 1 || ! td->basic.modifiers.empty() ) { throw SemanticError( "invalid type specifier \"void\" in type: ", td ); } else { @@ -611,5 +611,5 @@ } // for - for ( std::list< DeclarationNode::Modifier >::const_iterator i = td->basic->modifiers.begin(); i != td->basic->modifiers.end(); ++i ) { + for ( std::list< DeclarationNode::Modifier >::const_iterator i = td->basic.modifiers.begin(); i != td->basic.modifiers.end(); ++i ) { switch ( *i ) { case DeclarationNode::Long: @@ -746,9 +746,9 @@ ArrayType * at; if ( td->base ) { - at = new ArrayType( buildQualifiers( td ), typebuild( td->base ), maybeBuild< Expression >( td->array->dimension ), - td->array->isVarLen, td->array->isStatic ); + at = new ArrayType( buildQualifiers( td ), typebuild( td->base ), maybeBuild< Expression >( td->array.dimension ), + td->array.isVarLen, td->array.isStatic ); } else { at = new ArrayType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ), - maybeBuild< Expression >( td->array->dimension ), td->array->isVarLen, td->array->isStatic ); + maybeBuild< Expression >( td->array.dimension ), td->array.isVarLen, td->array.isStatic ); } // if buildForall( td->forall, at->get_forall() ); @@ -759,16 +759,16 @@ assert( td->kind == TypeData::Aggregate ); AggregateDecl * at; - switch ( td->aggregate->kind ) { + switch ( td->aggregate.kind ) { case DeclarationNode::Struct: - at = new StructDecl( td->aggregate->name ); - buildForall( td->aggregate->params, at->get_parameters() ); + at = new StructDecl( td->aggregate.name ); + buildForall( td->aggregate.params, at->get_parameters() ); break; case DeclarationNode::Union: - at = new UnionDecl( td->aggregate->name ); - buildForall( td->aggregate->params, at->get_parameters() ); + at = new UnionDecl( td->aggregate.name ); + buildForall( td->aggregate.params, at->get_parameters() ); break; case DeclarationNode::Trait: - at = new TraitDecl( td->aggregate->name ); - buildList( td->aggregate->params, at->get_parameters() ); + at = new TraitDecl( td->aggregate.name ); + buildList( td->aggregate.params, at->get_parameters() ); break; default: @@ -776,6 +776,6 @@ } // switch - buildList( td->aggregate->fields, at->get_members() ); - at->set_body( td->aggregate->body ); + buildList( td->aggregate.fields, at->get_members() ); + at->set_body( td->aggregate.body ); return at; @@ -786,17 +786,17 @@ ReferenceToType * ret; - if ( td->aggInst->aggregate->kind == TypeData::Enum ) { - ret = new EnumInstType( buildQualifiers( td ), td->aggInst->aggregate->enumeration->name ); + if ( td->aggInst.aggregate->kind == TypeData::Enum ) { + ret = new EnumInstType( buildQualifiers( td ), td->aggInst.aggregate->enumeration.name ); } else { - assert( td->aggInst->aggregate->kind == TypeData::Aggregate ); - switch ( td->aggInst->aggregate->aggregate->kind ) { + assert( td->aggInst.aggregate->kind == TypeData::Aggregate ); + switch ( td->aggInst.aggregate->aggregate.kind ) { case DeclarationNode::Struct: - ret = new StructInstType( buildQualifiers( td ), td->aggInst->aggregate->aggregate->name ); + ret = new StructInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name ); break; case DeclarationNode::Union: - ret = new UnionInstType( buildQualifiers( td ), td->aggInst->aggregate->aggregate->name ); + ret = new UnionInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name ); break; case DeclarationNode::Trait: - ret = new TraitInstType( buildQualifiers( td ), td->aggInst->aggregate->aggregate->name ); + ret = new TraitInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name ); break; default: @@ -804,5 +804,5 @@ } // switch } // if - buildList( td->aggInst->params, ret->get_parameters() ); + buildList( td->aggInst.params, ret->get_parameters() ); buildForall( td->forall, ret->get_forall() ); return ret; @@ -813,11 +813,11 @@ NamedTypeDecl * ret; assert( td->base ); - if ( td->symbolic->isTypedef ) { + if ( td->symbolic.isTypedef ) { ret = new TypedefDecl( name, sc, typebuild( td->base ) ); } else { ret = new TypeDecl( name, sc, typebuild( td->base ), TypeDecl::Any ); } // if - buildList( td->symbolic->params, ret->get_parameters() ); - buildList( td->symbolic->assertions, ret->get_assertions() ); + buildList( td->symbolic.params, ret->get_parameters() ); + buildList( td->symbolic.assertions, ret->get_assertions() ); return ret; } // buildSymbolic @@ -827,6 +827,6 @@ static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype }; - TypeDecl * ret = new TypeDecl( td->variable->name, DeclarationNode::NoStorageClass, 0, kindMap[ td->variable->tyClass ] ); - buildList( td->variable->assertions, ret->get_assertions() ); + TypeDecl * ret = new TypeDecl( td->variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ td->variable.tyClass ] ); + buildList( td->variable.assertions, ret->get_assertions() ); return ret; } // buildSymbolic @@ -834,8 +834,8 @@ EnumDecl * buildEnum( const TypeData * td ) { assert( td->kind == TypeData::Enum ); - EnumDecl * ret = new EnumDecl( td->enumeration->name ); - buildList( td->enumeration->constants, ret->get_members() ); + EnumDecl * ret = new EnumDecl( td->enumeration.name ); + buildList( td->enumeration.constants, ret->get_members() ); std::list< Declaration * >::iterator members = ret->get_members().begin(); - for ( const DeclarationNode * cur = td->enumeration-> constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) { + for ( const DeclarationNode * cur = td->enumeration. constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) { if ( cur->has_enumeratorValue() ) { ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members); @@ -848,6 +848,6 @@ TypeInstType * buildSymbolicInst( const TypeData * td ) { assert( td->kind == TypeData::SymbolicInst ); - TypeInstType * ret = new TypeInstType( buildQualifiers( td ), td->symbolic->name, false ); - buildList( td->symbolic->actuals, ret->get_parameters() ); + TypeInstType * ret = new TypeInstType( buildQualifiers( td ), td->symbolic.name, false ); + buildList( td->symbolic.actuals, ret->get_parameters() ); buildForall( td->forall, ret->get_forall() ); return ret; @@ -857,5 +857,5 @@ assert( td->kind == TypeData::Tuple ); TupleType * ret = new TupleType( buildQualifiers( td ) ); - buildTypeList( td->tuple->members, ret->get_types() ); + buildTypeList( td->tuple, ret->get_types() ); buildForall( td->forall, ret->get_forall() ); return ret; @@ -865,17 +865,17 @@ assert( td->kind == TypeData::Typeof ); assert( td->typeexpr ); - assert( td->typeexpr->expr ); - return new TypeofType( buildQualifiers( td ), td->typeexpr->expr->build() ); + // assert( td->typeexpr->expr ); + return new TypeofType( buildQualifiers( td ), td->typeexpr->build() ); } // buildTypeof AttrType * buildAttr( const TypeData * td ) { assert( td->kind == TypeData::Attr ); - assert( td->attr ); + // assert( td->attr ); AttrType * ret; - if ( td->attr->expr ) { - ret = new AttrType( buildQualifiers( td ), td->attr->name, td->attr->expr->build() ); + if ( td->attr.expr ) { + ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.expr->build() ); } else { - assert( td->attr->type ); - ret = new AttrType( buildQualifiers( td ), td->attr->name, td->attr->type->buildType() ); + assert( td->attr.type ); + ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.type->buildType() ); } // if return ret; @@ -885,7 +885,7 @@ if ( td->kind == TypeData::Function ) { FunctionDecl * decl; - if ( td->function->hasBody ) { - if ( td->function->body ) { - Statement * stmt = td->function->body->build(); + if ( td->function.hasBody ) { + if ( td->function.body ) { + Statement * stmt = td->function.body->build(); CompoundStmt * body = dynamic_cast< CompoundStmt* >( stmt ); assert( body ); @@ -898,10 +898,10 @@ decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), 0, isInline, isNoreturn ); } // if - for ( DeclarationNode * cur = td->function->idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) { + for ( DeclarationNode * cur = td->function.idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) { if ( cur->get_name() != "" ) { decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() ); } // if } // for - buildList( td->function->oldDeclList, decl->get_oldDecls() ); + buildList( td->function.oldDeclList, decl->get_oldDecls() ); return decl; } else if ( td->kind == TypeData::Aggregate ) { @@ -921,13 +921,13 @@ FunctionType * buildFunction( const TypeData * td ) { assert( td->kind == TypeData::Function ); - bool hasEllipsis = td->function->params ? td->function->params->get_hasEllipsis() : true; - if ( ! td->function->params ) hasEllipsis = ! td->function->newStyle; + bool hasEllipsis = td->function.params ? td->function.params->get_hasEllipsis() : true; + if ( ! td->function.params ) hasEllipsis = ! td->function.newStyle; FunctionType * ft = new FunctionType( buildQualifiers( td ), hasEllipsis ); - buildList( td->function->params, ft->get_parameters() ); + buildList( td->function.params, ft->get_parameters() ); buildForall( td->forall, ft->get_forall() ); if ( td->base ) { switch ( td->base->kind ) { case TypeData::Tuple: - buildList( td->base->tuple->members, ft->get_returnVals() ); + buildList( td->base->tuple, ft->get_returnVals() ); break; default: Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision 5e644d3ef72d65dc187491097854dec3ad90c16e) +++ src/Parser/TypeData.h (revision 8f6f47d7dda0117750908df7f55ff6a7f7349277) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:18:36 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Aug 28 22:39:00 2016 -// Update Count : 85 +// Last Modified On : Mon Aug 29 15:54:00 2016 +// Update Count : 106 // @@ -79,15 +79,15 @@ }; - struct Tuple_t { - DeclarationNode * members; - }; + // struct Tuple_t { + // DeclarationNode * members; + // }; - struct Typeof_t { - ExpressionNode * expr; - }; + // struct Typeof_t { + // ExpressionNode * expr; + // }; - struct Builtin_t { - DeclarationNode::BuiltinType type; - }; + // struct Builtin_t { + // DeclarationNode::BuiltinType type; + // }; struct Attr_t { @@ -102,18 +102,16 @@ DeclarationNode * forall; - union { - Basic_t * basic; - Aggregate_t * aggregate; - AggInst_t * aggInst; - Array_t * array; - Enumeration_t * enumeration; - Function_t * function; - Symbolic_t * symbolic; - Variable_t * variable; - Tuple_t * tuple; - Typeof_t * typeexpr; - Attr_t * attr; - Builtin_t * builtin; - }; + Basic_t basic; + Aggregate_t aggregate; + AggInst_t aggInst; + Array_t array; + Enumeration_t enumeration; + Function_t function; + Symbolic_t symbolic; + Variable_t variable; + DeclarationNode * tuple; + ExpressionNode * typeexpr; + Attr_t attr; + // DeclarationNode::BuiltinType builtin; TypeData( Kind k = Unknown );