Context Navigation

source: src/Parser/TypeData.cc @ 2794fff

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decaygc_noraiijacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc

Last change on this file since 2794fff was 721f17a, checked in by Peter A. Buhr <pabuhr@…>, 9 years ago
fix OT_LABELADDRESS warning, parse genric types
Property mode set to `100644`
File size: 26.6 KB

Rev	Line
[b87a5ed]	1	//
	2	// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
	3	//
	4	// The contents of this file are covered under the licence agreement in the
	5	// file "LICENCE" distributed with Cforall.
	6	//
	7	// TypeData.cc --
	8	//
	9	// Author : Rodolfo G. Esteves
	10	// Created On : Sat May 16 15:12:51 2015
	11	// Last Modified By : Peter A. Buhr
[721f17a]	12	// Last Modified On : Fri Jun 26 07:30:06 2015
	13	// Update Count : 26
[b87a5ed]	14	//
	15
[51b7345]	16	#include <cassert>
	17	#include <algorithm>
	18	#include <iterator>
	19	#include "utility.h"
	20	#include "TypeData.h"
	21	#include "SynTree/Type.h"
	22	#include "SynTree/Declaration.h"
	23	#include "SynTree/Expression.h"
	24	#include "SynTree/Statement.h"
	25
[c8ffe20b]	26	TypeData::TypeData( Kind k ) : kind( k ), base( 0 ), forall( 0 ) {
[b87a5ed]	27	switch ( kind ) {
	28	case Unknown:
	29	case Pointer:
	30	case EnumConstant:
	31	// nothing else to initialize
	32	break;
	33	case Basic:
	34	basic = new Basic_t;
	35	break;
	36	case Array:
	37	array = new Array_t;
	38	array->dimension = 0;
	39	array->isVarLen = false;
	40	array->isStatic = false;
	41	break;
	42	case Function:
	43	function = new Function_t;
	44	function->params = 0;
	45	function->idList = 0;
	46	function->oldDeclList = 0;
	47	function->body = 0;
	48	function->hasBody = false;
	49	function->newStyle = false;
	50	break;
	51	case Aggregate:
	52	aggregate = new Aggregate_t;
	53	aggregate->params = 0;
	54	aggregate->actuals = 0;
[721f17a]	55	aggregate->fields = 0;
[b87a5ed]	56	break;
	57	case AggregateInst:
	58	aggInst = new AggInst_t;
	59	aggInst->aggregate = 0;
	60	aggInst->params = 0;
	61	break;
	62	case Enum:
	63	enumeration = new Enumeration_t;
	64	enumeration->constants = 0;
	65	break;
	66	case Symbolic:
	67	case SymbolicInst:
	68	symbolic = new Symbolic_t;
	69	symbolic->params = 0;
	70	symbolic->actuals = 0;
	71	symbolic->assertions = 0;
	72	break;
	73	case Variable:
	74	variable = new Variable_t;
	75	variable->tyClass = DeclarationNode::Type;
	76	variable->assertions = 0;
	77	break;
	78	case Tuple:
	79	tuple = new Tuple_t;
	80	tuple->members = 0;
	81	break;
	82	case Typeof:
	83	typeexpr = new Typeof_t;
	84	typeexpr->expr = 0;
	85	break;
	86	case Attr:
	87	attr = new Attr_t;
	88	attr->expr = 0;
	89	attr->type = 0;
	90	break;
[68cd1ce]	91	} // switch
[51b7345]	92	}
	93
[c8ffe20b]	94	TypeData::~TypeData() {
[b87a5ed]	95	delete base;
	96	delete forall;
	97
	98	switch ( kind ) {
	99	case Unknown:
	100	case Pointer:
	101	case EnumConstant:
	102	// nothing to destroy
	103	break;
	104	case Basic:
	105	delete basic;
	106	break;
	107	case Array:
	108	delete array->dimension;
	109	delete array;
	110	break;
	111	case Function:
	112	delete function->params;
	113	delete function->idList;
	114	delete function->oldDeclList;
	115	delete function->body;
	116	delete function;
	117	break;
	118	case Aggregate:
	119	delete aggregate->params;
	120	delete aggregate->actuals;
[721f17a]	121	delete aggregate->fields;
[b87a5ed]	122	delete aggregate;
	123	break;
	124	case AggregateInst:
	125	delete aggInst->aggregate;
	126	delete aggInst->params;
	127	delete aggInst;
	128	break;
	129	case Enum:
	130	delete enumeration->constants;
	131	delete enumeration;
	132	break;
	133	case Symbolic:
	134	case SymbolicInst:
	135	delete symbolic->params;
	136	delete symbolic->actuals;
	137	delete symbolic->assertions;
	138	delete symbolic;
	139	break;
	140	case Variable:
	141	delete variable->assertions;
	142	delete variable;
	143	break;
	144	case Tuple:
	145	delete tuple->members;
	146	delete tuple;
	147	break;
	148	case Typeof:
	149	delete typeexpr->expr;
	150	delete typeexpr;
	151	break;
	152	case Attr:
	153	delete attr->expr;
	154	delete attr->type;
	155	delete attr;
	156	break;
[68cd1ce]	157	} // switch
[51b7345]	158	}
	159
[c8ffe20b]	160	TypeData *TypeData::clone() const {
[b87a5ed]	161	TypeData *newtype = new TypeData( kind );
	162	newtype->qualifiers = qualifiers;
	163	newtype->base = maybeClone( base );
	164	newtype->forall = maybeClone( forall );
	165
	166	switch ( kind ) {
	167	case Unknown:
	168	case EnumConstant:
	169	case Pointer:
	170	// nothing else to copy
	171	break;
	172	case Basic:
	173	newtype->basic->typeSpec = basic->typeSpec;
	174	newtype->basic->modifiers = basic->modifiers;
	175	break;
	176	case Array:
	177	newtype->array->dimension = maybeClone( array->dimension );
	178	newtype->array->isVarLen = array->isVarLen;
	179	newtype->array->isStatic = array->isStatic;
	180	break;
	181	case Function:
	182	newtype->function->params = maybeClone( function->params );
	183	newtype->function->idList = maybeClone( function->idList );
	184	newtype->function->oldDeclList = maybeClone( function->oldDeclList );
	185	newtype->function->body = maybeClone( function->body );
	186	newtype->function->hasBody = function->hasBody;
	187	newtype->function->newStyle = function->newStyle;
	188	break;
	189	case Aggregate:
	190	newtype->aggregate->params = maybeClone( aggregate->params );
	191	newtype->aggregate->actuals = maybeClone( aggregate->actuals );
[721f17a]	192	newtype->aggregate->fields = maybeClone( aggregate->fields );
[b87a5ed]	193	newtype->aggregate->name = aggregate->name;
	194	newtype->aggregate->kind = aggregate->kind;
	195	break;
	196	case AggregateInst:
	197	newtype->aggInst->aggregate = maybeClone( aggInst->aggregate );
	198	newtype->aggInst->params = maybeClone( aggInst->params );
	199	break;
	200	case Enum:
	201	newtype->enumeration->name = enumeration->name;
	202	newtype->enumeration->constants = maybeClone( enumeration->constants );
	203	break;
	204	case Symbolic:
	205	case SymbolicInst:
	206	newtype->symbolic->params = maybeClone( symbolic->params );
	207	newtype->symbolic->actuals = maybeClone( symbolic->actuals );
	208	newtype->symbolic->assertions = maybeClone( symbolic->assertions );
	209	newtype->symbolic->isTypedef = symbolic->isTypedef;
	210	newtype->symbolic->name = symbolic->name;
	211	break;
	212	case Variable:
	213	newtype->variable->assertions = maybeClone( variable->assertions );
	214	newtype->variable->name = variable->name;
	215	newtype->variable->tyClass = variable->tyClass;
	216	break;
	217	case Tuple:
	218	newtype->tuple->members = maybeClone( tuple->members );
	219	break;
	220	case Typeof:
	221	newtype->typeexpr->expr = maybeClone( typeexpr->expr );
	222	break;
	223	case Attr:
	224	newtype->attr->expr = maybeClone( attr->expr );
	225	newtype->attr->type = maybeClone( attr->type );
	226	break;
[68cd1ce]	227	} // switch
[b87a5ed]	228	return newtype;
[c8ffe20b]	229	}
[51b7345]	230
[c8ffe20b]	231	void TypeData::print( std::ostream &os, int indent ) const {
[b87a5ed]	232	using std::endl;
	233	using std::string;
	234
	235	printEnums( qualifiers.begin(), qualifiers.end(), DeclarationNode::qualifierName, os );
	236
	237	if ( forall ) {
	238	os << "forall " << endl;
[721f17a]	239	forall->printList( os, indent + 4 );
[68cd1ce]	240	} // if
[b87a5ed]	241
	242	switch ( kind ) {
	243	case Unknown:
	244	os << "entity of unknown type ";
	245	break;
	246	case Pointer:
	247	os << "pointer ";
	248	if ( base ) {
	249	os << "to ";
	250	base->print( os, indent );
[68cd1ce]	251	} // if
[b87a5ed]	252	break;
	253	case EnumConstant:
	254	os << "enumeration constant ";
	255	break;
	256	case Basic:
	257	printEnums( basic->modifiers.begin(), basic->modifiers.end(), DeclarationNode::modifierName, os );
	258	printEnums( basic->typeSpec.begin(), basic->typeSpec.end(), DeclarationNode::basicTypeName, os );
	259	break;
	260	case Array:
	261	if ( array->isStatic ) {
	262	os << "static ";
[68cd1ce]	263	} // if
[b87a5ed]	264	if ( array->dimension ) {
	265	os << "array of ";
	266	array->dimension->printOneLine( os, indent );
	267	} else if ( array->isVarLen ) {
	268	os << "variable-length array of ";
	269	} else {
	270	os << "open array of ";
[68cd1ce]	271	} // if
[b87a5ed]	272	if ( base ) {
	273	base->print( os, indent );
[68cd1ce]	274	} // if
[b87a5ed]	275	break;
	276	case Function:
	277	os << "function" << endl;
	278	if ( function->params ) {
[721f17a]	279	os << string( indent + 2, ' ' ) << "with parameters " << endl;
	280	function->params->printList( os, indent + 4 );
[b87a5ed]	281	} else {
[721f17a]	282	os << string( indent + 2, ' ' ) << "with no parameters " << endl;
[68cd1ce]	283	} // if
[b87a5ed]	284	if ( function->idList ) {
[721f17a]	285	os << string( indent + 2, ' ' ) << "with old-style identifier list " << endl;
	286	function->idList->printList( os, indent + 4 );
[68cd1ce]	287	} // if
[b87a5ed]	288	if ( function->oldDeclList ) {
[721f17a]	289	os << string( indent + 2, ' ' ) << "with old-style declaration list " << endl;
	290	function->oldDeclList->printList( os, indent + 4 );
[68cd1ce]	291	} // if
[721f17a]	292	os << string( indent + 2, ' ' ) << "returning ";
[b87a5ed]	293	if ( base ) {
[721f17a]	294	base->print( os, indent + 4 );
[b87a5ed]	295	} else {
	296	os << "nothing ";
[68cd1ce]	297	} // if
[b87a5ed]	298	os << endl;
	299	if ( function->hasBody ) {
[721f17a]	300	os << string( indent + 2, ' ' ) << "with body " << endl;
[68cd1ce]	301	} // if
[b87a5ed]	302	if ( function->body ) {
[721f17a]	303	function->body->printList( os, indent + 2 );
[68cd1ce]	304	} // if
[b87a5ed]	305	break;
	306	case Aggregate:
[68cd1ce]	307	os << DeclarationNode::aggregateName[ aggregate->kind ] << ' ' << aggregate->name << endl;
[b87a5ed]	308	if ( aggregate->params ) {
[721f17a]	309	os << string( indent + 2, ' ' ) << "with type parameters " << endl;
	310	aggregate->params->printList( os, indent + 4 );
[68cd1ce]	311	} // if
[b87a5ed]	312	if ( aggregate->actuals ) {
[721f17a]	313	os << string( indent + 2, ' ' ) << "instantiated with actual parameters " << endl;
	314	aggregate->actuals->printList( os, indent + 4 );
[68cd1ce]	315	} // if
[721f17a]	316	if ( aggregate->fields ) {
	317	os << string( indent + 2, ' ' ) << "with members " << endl;
	318	aggregate->fields->printList( os, indent + 4 );
[51b7345]	319	/// } else {
[721f17a]	320	/// os << string( indent + 2, ' ' ) << "with no members " << endl;
[68cd1ce]	321	} // if
[b87a5ed]	322	break;
	323	case AggregateInst:
	324	if ( aggInst->aggregate ) {
	325	os << "instance of " ;
	326	aggInst->aggregate->print( os, indent );
	327	} else {
	328	os << "instance of an unspecified aggregate ";
[68cd1ce]	329	} // if
[b87a5ed]	330	if ( aggInst->params ) {
[721f17a]	331	os << string( indent + 2, ' ' ) << "with parameters " << endl;
	332	aggInst->params->printList( os, indent + 2 );
[68cd1ce]	333	} // if
[b87a5ed]	334	break;
	335	case Enum:
	336	os << "enumeration ";
	337	if ( enumeration->constants ) {
	338	os << "with constants" << endl;
[721f17a]	339	enumeration->constants->printList( os, indent + 2 );
[68cd1ce]	340	} // if
[b87a5ed]	341	break;
	342	case SymbolicInst:
	343	os << "instance of type " << symbolic->name;
	344	if ( symbolic->actuals ) {
	345	os << " with parameters" << endl;
	346	symbolic->actuals->printList( os, indent + 2 );
[68cd1ce]	347	} // if
[b87a5ed]	348	break;
	349	case Symbolic:
	350	if ( symbolic->isTypedef ) {
	351	os << "typedef definition ";
	352	} else {
	353	os << "type definition ";
[68cd1ce]	354	} // if
[b87a5ed]	355	if ( symbolic->params ) {
[721f17a]	356	os << endl << string( indent + 2, ' ' ) << "with parameters" << endl;
[b87a5ed]	357	symbolic->params->printList( os, indent + 2 );
[68cd1ce]	358	} // if
[b87a5ed]	359	if ( symbolic->assertions ) {
[721f17a]	360	os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;
[b87a5ed]	361	symbolic->assertions->printList( os, indent + 4 );
[721f17a]	362	os << string( indent + 2, ' ' );
[68cd1ce]	363	} // if
[b87a5ed]	364	if ( base ) {
	365	os << "for ";
	366	base->print( os, indent + 2 );
[68cd1ce]	367	} // if
[b87a5ed]	368	break;
	369	case Variable:
	370	os << DeclarationNode::typeClassName[ variable->tyClass ] << " variable ";
	371	if ( variable->assertions ) {
[721f17a]	372	os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;
[b87a5ed]	373	variable->assertions->printList( os, indent + 4 );
[721f17a]	374	os << string( indent + 2, ' ' );
[68cd1ce]	375	} // if
[b87a5ed]	376	break;
	377	case Tuple:
	378	os << "tuple ";
	379	if ( tuple->members ) {
	380	os << "with members " << endl;
	381	tuple->members->printList( os, indent + 2 );
[68cd1ce]	382	} // if
[b87a5ed]	383	break;
	384	case Typeof:
	385	os << "type-of expression ";
	386	if ( typeexpr->expr ) {
	387	typeexpr->expr->print( os, indent + 2 );
[68cd1ce]	388	} // if
[b87a5ed]	389	break;
	390	case Attr:
	391	os << "attribute type decl " << attr->name << " applied to ";
	392	if ( attr->expr ) {
	393	attr->expr->print( os, indent + 2 );
[68cd1ce]	394	} // if
[b87a5ed]	395	if ( attr->type ) {
	396	attr->type->print( os, indent + 2 );
[68cd1ce]	397	} // if
[b87a5ed]	398	break;
[68cd1ce]	399	} // switch
[51b7345]	400	}
	401
[c8ffe20b]	402	TypeData *TypeData::extractAggregate( bool toplevel ) const {
[b87a5ed]	403	TypeData *ret = 0;
[51b7345]	404
[b87a5ed]	405	switch ( kind ) {
	406	case Aggregate:
[721f17a]	407	if ( ! toplevel && aggregate->fields ) {
[b87a5ed]	408	ret = clone();
	409	ret->qualifiers.clear();
[68cd1ce]	410	} // if
[b87a5ed]	411	break;
	412	case Enum:
[a32b204]	413	if ( ! toplevel && enumeration->constants ) {
[b87a5ed]	414	ret = clone();
	415	ret->qualifiers.clear();
[68cd1ce]	416	} // if
[b87a5ed]	417	break;
	418	case AggregateInst:
	419	if ( aggInst->aggregate ) {
	420	ret = aggInst->aggregate->extractAggregate( false );
[68cd1ce]	421	} // if
[b87a5ed]	422	break;
	423	default:
	424	if ( base ) {
	425	ret = base->extractAggregate( false );
[68cd1ce]	426	} // if
	427	} // switch
[b87a5ed]	428	return ret;
[51b7345]	429	}
	430
[c8ffe20b]	431	void buildForall( const DeclarationNode firstNode, std::list< TypeDecl > &outputList ) {
[b87a5ed]	432	buildList( firstNode, outputList );
	433	for ( std::list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
	434	if ( (*i)->get_kind() == TypeDecl::Any ) {
	435	FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
[68cd1ce]	436	assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (i)->get_name(), i ) ), 0 ) );
	437	assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (i)->get_name(), i ), 0 ) );
	438	assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (i)->get_name(), i ), 0 ) );
[de62360d]	439	(*i)->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false, false ) );
[68cd1ce]	440	} // if
	441	} // for
[51b7345]	442	}
	443
[de62360d]	444	Declaration TypeData::buildDecl( std::string name, DeclarationNode::StorageClass sc, Expression bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Type linkage, Initializer *init ) const {
[b87a5ed]	445	if ( kind == TypeData::Function ) {
	446	FunctionDecl *decl;
	447	if ( function->hasBody ) {
	448	if ( function->body ) {
	449	Statement *stmt = function->body->build();
	450	CompoundStmt body = dynamic_cast< CompoundStmt >( stmt );
	451	assert( body );
[de62360d]	452	decl = new FunctionDecl( name, sc, linkage, buildFunction(), body, isInline, isNoreturn );
[b87a5ed]	453	} else {
	454	// std::list<Label> ls;
[de62360d]	455	decl = new FunctionDecl( name, sc, linkage, buildFunction(), new CompoundStmt( std::list<Label>() ), isInline, isNoreturn );
[68cd1ce]	456	} // if
[b87a5ed]	457	} else {
[de62360d]	458	decl = new FunctionDecl( name, sc, linkage, buildFunction(), 0, isInline, isNoreturn );
[68cd1ce]	459	} // if
[b87a5ed]	460	for ( DeclarationNode cur = function->idList; cur != 0; cur = dynamic_cast< DeclarationNode >( cur->get_link() ) ) {
	461	if ( cur->get_name() != "" ) {
	462	decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() );
[68cd1ce]	463	} // if
	464	} // for
[b87a5ed]	465	buildList( function->oldDeclList, decl->get_oldDecls() );
	466	return decl;
	467	} else if ( kind == TypeData::Aggregate ) {
	468	return buildAggregate();
	469	} else if ( kind == TypeData::Enum ) {
	470	return buildEnum();
	471	} else if ( kind == TypeData::Symbolic ) {
	472	return buildSymbolic( name, sc );
	473	} else if ( kind == TypeData::Variable ) {
	474	return buildVariable();
[c8ffe20b]	475	} else {
[de62360d]	476	if ( isInline \|\| isNoreturn ) {
	477	throw SemanticError( "invalid inline or _Noreturn specification in declaration of ", this );
[b87a5ed]	478	} else {
	479	return new ObjectDecl( name, sc, linkage, bitfieldWidth, build(), init );
[68cd1ce]	480	} // if
	481	} // if
[b87a5ed]	482	return 0;
[51b7345]	483	}
	484
[c8ffe20b]	485	Type *TypeData::build() const {
[b87a5ed]	486	switch ( kind ) {
	487	case Unknown:
	488	// fill in implicit int
	489	return new BasicType( buildQualifiers(), BasicType::SignedInt );
	490	case Basic:
	491	return buildBasicType();
	492	case Pointer:
	493	return buildPointer();
	494	case Array:
	495	return buildArray();
	496	case Function:
	497	return buildFunction();
	498	case AggregateInst:
	499	return buildAggInst();
	500	case EnumConstant:
	501	// the name gets filled in later -- by SymTab::Validate
	502	return new EnumInstType( buildQualifiers(), "" );
	503	case SymbolicInst:
	504	return buildSymbolicInst();;
	505	case Tuple:
	506	return buildTuple();
	507	case Typeof:
	508	return buildTypeof();
	509	case Attr:
	510	return buildAttr();
	511	case Symbolic:
	512	case Enum:
	513	case Aggregate:
	514	case Variable:
	515	assert( false );
[68cd1ce]	516	} // switch
[b87a5ed]	517	return 0;
[c8ffe20b]	518	}
[51b7345]	519
[c8ffe20b]	520	Type::Qualifiers TypeData::buildQualifiers() const {
[b87a5ed]	521	Type::Qualifiers q;
	522	for ( std::list< DeclarationNode::Qualifier >::const_iterator i = qualifiers.begin(); i != qualifiers.end(); ++i ) {
	523	switch ( *i ) {
	524	case DeclarationNode::Const:
	525	q.isConst = true;
	526	break;
	527	case DeclarationNode::Volatile:
	528	q.isVolatile = true;
	529	break;
	530	case DeclarationNode::Restrict:
	531	q.isRestrict = true;
	532	break;
	533	case DeclarationNode::Lvalue:
	534	q.isLvalue = true;
	535	break;
	536	case DeclarationNode::Atomic:
	537	q.isAtomic = true;
	538	break;
	539	case DeclarationNode::Attribute:
	540	q.isAttribute = true;
	541	break;
[68cd1ce]	542	} // switch
	543	} // for
[b87a5ed]	544	return q;
[c8ffe20b]	545	}
[51b7345]	546
[c8ffe20b]	547	Type *TypeData::buildBasicType() const {
[b87a5ed]	548	static const BasicType::Kind kindMap[] = { BasicType::Char, BasicType::SignedInt, BasicType::Float, BasicType::Double,
	549	BasicType::Char /* void */, BasicType::Bool, BasicType::DoubleComplex,
	550	BasicType::DoubleImaginary };
	551	bool init = false;
	552	bool sawDouble = false;
	553	bool sawSigned = false;
	554	BasicType::Kind ret;
	555
	556	for ( std::list< DeclarationNode::BasicType >::const_iterator i = basic->typeSpec.begin(); i != basic->typeSpec.end(); ++i ) {
[a32b204]	557	if ( ! init ) {
[b87a5ed]	558	init = true;
	559	if ( *i == DeclarationNode::Void ) {
[a32b204]	560	if ( basic->typeSpec.size() != 1 \|\| ! basic->modifiers.empty() ) {
[b87a5ed]	561	throw SemanticError( "invalid type specifier \"void\" in type: ", this );
	562	} else {
	563	return new VoidType( buildQualifiers() );
[68cd1ce]	564	} // if
[b87a5ed]	565	} else {
	566	ret = kindMap[ *i ];
[68cd1ce]	567	} // if
[c8ffe20b]	568	} else {
[b87a5ed]	569	switch ( *i ) {
	570	case DeclarationNode::Float:
	571	if ( sawDouble ) {
	572	throw SemanticError( "invalid type specifier \"float\" in type: ", this );
	573	} else {
	574	switch ( ret ) {
	575	case BasicType::DoubleComplex:
	576	ret = BasicType::FloatComplex;
	577	break;
	578	case BasicType::DoubleImaginary:
	579	ret = BasicType::FloatImaginary;
	580	break;
	581	default:
	582	throw SemanticError( "invalid type specifier \"float\" in type: ", this );
[68cd1ce]	583	} // switch
	584	} // if
[b87a5ed]	585	break;
	586	case DeclarationNode::Double:
	587	if ( sawDouble ) {
	588	throw SemanticError( "duplicate type specifier \"double\" in type: ", this );
	589	} else {
	590	switch ( ret ) {
	591	case BasicType::DoubleComplex:
	592	case BasicType::DoubleImaginary:
	593	break;
	594	default:
	595	throw SemanticError( "invalid type specifier \"double\" in type: ", this );
[68cd1ce]	596	} // switch
	597	} // if
[b87a5ed]	598	break;
	599	case DeclarationNode::Complex:
	600	switch ( ret ) {
	601	case BasicType::Float:
	602	ret = BasicType::FloatComplex;
	603	break;
	604	case BasicType::Double:
	605	ret = BasicType::DoubleComplex;
	606	break;
	607	default:
	608	throw SemanticError( "invalid type specifier \"_Complex\" in type: ", this );
[68cd1ce]	609	} // switch
[b87a5ed]	610	break;
	611	case DeclarationNode::Imaginary:
	612	switch ( ret ) {
	613	case BasicType::Float:
	614	ret = BasicType::FloatImaginary;
	615	break;
	616	case BasicType::Double:
	617	ret = BasicType::DoubleImaginary;
	618	break;
	619	default:
	620	throw SemanticError( "invalid type specifier \"_Imaginary\" in type: ", this );
[68cd1ce]	621	} // switch
[b87a5ed]	622	break;
	623	default:
	624	throw SemanticError( std::string( "invalid type specifier \"" ) + DeclarationNode::basicTypeName[ *i ] + "\" in type: ", this );
[68cd1ce]	625	} // switch
	626	} // if
[b87a5ed]	627	if ( *i == DeclarationNode::Double ) {
	628	sawDouble = true;
[68cd1ce]	629	} // if
	630	} // for
[b87a5ed]	631
	632	for ( std::list< DeclarationNode::Modifier >::const_iterator i = basic->modifiers.begin(); i != basic->modifiers.end(); ++i ) {
	633	switch ( *i ) {
	634	case DeclarationNode::Long:
[a32b204]	635	if ( ! init ) {
[b87a5ed]	636	init = true;
	637	ret = BasicType::LongSignedInt;
	638	} else {
	639	switch ( ret ) {
	640	case BasicType::SignedInt:
	641	ret = BasicType::LongSignedInt;
	642	break;
	643	case BasicType::UnsignedInt:
	644	ret = BasicType::LongUnsignedInt;
	645	break;
	646	case BasicType::LongSignedInt:
	647	ret = BasicType::LongLongSignedInt;
	648	break;
	649	case BasicType::LongUnsignedInt:
	650	ret = BasicType::LongLongUnsignedInt;
	651	break;
	652	case BasicType::Double:
	653	ret = BasicType::LongDouble;
	654	break;
	655	case BasicType::DoubleComplex:
	656	ret = BasicType::LongDoubleComplex;
	657	break;
	658	case BasicType::DoubleImaginary:
	659	ret = BasicType::LongDoubleImaginary;
	660	break;
	661	default:
	662	throw SemanticError( "invalid type modifier \"long\" in type: ", this );
[68cd1ce]	663	} // switch
	664	} // if
[c8ffe20b]	665	break;
[b87a5ed]	666	case DeclarationNode::Short:
[a32b204]	667	if ( ! init ) {
[b87a5ed]	668	init = true;
	669	ret = BasicType::ShortSignedInt;
	670	} else {
	671	switch ( ret ) {
	672	case BasicType::SignedInt:
	673	ret = BasicType::ShortSignedInt;
	674	break;
	675	case BasicType::UnsignedInt:
	676	ret = BasicType::ShortUnsignedInt;
	677	break;
	678	default:
	679	throw SemanticError( "invalid type modifier \"short\" in type: ", this );
[68cd1ce]	680	} // switch
	681	} // if
[c8ffe20b]	682	break;
[b87a5ed]	683	case DeclarationNode::Signed:
[a32b204]	684	if ( ! init ) {
[b87a5ed]	685	init = true;
	686	ret = BasicType::SignedInt;
	687	} else if ( sawSigned ) {
	688	throw SemanticError( "duplicate type modifer \"signed\" in type: ", this );
	689	} else {
	690	switch ( ret ) {
[59db689]	691	case BasicType::LongLongSignedInt:
[b87a5ed]	692	ret = BasicType::LongLongUnsignedInt;
	693	break;
	694	case BasicType::LongSignedInt:
	695	ret = BasicType::LongUnsignedInt;
	696	break;
	697	case BasicType::SignedInt:
	698	case BasicType::ShortSignedInt:
	699	break;
	700	case BasicType::Char:
	701	ret = BasicType::SignedChar;
	702	break;
	703	default:
	704	throw SemanticError( "invalid type modifer \"signed\" in type: ", this );
[68cd1ce]	705	} // switch
	706	} // if
[b87a5ed]	707	break;
	708	case DeclarationNode::Unsigned:
[a32b204]	709	if ( ! init ) {
[b87a5ed]	710	init = true;
	711	ret = BasicType::UnsignedInt;
	712	} else if ( sawSigned ) {
	713	throw SemanticError( "invalid type modifer \"unsigned\" in type: ", this );
	714	} else {
	715	switch ( ret ) {
[59db689]	716	case BasicType::LongLongSignedInt:
[b87a5ed]	717	ret = BasicType::LongLongUnsignedInt;
	718	break;
	719	case BasicType::LongSignedInt:
	720	ret = BasicType::LongUnsignedInt;
	721	break;
	722	case BasicType::SignedInt:
	723	ret = BasicType::UnsignedInt;
	724	break;
	725	case BasicType::ShortSignedInt:
	726	ret = BasicType::ShortUnsignedInt;
	727	break;
	728	case BasicType::Char:
	729	ret = BasicType::UnsignedChar;
	730	break;
	731	default:
	732	throw SemanticError( "invalid type modifer \"unsigned\" in type: ", this );
[68cd1ce]	733	} // switch
	734	} // if
[c8ffe20b]	735	break;
[68cd1ce]	736	} // switch
[b87a5ed]	737
	738	if ( *i == DeclarationNode::Signed ) {
	739	sawSigned = true;
[68cd1ce]	740	} // if
	741	} // for
[51b7345]	742
[b87a5ed]	743	BasicType *bt;
[a32b204]	744	if ( ! init ) {
[b87a5ed]	745	bt = new BasicType( buildQualifiers(), BasicType::SignedInt );
	746	} else {
	747	bt = new BasicType( buildQualifiers(), ret );
[68cd1ce]	748	} // if
[b87a5ed]	749	buildForall( forall, bt->get_forall() );
	750	return bt;
[51b7345]	751	}
	752
	753
[c8ffe20b]	754	PointerType *TypeData::buildPointer() const {
[b87a5ed]	755	PointerType *pt;
	756	if ( base ) {
	757	pt = new PointerType( buildQualifiers(), base->build() );
	758	} else {
	759	pt = new PointerType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
[68cd1ce]	760	} // if
[b87a5ed]	761	buildForall( forall, pt->get_forall() );
	762	return pt;
[51b7345]	763	}
	764
[c8ffe20b]	765	ArrayType *TypeData::buildArray() const {
[b87a5ed]	766	ArrayType *at;
	767	if ( base ) {
	768	at = new ArrayType( buildQualifiers(), base->build(), maybeBuild< Expression >( array->dimension ),
	769	array->isVarLen, array->isStatic );
	770	} else {
	771	at = new ArrayType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ),
	772	maybeBuild< Expression >( array->dimension ), array->isVarLen, array->isStatic );
[68cd1ce]	773	} // if
[b87a5ed]	774	buildForall( forall, at->get_forall() );
	775	return at;
[51b7345]	776	}
	777
[c8ffe20b]	778	FunctionType *TypeData::buildFunction() const {
[b87a5ed]	779	assert( kind == Function );
	780	bool hasEllipsis = function->params ? function->params->get_hasEllipsis() : true;
[a32b204]	781	if ( ! function->params ) hasEllipsis = ! function->newStyle;
[b87a5ed]	782	FunctionType *ft = new FunctionType( buildQualifiers(), hasEllipsis );
	783	buildList( function->params, ft->get_parameters() );
	784	buildForall( forall, ft->get_forall() );
	785	if ( base ) {
	786	switch ( base->kind ) {
	787	case Tuple:
	788	buildList( base->tuple->members, ft->get_returnVals() );
	789	break;
	790	default:
[de62360d]	791	ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( base->buildDecl( "", DeclarationNode::NoStorageClass, 0, false, false, LinkageSpec::Cforall ) ) );
[68cd1ce]	792	} // switch
[b87a5ed]	793	} else {
[68cd1ce]	794	ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) );
	795	} // if
[b87a5ed]	796	return ft;
[51b7345]	797	}
	798
[c8ffe20b]	799	AggregateDecl *TypeData::buildAggregate() const {
[b87a5ed]	800	assert( kind == Aggregate );
	801	AggregateDecl *at;
	802	switch ( aggregate->kind ) {
	803	case DeclarationNode::Struct:
	804	at = new StructDecl( aggregate->name );
	805	break;
	806	case DeclarationNode::Union:
	807	at = new UnionDecl( aggregate->name );
	808	break;
	809	case DeclarationNode::Context:
	810	at = new ContextDecl( aggregate->name );
	811	break;
	812	default:
	813	assert( false );
[68cd1ce]	814	} // switch
[b87a5ed]	815	buildList( aggregate->params, at->get_parameters() );
[721f17a]	816	buildList( aggregate->fields, at->get_members() );
[b87a5ed]	817
	818	return at;
[51b7345]	819	}
	820
	821	/// namespace {
	822	/// Type*
	823	/// makeType( Declaration* decl )
	824	/// {
[c8ffe20b]	825	/// if ( DeclarationWithType dwt = dynamic_cast< DeclarationWithType >( decl ) ) {
[51b7345]	826	/// return dwt->get_type()->clone();
	827	/// } else {
	828	/// return 0;
	829	/// }
	830	/// }
	831	/// }
	832
[c8ffe20b]	833	ReferenceToType *TypeData::buildAggInst() const {
[b87a5ed]	834	assert( kind == AggregateInst );
	835
	836	ReferenceToType *ret;
	837	if ( aggInst->aggregate->kind == Enum ) {
	838	ret = new EnumInstType( buildQualifiers(), aggInst->aggregate->enumeration->name );
	839	} else {
	840	assert( aggInst->aggregate->kind == Aggregate );
	841	switch ( aggInst->aggregate->aggregate->kind ) {
	842	case DeclarationNode::Struct:
	843	ret = new StructInstType( buildQualifiers(), aggInst->aggregate->aggregate->name );
	844	break;
	845	case DeclarationNode::Union:
	846	ret = new UnionInstType( buildQualifiers(), aggInst->aggregate->aggregate->name );
	847	break;
	848	case DeclarationNode::Context:
	849	ret = new ContextInstType( buildQualifiers(), aggInst->aggregate->aggregate->name );
	850	break;
	851	default:
	852	assert( false );
[68cd1ce]	853	} // switch
	854	} // if
[b87a5ed]	855	buildList( aggInst->params, ret->get_parameters() );
	856	buildForall( forall, ret->get_forall() );
	857	return ret;
[51b7345]	858	}
	859
[68cd1ce]	860	NamedTypeDecl *TypeData::buildSymbolic( const std::string &name, DeclarationNode::StorageClass sc ) const {
[b87a5ed]	861	assert( kind == Symbolic );
	862	NamedTypeDecl *ret;
	863	if ( symbolic->isTypedef ) {
	864	ret = new TypedefDecl( name, sc, maybeBuild< Type >( base ) );
	865	} else {
	866	ret = new TypeDecl( name, sc, maybeBuild< Type >( base ), TypeDecl::Any );
[68cd1ce]	867	} // if
[b87a5ed]	868	buildList( symbolic->params, ret->get_parameters() );
	869	buildList( symbolic->assertions, ret->get_assertions() );
	870	return ret;
[51b7345]	871	}
	872
[c8ffe20b]	873	TypeDecl *TypeData::buildVariable() const {
[b87a5ed]	874	assert( kind == Variable );
	875	static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
[51b7345]	876
[68cd1ce]	877	TypeDecl *ret = new TypeDecl( variable->name, DeclarationNode::NoStorageClass, 0, kindMap[ variable->tyClass ] );
[b87a5ed]	878	buildList( variable->assertions, ret->get_assertions() );
	879	return ret;
[51b7345]	880	}
	881
[c8ffe20b]	882	EnumDecl *TypeData::buildEnum() const {
[b87a5ed]	883	assert( kind == Enum );
	884	EnumDecl *ret = new EnumDecl( enumeration->name );
	885	buildList( enumeration->constants, ret->get_members() );
	886	return ret;
[51b7345]	887	}
	888
[c8ffe20b]	889	TypeInstType *TypeData::buildSymbolicInst() const {
[b87a5ed]	890	assert( kind == SymbolicInst );
	891	TypeInstType *ret = new TypeInstType( buildQualifiers(), symbolic->name, false );
	892	buildList( symbolic->actuals, ret->get_parameters() );
	893	buildForall( forall, ret->get_forall() );
	894	return ret;
[51b7345]	895	}
	896
[c8ffe20b]	897	TupleType *TypeData::buildTuple() const {
[b87a5ed]	898	assert( kind == Tuple );
	899	TupleType *ret = new TupleType( buildQualifiers() );
	900	buildTypeList( tuple->members, ret->get_types() );
	901	buildForall( forall, ret->get_forall() );
	902	return ret;
[51b7345]	903	}
	904
[c8ffe20b]	905	TypeofType *TypeData::buildTypeof() const {
[b87a5ed]	906	assert( kind == Typeof );
	907	assert( typeexpr );
	908	assert( typeexpr->expr );
	909	TypeofType *ret = new TypeofType( buildQualifiers(), typeexpr->expr->build() );
	910	return ret;
[51b7345]	911	}
	912
[c8ffe20b]	913	AttrType *TypeData::buildAttr() const {
[b87a5ed]	914	assert( kind == Attr );
	915	assert( attr );
	916	AttrType *ret;
	917	if ( attr->expr ) {
	918	ret = new AttrType( buildQualifiers(), attr->name, attr->expr->build() );
	919	} else {
	920	assert( attr->type );
	921	ret = new AttrType( buildQualifiers(), attr->name, attr->type->buildType() );
[68cd1ce]	922	} // if
[b87a5ed]	923	return ret;
[51b7345]	924	}
[b87a5ed]	925
	926	// Local Variables: //
	927	// tab-width: 4 //
	928	// mode: c++ //
	929	// compile-command: "make install" //
	930	// End: //

Note: See TracBrowser for help on using the repository browser.

Download in other formats: