class name change ParseData -> Compiler

18 files changed, 444 insertions, 444 deletions

diff --git a/colm/analysis.cc b/colm/analysis.cc
index 88a13644..cc13b03c 100644
--- a/colm/analysis.cc
+++ b/colm/analysis.cc
@@ -40,7 +40,7 @@
 using namespace std;
 
 
-void ParseData::prepGrammar()
+void Compiler::prepGrammar()
 {
 	/* This will create language elements. */
 	wrapNonTerminals();
@@ -64,7 +64,7 @@ void ParseData::prepGrammar()
 	runtimeData = new RuntimeData;
 }
 
-void ParseData::semanticAnalysis()
+void Compiler::semanticAnalysis()
 {
 	beginProcessing();
 	initKeyOps();
diff --git a/colm/closure.cc b/colm/closure.cc
index 7590a0ac..37b0e259 100644
--- a/colm/closure.cc
+++ b/colm/closure.cc
@@ -30,7 +30,7 @@
 using std::endl;
 using std::cerr;
 
-void ParseData::lr0BringInItem( PdaGraph *pdaGraph, PdaState *dest, PdaState *prodState, 
+void Compiler::lr0BringInItem( PdaGraph *pdaGraph, PdaState *dest, PdaState *prodState, 
 		PdaTrans *expandFrom, Definition *prod )
 {
 	/* We use dot sets for finding unique states. In the future, should merge
@@ -105,7 +105,7 @@ void ParseData::lr0BringInItem( PdaGraph *pdaGraph, PdaState *dest, PdaState *pr
 	}
 }
 
-void ParseData::lr0InvokeClosure( PdaGraph *pdaGraph, PdaState *state )
+void Compiler::lr0InvokeClosure( PdaGraph *pdaGraph, PdaState *state )
 {
 	/* State should not already be closed. */
 	assert( !state->inClosedMap );
@@ -175,7 +175,7 @@ void ParseData::lr0InvokeClosure( PdaGraph *pdaGraph, PdaState *state )
  * first search of the tree we build. Note, there are back edges in this
  * tree. They are the edges made when upon closure, a dot set exists
  * already. */
-void ParseData::lr0CloseAllStates( PdaGraph *pdaGraph )
+void Compiler::lr0CloseAllStates( PdaGraph *pdaGraph )
 {
 	/* While there are items on the closure queue. */
 	while ( pdaGraph->stateClosureQueue.length() > 0 ) {
@@ -188,7 +188,7 @@ void ParseData::lr0CloseAllStates( PdaGraph *pdaGraph )
 	}
 }
 
-void ParseData::transferCommits( PdaGraph *pdaGraph, PdaTrans *trans, 
+void Compiler::transferCommits( PdaGraph *pdaGraph, PdaTrans *trans, 
 		PdaState *state, long prodId )
 {
 	ProdIdPairSet &pendingCommits = state->pendingCommits;
@@ -198,7 +198,7 @@ void ParseData::transferCommits( PdaGraph *pdaGraph, PdaTrans *trans,
 	}
 }
 
-void ParseData::lalr1AddFollow2( PdaGraph *pdaGraph, PdaTrans *trans, FollowToAdd &followKeys )
+void Compiler::lalr1AddFollow2( PdaGraph *pdaGraph, PdaTrans *trans, FollowToAdd &followKeys )
 {
 	for ( ExpandToSet::Iter ets = trans->expandTo; ets.lte(); ets++ ) {
 		int prodId = ets->prodId;
@@ -244,7 +244,7 @@ long PdaTrans::maxPrior()
 	return prior;
 }
 
-void ParseData::lalr1AddFollow1( PdaGraph *pdaGraph, PdaState *state )
+void Compiler::lalr1AddFollow1( PdaGraph *pdaGraph, PdaState *state )
 {
 	/* Finding non-terminals into the state. */
 	for ( PdaTransInList::Iter in = state->inRange; in.lte(); in++ ) {
@@ -268,7 +268,7 @@ void ParseData::lalr1AddFollow1( PdaGraph *pdaGraph, PdaState *state )
 	}
 }
 
-void ParseData::lalr1AddFollow2( PdaGraph *pdaGraph, PdaTrans *trans, 
+void Compiler::lalr1AddFollow2( PdaGraph *pdaGraph, PdaTrans *trans, 
 		long followKey, long prior )
 {
 	for ( ExpandToSet::Iter ets = trans->expandTo; ets.lte(); ets++ ) {
@@ -300,7 +300,7 @@ void ParseData::lalr1AddFollow2( PdaGraph *pdaGraph, PdaTrans *trans,
 	}
 }
 
-void ParseData::lalr1AddFollow1( PdaGraph *pdaGraph, PdaTrans *trans )
+void Compiler::lalr1AddFollow1( PdaGraph *pdaGraph, PdaTrans *trans )
 {
 	PdaState *state = trans->fromState;
 	int fkey = trans->lowKey; 
@@ -320,7 +320,7 @@ void ParseData::lalr1AddFollow1( PdaGraph *pdaGraph, PdaTrans *trans )
 }
 
 /* Add follow sets to an LR(0) graph to make it LALR(1). */
-void ParseData::lalr1AddFollowSets( PdaGraph *pdaGraph, LangElSet &parserEls )
+void Compiler::lalr1AddFollowSets( PdaGraph *pdaGraph, LangElSet &parserEls )
 {
 	/* Make the state that all reduction actions go to. Since a reduction pops
 	 * states of the stack and sets the new target state, this state is
@@ -354,7 +354,7 @@ void ParseData::lalr1AddFollowSets( PdaGraph *pdaGraph, LangElSet &parserEls )
 	}
 }
 
-void ParseData::linkExpansions( PdaGraph *pdaGraph )
+void Compiler::linkExpansions( PdaGraph *pdaGraph )
 {
 	pdaGraph->setStateNumbers();
 	for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) {
@@ -384,7 +384,7 @@ void ParseData::linkExpansions( PdaGraph *pdaGraph )
 }
 
 /* Add terminal versions of all nonterminal transitions. */
-void ParseData::addDupTerms( PdaGraph *pdaGraph )
+void Compiler::addDupTerms( PdaGraph *pdaGraph )
 {
 	for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) {
 		PdaTransList newTranitions;
@@ -418,7 +418,7 @@ void ParseData::addDupTerms( PdaGraph *pdaGraph )
 }
 
 /* Generate a LALR(1) graph. */
-void ParseData::lalr1GenerateParser( PdaGraph *pdaGraph, LangElSet &parserEls )
+void Compiler::lalr1GenerateParser( PdaGraph *pdaGraph, LangElSet &parserEls )
 {
 	/* Make the intial graph. */
 	pdaGraph->langElIndex = langElIndex;
diff --git a/colm/codegen.cc b/colm/codegen.cc
index d1553971..487b9f83 100644
--- a/colm/codegen.cc
+++ b/colm/codegen.cc
@@ -35,7 +35,7 @@ using std::string;
 using std::cerr;
 using std::endl;
 
-void ParseData::openNameSpace( ostream &out, Namespace *nspace )
+void Compiler::openNameSpace( ostream &out, Namespace *nspace )
 {
 	if ( nspace == defaultNamespace || nspace == rootNamespace )
 		return;
@@ -44,7 +44,7 @@ void ParseData::openNameSpace( ostream &out, Namespace *nspace )
 	out << "namespace " << nspace->name << " { ";
 }
 
-void ParseData::closeNameSpace( ostream &out, Namespace *nspace )
+void Compiler::closeNameSpace( ostream &out, Namespace *nspace )
 {
 	if ( nspace == defaultNamespace || nspace == rootNamespace )
 		return;
@@ -53,7 +53,7 @@ void ParseData::closeNameSpace( ostream &out, Namespace *nspace )
 	out << " }";
 }
 
-void ParseData::generateExports()
+void Compiler::generateExports()
 {
 	ostream &out = *outStream;
 
@@ -200,7 +200,7 @@ void ParseData::generateExports()
 	out << "#endif\n";
 }
 
-void ParseData::generateExportsImpl()
+void Compiler::generateExportsImpl()
 {
 	ostream &out = *outStream;
 
diff --git a/colm/compile.cc b/colm/compile.cc
index 14084a5a..794927ad 100644
--- a/colm/compile.cc
+++ b/colm/compile.cc
@@ -31,7 +31,7 @@ using std::cout;
 using std::cerr;
 using std::endl;
 
-void ParseData::initUniqueTypes( )
+void Compiler::initUniqueTypes( )
 {
 	uniqueTypeNil = new UniqueType( TYPE_NIL );
 	uniqueTypePtr = new UniqueType( TYPE_TREE, ptrLangEl );
@@ -174,7 +174,7 @@ ObjMethod *initFunction( UniqueType *retType, ObjectDef *obj,
 	return objMethod;
 }
 
-IterDef *ParseData::findIterDef( IterDef::Type type, Function *func )
+IterDef *Compiler::findIterDef( IterDef::Type type, Function *func )
 {
 	IterDefSetEl *el = iterDefSet.find( IterDef( type, func ) );
 	if ( el == 0 )
@@ -182,7 +182,7 @@ IterDef *ParseData::findIterDef( IterDef::Type type, Function *func )
 	return &el->key;
 }
 
-IterDef *ParseData::findIterDef( IterDef::Type type )
+IterDef *Compiler::findIterDef( IterDef::Type type )
 {
 	IterDefSetEl *el = iterDefSet.find( IterDef( type ) );
 	if ( el == 0 )
@@ -190,7 +190,7 @@ IterDef *ParseData::findIterDef( IterDef::Type type )
 	return &el->key;
 }
 
-UniqueType *ParseData::findUniqueType( int typeId )
+UniqueType *Compiler::findUniqueType( int typeId )
 {
 	UniqueType searchKey( typeId );
 	UniqueType *uniqueType = uniqeTypeMap.find( &searchKey );
@@ -201,7 +201,7 @@ UniqueType *ParseData::findUniqueType( int typeId )
 	return uniqueType;
 }
 
-UniqueType *ParseData::findUniqueType( int typeId, LangEl *langEl )
+UniqueType *Compiler::findUniqueType( int typeId, LangEl *langEl )
 {
 	UniqueType searchKey( typeId, langEl );
 	UniqueType *uniqueType = uniqeTypeMap.find( &searchKey );
@@ -212,7 +212,7 @@ UniqueType *ParseData::findUniqueType( int typeId, LangEl *langEl )
 	return uniqueType;
 }
 
-UniqueType *ParseData::findUniqueType( int typeId, IterDef *iterDef )
+UniqueType *Compiler::findUniqueType( int typeId, IterDef *iterDef )
 {
 	UniqueType searchKey( typeId, iterDef );
 	UniqueType *uniqueType = uniqeTypeMap.find( &searchKey );
@@ -350,13 +350,13 @@ long sizeOfField( UniqueType *fieldUT )
 	return size;
 }
 
-void ObjectDef::referenceField( ParseData *pd, ObjField *field )
+void ObjectDef::referenceField( Compiler *pd, ObjField *field )
 {
 	field->beenReferenced = true;
 	initField( pd, field );
 }
 
-void ObjectDef::initField( ParseData *pd, ObjField *field )
+void ObjectDef::initField( Compiler *pd, ObjField *field )
 {
 	if ( !field->beenInitialized ) {
 		field->beenInitialized = true;
@@ -386,7 +386,7 @@ void ObjectDef::initField( ParseData *pd, ObjField *field )
 	}
 }
 
-UniqueType *LangVarRef::loadFieldInstr( ParseData *pd, CodeVect &code, 
+UniqueType *LangVarRef::loadFieldInstr( Compiler *pd, CodeVect &code, 
 		ObjectDef *inObject, ObjField *el, bool forWriting, bool revert ) const
 {
 	/* Ensure that the field is referenced. */
@@ -433,7 +433,7 @@ UniqueType *LangVarRef::loadFieldInstr( ParseData *pd, CodeVect &code,
 	return elUT;
 }
 
-ObjectDef *objDefFromUT( ParseData *pd, UniqueType *ut )
+ObjectDef *objDefFromUT( Compiler *pd, UniqueType *ut )
 {
 	ObjectDef *objDef = 0;
 	if ( ut->typeId == TYPE_TREE || ut->typeId == TYPE_REF )
@@ -446,7 +446,7 @@ ObjectDef *objDefFromUT( ParseData *pd, UniqueType *ut )
 }
 
 /* The qualification must start at a local frame. There cannot be any pointer. */
-long LangVarRef::loadQualificationRefs( ParseData *pd, CodeVect &code ) const
+long LangVarRef::loadQualificationRefs( Compiler *pd, CodeVect &code ) const
 {
 	long count = 0;
 	ObjectDef *rootObj = pd->curLocalFrame;
@@ -490,7 +490,7 @@ long LangVarRef::loadQualificationRefs( ParseData *pd, CodeVect &code ) const
 	return count;
 }
 
-void LangVarRef::loadQualification( ParseData *pd, CodeVect &code, 
+void LangVarRef::loadQualification( Compiler *pd, CodeVect &code, 
 		ObjectDef *rootObj, int lastPtrInQual, bool forWriting, bool revert ) const
 {
 	/* Start the search from the root object. */
@@ -560,7 +560,7 @@ void LangVarRef::loadQualification( ParseData *pd, CodeVect &code,
 	}
 }
 
-void LangVarRef::loadContextObj( ParseData *pd, CodeVect &code, 
+void LangVarRef::loadContextObj( Compiler *pd, CodeVect &code, 
 		int lastPtrInQual, bool forWriting ) const
 {
 	/* Start the search in the global object. */
@@ -583,7 +583,7 @@ void LangVarRef::loadContextObj( ParseData *pd, CodeVect &code,
 	loadQualification( pd, code, rootObj, lastPtrInQual, forWriting, true );
 }
 
-void LangVarRef::loadGlobalObj( ParseData *pd, CodeVect &code, 
+void LangVarRef::loadGlobalObj( Compiler *pd, CodeVect &code, 
 		int lastPtrInQual, bool forWriting ) const
 {
 	/* Start the search in the global object. */
@@ -606,21 +606,21 @@ void LangVarRef::loadGlobalObj( ParseData *pd, CodeVect &code,
 	loadQualification( pd, code, rootObj, lastPtrInQual, forWriting, true );
 }
 
-void LangVarRef::loadCustom( ParseData *pd, CodeVect &code, 
+void LangVarRef::loadCustom( Compiler *pd, CodeVect &code, 
 		int lastPtrInQual, bool forWriting ) const
 {
 	/* Start the search in the local frame. */
 	loadQualification( pd, code, pd->curLocalFrame, lastPtrInQual, forWriting, true );
 }
 
-void LangVarRef::loadLocalObj( ParseData *pd, CodeVect &code, 
+void LangVarRef::loadLocalObj( Compiler *pd, CodeVect &code, 
 		int lastPtrInQual, bool forWriting ) const
 {
 	/* Start the search in the local frame. */
 	loadQualification( pd, code, pd->curLocalFrame, lastPtrInQual, forWriting, false );
 }
 
-bool LangVarRef::isLocalRef( ParseData *pd ) const
+bool LangVarRef::isLocalRef( Compiler *pd ) const
 {
 	if ( qual->length() > 0 ) {
 		if ( pd->curLocalFrame->findField( qual->data[0].data ) != 0 )
@@ -634,7 +634,7 @@ bool LangVarRef::isLocalRef( ParseData *pd ) const
 	return false;
 }
 
-bool LangVarRef::isContextRef( ParseData *pd ) const
+bool LangVarRef::isContextRef( Compiler *pd ) const
 {
 	if ( pd->context != 0 ) {
 		if ( qual->length() > 0 ) {
@@ -650,7 +650,7 @@ bool LangVarRef::isContextRef( ParseData *pd ) const
 	return false;
 }
 
-bool LangVarRef::isCustom( ParseData *pd ) const
+bool LangVarRef::isCustom( Compiler *pd ) const
 {
 	if ( qual->length() > 0 ) {
 		ObjField *field = pd->curLocalFrame->findField( qual->data[0].data );
@@ -673,7 +673,7 @@ bool LangVarRef::isCustom( ParseData *pd ) const
 	return false;
 }
 
-void LangVarRef::loadObj( ParseData *pd, CodeVect &code, 
+void LangVarRef::loadObj( Compiler *pd, CodeVect &code, 
 		int lastPtrInQual, bool forWriting ) const
 {
 	if ( isCustom( pd ) )
@@ -686,7 +686,7 @@ void LangVarRef::loadObj( ParseData *pd, CodeVect &code,
 		loadGlobalObj( pd, code, lastPtrInQual, forWriting );
 }
 
-VarRefLookup LangVarRef::lookupQualification( ParseData *pd, ObjectDef *rootDef ) const
+VarRefLookup LangVarRef::lookupQualification( Compiler *pd, ObjectDef *rootDef ) const
 {
 	int lastPtrInQual = -1;
 	ObjectDef *searchObjDef = rootDef;
@@ -733,7 +733,7 @@ VarRefLookup LangVarRef::lookupQualification( ParseData *pd, ObjectDef *rootDef
 	return VarRefLookup( lastPtrInQual, firstConstPart, searchObjDef );
 }
 
-VarRefLookup LangVarRef::lookupObj( ParseData *pd ) const
+VarRefLookup LangVarRef::lookupObj( Compiler *pd ) const
 {
 	ObjectDef *rootDef;
 	if ( isLocalRef( pd ) )
@@ -746,7 +746,7 @@ VarRefLookup LangVarRef::lookupObj( ParseData *pd ) const
 	return lookupQualification( pd, rootDef );
 }
 
-VarRefLookup LangVarRef::lookupField( ParseData *pd ) const
+VarRefLookup LangVarRef::lookupField( Compiler *pd ) const
 {
 	/* Lookup the object that the field is in. */
 	VarRefLookup lookup = lookupObj( pd );
@@ -766,7 +766,7 @@ VarRefLookup LangVarRef::lookupField( ParseData *pd ) const
 }
 
 
-VarRefLookup LangVarRef::lookupMethod( ParseData *pd ) 
+VarRefLookup LangVarRef::lookupMethod( Compiler *pd ) 
 {
 	/* Lookup the object that the field is in. */
 	VarRefLookup lookup = lookupObj( pd );
@@ -796,7 +796,7 @@ VarRefLookup LangVarRef::lookupMethod( ParseData *pd )
 	return lookup;
 }
 
-void LangVarRef::setFieldInstr( ParseData *pd, CodeVect &code, 
+void LangVarRef::setFieldInstr( Compiler *pd, CodeVect &code, 
 		ObjectDef *inObject, ObjField *el, UniqueType *exprUT, bool revert ) const
 {
 	/* Ensure that the field is referenced. */
@@ -812,7 +812,7 @@ void LangVarRef::setFieldInstr( ParseData *pd, CodeVect &code,
 		code.appendHalf( el->offset );
 }
 
-bool castAssignment( ParseData *pd, CodeVect &code, UniqueType *destUT, 
+bool castAssignment( Compiler *pd, CodeVect &code, UniqueType *destUT, 
 		UniqueType *destSearchUT, UniqueType *srcUT )
 {
 	if ( destUT == srcUT )
@@ -849,7 +849,7 @@ bool castAssignment( ParseData *pd, CodeVect &code, UniqueType *destUT,
 	return false;
 }
 
-void LangVarRef::setField( ParseData *pd, CodeVect &code, 
+void LangVarRef::setField( Compiler *pd, CodeVect &code, 
 		ObjectDef *inObject, UniqueType *exprUT, bool revert ) const
 {
 	ObjField *el = inObject->findField( name );
@@ -859,7 +859,7 @@ void LangVarRef::setField( ParseData *pd, CodeVect &code,
 	setFieldInstr( pd, code, inObject, el, exprUT, revert );
 }
 
-void LangVarRef::setFieldIter( ParseData *pd, CodeVect &code, 
+void LangVarRef::setFieldIter( Compiler *pd, CodeVect &code, 
 		ObjectDef *inObject, UniqueType *objUT, UniqueType *exprType, bool revert ) const
 {
 	ObjField *el = inObject->findField( name );
@@ -870,7 +870,7 @@ void LangVarRef::setFieldIter( ParseData *pd, CodeVect &code,
 	code.appendHalf( el->offset );
 }
 
-UniqueType *LangVarRef::evaluate( ParseData *pd, CodeVect &code, bool forWriting ) const
+UniqueType *LangVarRef::evaluate( Compiler *pd, CodeVect &code, bool forWriting ) const
 {
 	/* Lookup the loadObj. */
 	VarRefLookup lookup = lookupField( pd );
@@ -885,7 +885,7 @@ UniqueType *LangVarRef::evaluate( ParseData *pd, CodeVect &code, bool forWriting
 	return ut;
 }
 
-void LangVarRef::canTakeRef( ParseData *pd, VarRefLookup &lookup ) const
+void LangVarRef::canTakeRef( Compiler *pd, VarRefLookup &lookup ) const
 {
 	bool canTake = false;
 
@@ -906,7 +906,7 @@ void LangVarRef::canTakeRef( ParseData *pd, VarRefLookup &lookup ) const
 }
 
 /* Return the field referenced. */
-ObjField *LangVarRef::preEvaluateRef( ParseData *pd, CodeVect &code ) const
+ObjField *LangVarRef::preEvaluateRef( Compiler *pd, CodeVect &code ) const
 {
 	VarRefLookup lookup = lookupField( pd );
 
@@ -918,7 +918,7 @@ ObjField *LangVarRef::preEvaluateRef( ParseData *pd, CodeVect &code ) const
 }
 
 /* Return the field referenced. */
-ObjField *LangVarRef::evaluateRef( ParseData *pd, CodeVect &code, long pushCount ) const
+ObjField *LangVarRef::evaluateRef( Compiler *pd, CodeVect &code, long pushCount ) const
 {
 	VarRefLookup lookup = lookupField( pd );
 
@@ -956,7 +956,7 @@ ObjField *LangVarRef::evaluateRef( ParseData *pd, CodeVect &code, long pushCount
 	return lookup.objField;
 }
 
-ObjField **LangVarRef::evaluateArgs( ParseData *pd, CodeVect &code, 
+ObjField **LangVarRef::evaluateArgs( Compiler *pd, CodeVect &code, 
 		VarRefLookup &lookup, ExprVect *args ) const
 {
 	/* Parameter list is given only for user defined methods. Otherwise it
@@ -1046,7 +1046,7 @@ ObjField **LangVarRef::evaluateArgs( ParseData *pd, CodeVect &code,
 	return paramRefs;
 }
 
-void LangVarRef::resetActiveRefs( ParseData *pd, VarRefLookup &lookup, ObjField **paramRefs ) const
+void LangVarRef::resetActiveRefs( Compiler *pd, VarRefLookup &lookup, ObjField **paramRefs ) const
 {
 	/* Parameter list is given only for user defined methods. Otherwise it
 	 * will be null. */
@@ -1057,7 +1057,7 @@ void LangVarRef::resetActiveRefs( ParseData *pd, VarRefLookup &lookup, ObjField
 }
 
 
-void LangVarRef::callOperation( ParseData *pd, CodeVect &code, VarRefLookup &lookup ) const
+void LangVarRef::callOperation( Compiler *pd, CodeVect &code, VarRefLookup &lookup ) const
 {
 	/* This is for writing if it is a non-const builtin. */
 	bool forWriting = lookup.objMethod->func == 0 && 
@@ -1104,7 +1104,7 @@ void LangVarRef::callOperation( ParseData *pd, CodeVect &code, VarRefLookup &loo
 		code.appendHalf( lookup.objMethod->funcId );
 }
 
-void LangVarRef::popRefQuals( ParseData *pd, CodeVect &code, 
+void LangVarRef::popRefQuals( Compiler *pd, CodeVect &code, 
 		VarRefLookup &lookup, ExprVect *args ) const
 {
 	long popCount = 0;
@@ -1130,7 +1130,7 @@ void LangVarRef::popRefQuals( ParseData *pd, CodeVect &code,
 	}
 }
 
-UniqueType *LangVarRef::evaluateCall( ParseData *pd, CodeVect &code, ExprVect *args ) 
+UniqueType *LangVarRef::evaluateCall( Compiler *pd, CodeVect &code, ExprVect *args ) 
 {
 	/* Evaluate the object. */
 	VarRefLookup lookup = lookupMethod( pd );
@@ -1150,7 +1150,7 @@ UniqueType *LangVarRef::evaluateCall( ParseData *pd, CodeVect &code, ExprVect *a
 	return lookup.uniqueType;
 }
 
-UniqueType *LangTerm::evaluateMatch( ParseData *pd, CodeVect &code ) const
+UniqueType *LangTerm::evaluateMatch( Compiler *pd, CodeVect &code ) const
 {
 	/* Add the vars bound by the pattern into the local scope. */
 	for ( PatternItemList::Iter item = *pattern->list; item.lte(); item++ ) {
@@ -1185,7 +1185,7 @@ UniqueType *LangTerm::evaluateMatch( ParseData *pd, CodeVect &code ) const
 	return ut;
 }
 
-UniqueType *LangTerm::evaluateNew( ParseData *pd, CodeVect &code ) const
+UniqueType *LangTerm::evaluateNew( Compiler *pd, CodeVect &code ) const
 {
 	/* Evaluate the expression. */
 	UniqueType *ut = expr->evaluate( pd, code );
@@ -1196,7 +1196,7 @@ UniqueType *LangTerm::evaluateNew( ParseData *pd, CodeVect &code ) const
 	return pd->findUniqueType( TYPE_PTR, ut->langEl );
 }
 
-void LangTerm::assignFieldArgs( ParseData *pd, CodeVect &code, UniqueType *replUT ) const
+void LangTerm::assignFieldArgs( Compiler *pd, CodeVect &code, UniqueType *replUT ) const
 {
 	/* Now assign the field initializations. Note that we need to do this in
 	 * reverse because the last expression evaluated is at the top of the
@@ -1226,7 +1226,7 @@ void LangTerm::assignFieldArgs( ParseData *pd, CodeVect &code, UniqueType *replU
 	}
 }
 
-UniqueType *LangTerm::evaluateConstruct( ParseData *pd, CodeVect &code ) const
+UniqueType *LangTerm::evaluateConstruct( Compiler *pd, CodeVect &code ) const
 {
 	/* Evaluate the initialization expressions. */
 	if ( fieldInitArgs != 0 && fieldInitArgs->length() > 0 ) {
@@ -1288,7 +1288,7 @@ UniqueType *LangTerm::evaluateConstruct( ParseData *pd, CodeVect &code ) const
 	return replUT;
 }
 
-UniqueType *LangTerm::evaluateParse( ParseData *pd, CodeVect &code, bool stop ) const
+UniqueType *LangTerm::evaluateParse( Compiler *pd, CodeVect &code, bool stop ) const
 {
 	UniqueType *ut = typeRef->uniqueType;
 	assert( ut != 0 );
@@ -1428,7 +1428,7 @@ UniqueType *LangTerm::evaluateParse( ParseData *pd, CodeVect &code, bool stop )
 	return ut;
 }
 
-UniqueType *LangTerm::evaluateEmbedString( ParseData *pd, CodeVect &code ) const
+UniqueType *LangTerm::evaluateEmbedString( Compiler *pd, CodeVect &code ) const
 {
 	/* Assign bind ids to the variables in the replacement. */
 	for ( ReplItemList::Iter item = *replItemList; item.lte(); item++ ) {
@@ -1473,7 +1473,7 @@ UniqueType *LangTerm::evaluateEmbedString( ParseData *pd, CodeVect &code ) const
 	return pd->uniqueTypeStr;
 }
 
-UniqueType *LangTerm::evaluate( ParseData *pd, CodeVect &code ) const
+UniqueType *LangTerm::evaluate( Compiler *pd, CodeVect &code ) const
 {
 	switch ( type ) {
 		case VarRefType:
@@ -1554,7 +1554,7 @@ UniqueType *LangTerm::evaluate( ParseData *pd, CodeVect &code ) const
 	return 0;
 }
 
-UniqueType *LangExpr::evaluate( ParseData *pd, CodeVect &code ) const
+UniqueType *LangExpr::evaluate( Compiler *pd, CodeVect &code ) const
 {
 	switch ( type ) {
 		case BinaryType: {
@@ -1756,7 +1756,7 @@ UniqueType *LangExpr::evaluate( ParseData *pd, CodeVect &code ) const
 	return 0;
 }
 
-void LangVarRef::assignValue( ParseData *pd, CodeVect &code, 
+void LangVarRef::assignValue( Compiler *pd, CodeVect &code, 
 		UniqueType *exprUT ) const
 {
 	/* Lookup the left hand side of the assignment. */
@@ -1794,9 +1794,9 @@ void LangVarRef::assignValue( ParseData *pd, CodeVect &code,
 		setField( pd, code, lookup.inObject, exprUT, revert );
 }
 
-UniqueType *LangTerm::evaluateMakeToken( ParseData *pd, CodeVect &code ) const
+UniqueType *LangTerm::evaluateMakeToken( Compiler *pd, CodeVect &code ) const
 {
-//	if ( pd->compileContext != ParseData::CompileTranslation )
+//	if ( pd->compileContext != Compiler::CompileTranslation )
 //		error(loc) << "make_token can be used only in a translation block" << endp;
 
 	/* Match the number of arguments. */
@@ -1822,9 +1822,9 @@ UniqueType *LangTerm::evaluateMakeToken( ParseData *pd, CodeVect &code ) const
 	return pd->uniqueTypeAny;
 }
 
-UniqueType *LangTerm::evaluateMakeTree( ParseData *pd, CodeVect &code ) const
+UniqueType *LangTerm::evaluateMakeTree( Compiler *pd, CodeVect &code ) const
 {
-	if ( pd->compileContext != ParseData::CompileTranslation )
+	if ( pd->compileContext != Compiler::CompileTranslation )
 		error(loc) << "make_tree can be used only in a translation block" << endp;
 
 	/* Match the number of arguments. */
@@ -1847,7 +1847,7 @@ UniqueType *LangTerm::evaluateMakeTree( ParseData *pd, CodeVect &code ) const
 	return pd->uniqueTypeAny;
 }
 
-void LangStmt::compileForIterBody( ParseData *pd, 
+void LangStmt::compileForIterBody( Compiler *pd, 
 		CodeVect &code, UniqueType *iterUT ) const
 {
 	/* Remember the top of the loop. */
@@ -1909,7 +1909,7 @@ void LangStmt::compileForIterBody( ParseData *pd,
 	/* Clean up any prepush args. */
 }
 
-LangTerm *LangStmt::chooseDefaultIter( ParseData *pd, LangTerm *fromVarRef ) const
+LangTerm *LangStmt::chooseDefaultIter( Compiler *pd, LangTerm *fromVarRef ) const
 {
 	/* Lookup the lang term and decide what iterator to use based
 	 * on its type. */
@@ -1943,7 +1943,7 @@ LangTerm *LangStmt::chooseDefaultIter( ParseData *pd, LangTerm *fromVarRef ) con
 	return callLangTerm;
 }
 
-void LangStmt::compileForIter( ParseData *pd, CodeVect &code ) const
+void LangStmt::compileForIter( Compiler *pd, CodeVect &code ) const
 {
 	pd->curLocalFrame->iterPushScope();
 
@@ -2007,7 +2007,7 @@ void LangStmt::compileForIter( ParseData *pd, CodeVect &code ) const
 	pd->curLocalFrame->iterPopScope();
 }
 
-void LangStmt::compileWhile( ParseData *pd, CodeVect &code ) const
+void LangStmt::compileWhile( Compiler *pd, CodeVect &code ) const
 {
 	pd->curLocalFrame->iterPushScope();
 
@@ -2044,7 +2044,7 @@ void LangStmt::compileWhile( ParseData *pd, CodeVect &code ) const
 	pd->curLocalFrame->iterPopScope();
 }
 
-void LangStmt::evaluateParserItems( ParseData *pd, CodeVect &code ) const
+void LangStmt::evaluateParserItems( Compiler *pd, CodeVect &code ) const
 {
 	varRef->evaluate( pd, code );
 
@@ -2117,7 +2117,7 @@ void LangStmt::evaluateParserItems( ParseData *pd, CodeVect &code ) const
 	code.append( IN_POP );
 }
 
-void LangStmt::compile( ParseData *pd, CodeVect &code ) const
+void LangStmt::compile( Compiler *pd, CodeVect &code ) const
 {
 	switch ( type ) {
 		case PrintType: 
@@ -2285,13 +2285,13 @@ void LangStmt::compile( ParseData *pd, CodeVect &code ) const
 	}
 }
 
-void CodeBlock::compile( ParseData *pd, CodeVect &code ) const
+void CodeBlock::compile( Compiler *pd, CodeVect &code ) const
 {
 	for ( StmtList::Iter stmt = *stmtList; stmt.lte(); stmt++ )
 		stmt->compile( pd, code );
 }
 
-void ParseData::addMatchLength( ObjectDef *frame, LangEl *lel )
+void Compiler::addMatchLength( ObjectDef *frame, LangEl *lel )
 {
 	/* Make the type ref. */
 	TypeRef *typeRef = new TypeRef( InputLoc(), uniqueTypeInt );
@@ -2306,7 +2306,7 @@ void ParseData::addMatchLength( ObjectDef *frame, LangEl *lel )
 	frame->insertField( el->name, el );
 }
 
-void ParseData::addMatchText( ObjectDef *frame, LangEl *lel )
+void Compiler::addMatchText( ObjectDef *frame, LangEl *lel )
 {
 	/* Make the type ref. */
 	TypeRef *typeRef = new TypeRef( InputLoc(), uniqueTypeStr );
@@ -2321,7 +2321,7 @@ void ParseData::addMatchText( ObjectDef *frame, LangEl *lel )
 	frame->insertField( el->name, el );
 }
 
-void ParseData::addInput( ObjectDef *frame )
+void Compiler::addInput( ObjectDef *frame )
 {
 	/* Make the type ref. */
 	TypeRef *typeRef = new TypeRef( InputLoc(), uniqueTypeInput );
@@ -2339,7 +2339,7 @@ void ParseData::addInput( ObjectDef *frame )
 	frame->insertField( el->name, el );
 }
 
-void ParseData::addCtx( ObjectDef *frame )
+void Compiler::addCtx( ObjectDef *frame )
 {
 	/* Make the type ref. */
 	TypeRef *typeRef = new TypeRef( InputLoc(), uniqueTypeStream );
@@ -2357,7 +2357,7 @@ void ParseData::addCtx( ObjectDef *frame )
 	frame->insertField( el->name, el );
 }
 
-void ParseData::initFieldInstructions( ObjField *el )
+void Compiler::initFieldInstructions( ObjField *el )
 {
 	el->inGetR =   IN_GET_FIELD_R;
 	el->inGetWC =  IN_GET_FIELD_WC;
@@ -2366,21 +2366,21 @@ void ParseData::initFieldInstructions( ObjField *el )
 	el->inSetWV =  IN_SET_FIELD_WV;
 }
 
-void ParseData::initLocalInstructions( ObjField *el )
+void Compiler::initLocalInstructions( ObjField *el )
 {
 	el->inGetR =   IN_GET_LOCAL_R;
 	el->inGetWC =  IN_GET_LOCAL_WC;
 	el->inSetWC =  IN_SET_LOCAL_WC;
 }
 
-void ParseData::initLocalRefInstructions( ObjField *el )
+void Compiler::initLocalRefInstructions( ObjField *el )
 {
 	el->inGetR =   IN_GET_LOCAL_REF_R;
 	el->inGetWC =  IN_GET_LOCAL_REF_WC;
 	el->inSetWC =  IN_SET_LOCAL_REF_WC;
 }
 
-void ParseData::initIntObject( )
+void Compiler::initIntObject( )
 {
 	intObj = new ObjectDef( ObjectDef::BuiltinType, "int", nextObjectId++ );
 	intLangEl->objectDef = intObj;
@@ -2390,7 +2390,7 @@ void ParseData::initIntObject( )
 
 /* Add a constant length field to the object. 
  * Opcode supplied by the caller. */
-void ParseData::addLengthField( ObjectDef *objDef, Code getLength )
+void Compiler::addLengthField( ObjectDef *objDef, Code getLength )
 {
 	/* Create the "length" field. */
 	TypeRef *typeRef = new TypeRef( InputLoc(), uniqueTypeInt );
@@ -2404,7 +2404,7 @@ void ParseData::addLengthField( ObjectDef *objDef, Code getLength )
 	objDef->insertField( el->name, el );
 }
 
-void ParseData::initStrObject( )
+void Compiler::initStrObject( )
 {
 	strObj = new ObjectDef( ObjectDef::BuiltinType, "str", nextObjectId++ );
 	strLangEl->objectDef = strObj;
@@ -2422,14 +2422,14 @@ void ParseData::initStrObject( )
 			IN_SPRINTF, IN_SPRINTF, uniqueTypeStr, uniqueTypeInt, true );
 }
 
-void ParseData::initStreamObject( )
+void Compiler::initStreamObject( )
 {
 	streamObj = new ObjectDef( ObjectDef::BuiltinType,
 			"stream", nextObjectId++ );
 	streamLangEl->objectDef = streamObj;
 }
 
-void ParseData::initInputObject( )
+void Compiler::initInputObject( )
 {
 	inputObj = new ObjectDef( ObjectDef::BuiltinType,
 			"accum_stream", nextObjectId++ );
@@ -2443,7 +2443,7 @@ void ParseData::initInputObject( )
 			IN_INPUT_PUSH_IGNORE_WV, IN_INPUT_PUSH_IGNORE_WV, uniqueTypeAny, false );
 }
 
-ObjField *ParseData::makeDataEl()
+ObjField *Compiler::makeDataEl()
 {
 	/* Create the "data" field. */
 	TypeRef *typeRef = new TypeRef( InputLoc(), uniqueTypeStr );
@@ -2461,7 +2461,7 @@ ObjField *ParseData::makeDataEl()
 	return el;
 }
 
-ObjField *ParseData::makePosEl()
+ObjField *Compiler::makePosEl()
 {
 	/* Create the "data" field. */
 	TypeRef *typeRef = new TypeRef( InputLoc(), uniqueTypeInt );
@@ -2478,7 +2478,7 @@ ObjField *ParseData::makePosEl()
 	return el;
 }
 
-ObjField *ParseData::makeLineEl()
+ObjField *Compiler::makeLineEl()
 {
 	/* Create the "data" field. */
 	TypeRef *typeRef = new TypeRef( InputLoc(), uniqueTypeInt );
@@ -2495,7 +2495,7 @@ ObjField *ParseData::makeLineEl()
 	return el;
 }
 
-void ParseData::initTokenObjects( )
+void Compiler::initTokenObjects( )
 {
 	/* Make a default object Definition. */
 	tokenObj = new ObjectDef( ObjectDef::BuiltinType, "token", nextObjectId++ );
@@ -2531,7 +2531,7 @@ void ParseData::initTokenObjects( )
 	}
 }
 
-void ParseData::findLocalTrees( CharSet &trees )
+void Compiler::findLocalTrees( CharSet &trees )
 {
 	/* We exlcude "lhs" from being downrefed because we need to use if after
 	 * the frame is is cleaned and so it must survive. */
@@ -2547,7 +2547,7 @@ void ParseData::findLocalTrees( CharSet &trees )
 	}
 }
 
-void ParseData::makeProdCopies( Definition *prod )
+void Compiler::makeProdCopies( Definition *prod )
 {
 	int pos = 0;
 	for ( ProdElList::Iter pel = *prod->prodElList; pel.lte(); pel++, pos++) {
@@ -2558,7 +2558,7 @@ void ParseData::makeProdCopies( Definition *prod )
 	}
 }
 
-void ParseData::compileReductionCode( Definition *prod )
+void Compiler::compileReductionCode( Definition *prod )
 {
 	CodeBlock *block = prod->redBlock;
 
@@ -2596,7 +2596,7 @@ void ParseData::compileReductionCode( Definition *prod )
 	findLocalTrees( block->trees );
 }
 
-void ParseData::compileTranslateBlock( LangEl *langEl )
+void Compiler::compileTranslateBlock( LangEl *langEl )
 {
 	CodeBlock *block = langEl->transBlock;
 
@@ -2642,7 +2642,7 @@ void ParseData::compileTranslateBlock( LangEl *langEl )
 	findLocalTrees( block->trees );
 }
 
-void ParseData::compilePreEof( TokenRegion *region )
+void Compiler::compilePreEof( TokenRegion *region )
 {
 	CodeBlock *block = region->preEofBlock;
 
@@ -2676,7 +2676,7 @@ void ParseData::compilePreEof( TokenRegion *region )
 	findLocalTrees( block->trees );
 }
 
-void ParseData::compileRootBlock( )
+void Compiler::compileRootBlock( )
 {
 	CodeBlock *block = rootCodeBlock;
 
@@ -2714,7 +2714,7 @@ void ParseData::compileRootBlock( )
 	findLocalTrees( block->trees );
 }
 
-void ParseData::initAllLanguageObjects()
+void Compiler::initAllLanguageObjects()
 {
 	/* Init all user object fields (need consistent size). */
 	for ( LelList::Iter lel = langEls; lel.lte(); lel++ ) {
@@ -2731,7 +2731,7 @@ void ParseData::initAllLanguageObjects()
 		globalObjectDef->initField( this, f->value );
 }
 
-void ParseData::initMapFunctions( GenericType *gen )
+void Compiler::initMapFunctions( GenericType *gen )
 {
 	addLengthField( gen->objDef, IN_MAP_LENGTH );
 	initFunction( gen->utArg, gen->objDef, "find", 
@@ -2744,7 +2744,7 @@ void ParseData::initMapFunctions( GenericType *gen )
 			IN_MAP_REMOVE_WV, IN_MAP_REMOVE_WC, gen->keyUT, false );
 }
 
-void ParseData::initListFunctions( GenericType *gen )
+void Compiler::initListFunctions( GenericType *gen )
 {
 	addLengthField( gen->objDef, IN_LIST_LENGTH );
 
@@ -2759,7 +2759,7 @@ void ParseData::initListFunctions( GenericType *gen )
 			IN_LIST_REMOVE_END_WV, IN_LIST_REMOVE_END_WC, false );
 }
 
-void ParseData::initListField( GenericType *gen, const char *name, int offset )
+void Compiler::initListField( GenericType *gen, const char *name, int offset )
 {
 	/* Make the type ref and create the field. */
 	TypeRef *typeRef = new TypeRef( InputLoc(), gen->utArg );
@@ -2781,14 +2781,14 @@ void ParseData::initListField( GenericType *gen, const char *name, int offset )
 	el->offset = offset;
 }
 
-void ParseData::initListFields( GenericType *gen )
+void Compiler::initListFields( GenericType *gen )
 {
 	initListField( gen, "head", 0 );
 	initListField( gen, "tail", 1 );
 	initListField( gen, "top", 1 );
 }
 
-void ParseData::initVectorFunctions( GenericType *gen )
+void Compiler::initVectorFunctions( GenericType *gen )
 {
 	addLengthField( gen->objDef, IN_VECTOR_LENGTH );
 	initFunction( uniqueTypeInt, gen->objDef, "append", 
@@ -2797,13 +2797,13 @@ void ParseData::initVectorFunctions( GenericType *gen )
 			IN_VECTOR_INSERT_WV, IN_VECTOR_INSERT_WC, uniqueTypeInt, gen->utArg, false );
 }
 
-void ParseData::initParserFunctions( GenericType *gen )
+void Compiler::initParserFunctions( GenericType *gen )
 {
 	initFunction( gen->utArg, gen->objDef, "finish", 
 			IN_PARSE_FINISH_WV, IN_PARSE_FINISH_WC, true );
 }
 
-void ParseData::initCtxField( GenericType *gen )
+void Compiler::initCtxField( GenericType *gen )
 {
 	LangEl *langEl = gen->utArg->langEl;
 	Context *context = langEl->contextIn;
@@ -2826,14 +2826,14 @@ void ParseData::initCtxField( GenericType *gen )
 	el->beenInitialized = true;
 }
 
-void ParseData::initParserFields( GenericType *gen )
+void Compiler::initParserFields( GenericType *gen )
 {
 	LangEl *langEl = gen->utArg->langEl;
 	if ( langEl->contextIn != 0 )
 		initCtxField( gen );
 }
 
-void ParseData::initGenericTypes()
+void Compiler::initGenericTypes()
 {
 	for ( NamespaceList::Iter ns = namespaceList; ns.lte(); ns++ ) {
 		for ( GenericList::Iter gen = ns->genericList; gen.lte(); gen++ ) {
@@ -2869,7 +2869,7 @@ void ParseData::initGenericTypes()
 	}
 }
 
-void ParseData::makeFuncVisible( Function *func, bool isUserIter )
+void Compiler::makeFuncVisible( Function *func, bool isUserIter )
 {
 	func->localFrame = func->codeBlock->localFrame;
 
@@ -2937,7 +2937,7 @@ void ParseData::makeFuncVisible( Function *func, bool isUserIter )
 	globalObjectDef->objMethodMap->insert( func->name, objMethod );
 }
 
-void ParseData::compileUserIter( Function *func, CodeVect &code )
+void Compiler::compileUserIter( Function *func, CodeVect &code )
 {
 	CodeBlock *block = func->codeBlock;
 
@@ -2963,7 +2963,7 @@ void ParseData::compileUserIter( Function *func, CodeVect &code )
 	}
 }
 
-void ParseData::compileUserIter( Function *func )
+void Compiler::compileUserIter( Function *func )
 {
 	CodeBlock *block = func->codeBlock;
 
@@ -2990,7 +2990,7 @@ void ParseData::compileUserIter( Function *func )
 }
 
 /* Called for each type of function compile: revert and commit. */
-void ParseData::compileFunction( Function *func, CodeVect &code )
+void Compiler::compileFunction( Function *func, CodeVect &code )
 {
 	CodeBlock *block = func->codeBlock;
 
@@ -3029,7 +3029,7 @@ void ParseData::compileFunction( Function *func, CodeVect &code )
 	code.append( IN_RET );
 }
 
-void ParseData::compileFunction( Function *func )
+void Compiler::compileFunction( Function *func )
 {
 	CodeBlock *block = func->codeBlock;
 
@@ -3056,7 +3056,7 @@ void ParseData::compileFunction( Function *func )
 	findLocalTrees( block->trees );
 }
 
-void ParseData::makeDefaultIterators()
+void Compiler::makeDefaultIterators()
 {
 	/* Tree iterator. */
 	{
@@ -3109,7 +3109,7 @@ void ParseData::makeDefaultIterators()
 	}
 }
 
-void ParseData::addStdin()
+void Compiler::addStdin()
 {
 	/* Make the type ref. */
 	TypeRef *typeRef = new TypeRef( InputLoc(), uniqueTypeStream );
@@ -3124,7 +3124,7 @@ void ParseData::addStdin()
 	globalObjectDef->insertField( el->name, el );
 }
 
-void ParseData::addStdout()
+void Compiler::addStdout()
 {
 	/* Make the type ref. */
 	TypeRef *typeRef = new TypeRef( InputLoc(), uniqueTypeStr );
@@ -3139,7 +3139,7 @@ void ParseData::addStdout()
 	globalObjectDef->insertField( el->name, el );
 }
 
-void ParseData::addStderr()
+void Compiler::addStderr()
 {
 	/* Make the type ref. */
 	TypeRef *typeRef = new TypeRef( InputLoc(), uniqueTypeStr );
@@ -3154,7 +3154,7 @@ void ParseData::addStderr()
 	globalObjectDef->insertField( el->name, el );
 }
 
-void ParseData::addArgv()
+void Compiler::addArgv()
 {
 	/* Create the field and insert it into the map. */
 	ObjField *el = new ObjField( InputLoc(), argvTypeRef, "argv" );
@@ -3163,7 +3163,7 @@ void ParseData::addArgv()
 	globalObjectDef->insertField( el->name, el );
 }
 
-int ParseData::argvOffset()
+int Compiler::argvOffset()
 {
 	for ( ObjFieldList::Iter field = *globalObjectDef->objFieldList;
 			field.lte(); field++ )
@@ -3176,7 +3176,7 @@ int ParseData::argvOffset()
 	assert(false);
 }
 
-void ParseData::initGlobalFunctions()
+void Compiler::initGlobalFunctions()
 {
 	ObjMethod *method;
 
@@ -3204,7 +3204,7 @@ void ParseData::initGlobalFunctions()
 	addArgv();
 }
 
-void ParseData::removeNonUnparsableRepls()
+void Compiler::removeNonUnparsableRepls()
 {
 	for ( ReplList::Iter repl = replList; repl.lte(); ) {
 		Replacement *maybeDel = repl++;
@@ -3213,7 +3213,7 @@ void ParseData::removeNonUnparsableRepls()
 	}
 }
 
-void ParseData::compileByteCode()
+void Compiler::compileByteCode()
 {
 //	initUniqueTypes();
 	initIntObject();
diff --git a/colm/declare.cc b/colm/declare.cc
index c9a628d4..167fe050 100644
--- a/colm/declare.cc
+++ b/colm/declare.cc
@@ -25,7 +25,7 @@
 #include <iostream>
 #include <assert.h>
 
-LangEl *declareLangEl( ParseData *pd, Namespace *nspace, const String &data, LangEl::Type type )
+LangEl *declareLangEl( Compiler *pd, Namespace *nspace, const String &data, LangEl::Type type )
 {
     /* If the id is already in the dict, it will be placed in last found. If
      * it is not there then it will be inserted and last found will be set to it. */
@@ -43,14 +43,14 @@ LangEl *declareLangEl( ParseData *pd, Namespace *nspace, const String &data, Lan
 }
 
 /* Does not map the new language element. */
-LangEl *addLangEl( ParseData *pd, Namespace *nspace, const String &data, LangEl::Type type )
+LangEl *addLangEl( Compiler *pd, Namespace *nspace, const String &data, LangEl::Type type )
 {
 	LangEl *langEl = new LangEl( nspace, data, type );
 	pd->langEls.append( langEl );
 	return langEl;
 }
 
-void declareTypeAlias( ParseData *pd, Namespace *nspace, const String &data, TypeRef *typeRef )
+void declareTypeAlias( Compiler *pd, Namespace *nspace, const String &data, TypeRef *typeRef )
 {
     /* If the id is already in the dict, it will be placed in last found. If
      * it is not there then it will be inserted and last found will be set to it. */
@@ -63,7 +63,7 @@ void declareTypeAlias( ParseData *pd, Namespace *nspace, const String &data, Typ
 	nspace->typeMap.insert( typeMapEl );
 }
 
-LangEl *findType( ParseData *pd, Namespace *nspace, const String &data )
+LangEl *findType( Compiler *pd, Namespace *nspace, const String &data )
 {
 	/* If the id is already in the dict, it will be placed in last found. If
 	 * it is not there then it will be inserted and last found will be set to it. */
@@ -76,7 +76,7 @@ LangEl *findType( ParseData *pd, Namespace *nspace, const String &data )
 }
 
 
-void ParseData::declareBaseLangEls()
+void Compiler::declareBaseLangEls()
 {
 	/* Order here is important because we make assumptions about the inbuild
 	 * language elements in the runtime. Note tokens are have identifiers set
@@ -107,7 +107,7 @@ void ParseData::declareBaseLangEls()
 }
 
 
-void ParseData::addProdRedObjectVar( ObjectDef *localFrame, LangEl *nonTerm )
+void Compiler::addProdRedObjectVar( ObjectDef *localFrame, LangEl *nonTerm )
 {
 	UniqueType *prodNameUT = findUniqueType( TYPE_TREE, nonTerm );
 	TypeRef *typeRef = new TypeRef( InputLoc(), prodNameUT );
@@ -120,7 +120,7 @@ void ParseData::addProdRedObjectVar( ObjectDef *localFrame, LangEl *nonTerm )
 	localFrame->insertField( el->name, el );
 }
 
-void ParseData::addProdLHSLoad( Definition *prod, CodeVect &code, long &insertPos )
+void Compiler::addProdLHSLoad( Definition *prod, CodeVect &code, long &insertPos )
 {
 	ObjField *lhsField = prod->redBlock->localFrame->findField("lhs");
 	assert( lhsField != 0 );
@@ -135,7 +135,7 @@ void ParseData::addProdLHSLoad( Definition *prod, CodeVect &code, long &insertPo
 	insertPos += loads.length();
 }
 
-void ParseData::addPushBackLHS( Definition *prod, CodeVect &code, long &insertPos )
+void Compiler::addPushBackLHS( Definition *prod, CodeVect &code, long &insertPos )
 {
 	CodeBlock *block = prod->redBlock;
 
@@ -152,7 +152,7 @@ void ParseData::addPushBackLHS( Definition *prod, CodeVect &code, long &insertPo
 	}
 }
 
-void ParseData::addProdRHSVars( ObjectDef *localFrame, ProdElList *prodElList )
+void Compiler::addProdRHSVars( ObjectDef *localFrame, ProdElList *prodElList )
 {
 	long position = 1;
 	for ( ProdElList::Iter rhsEl = *prodElList; rhsEl.lte(); rhsEl++, position++ ) {
@@ -175,7 +175,7 @@ void ParseData::addProdRHSVars( ObjectDef *localFrame, ProdElList *prodElList )
 	}
 }
 
-void ParseData::addProdRHSLoads( Definition *prod, CodeVect &code, long &insertPos )
+void Compiler::addProdRHSLoads( Definition *prod, CodeVect &code, long &insertPos )
 {
 	CodeVect loads;
 	long elPos = 0;
@@ -194,7 +194,7 @@ void ParseData::addProdRHSLoads( Definition *prod, CodeVect &code, long &insertP
 	insertPos += loads.length();
 }
 
-void GenericType::declare( ParseData *pd, Namespace *nspace )
+void GenericType::declare( Compiler *pd, Namespace *nspace )
 {
 	//std::cout << "generic " << g->name << std::endl;
 
@@ -222,7 +222,7 @@ void GenericType::declare( ParseData *pd, Namespace *nspace )
 	this->langEl = langEl;
 }
 
-void Namespace::declare( ParseData *pd )
+void Namespace::declare( Compiler *pd )
 {
 	for ( GenericList::Iter g = genericList; g.lte(); g++ )
 		g->declare( pd, this );
@@ -347,7 +347,7 @@ void Namespace::declare( ParseData *pd )
 		(*c)->declare( pd );
 }
 
-void ParseData::setPrecedence()
+void Compiler::setPrecedence()
 {
 	for ( PredDeclList::Iter predDecl = predDeclList; predDecl != 0; predDecl++ ) {
 		predDecl->typeRef->lookupType( this );
@@ -361,7 +361,7 @@ void ParseData::setPrecedence()
 /*
  * Type Declaration Root.
  */
-void ParseData::typeDeclaration()
+void Compiler::typeDeclaration()
 {
 	/* These must be declared first, since the runtime assumes their identifiers. */
 	declareBaseLangEls();
diff --git a/colm/dotgen.cc b/colm/dotgen.cc
index 9bb4dee5..e4474958 100644
--- a/colm/dotgen.cc
+++ b/colm/dotgen.cc
@@ -26,7 +26,7 @@
 using namespace std;
 
 
-void ParseData::writeTransList( PdaState *state )
+void Compiler::writeTransList( PdaState *state )
 {
 	for ( TransMap::Iter trans = state->transMap; trans.lte(); trans++ ) {
 		/* Write out the from and to states. */
@@ -67,7 +67,7 @@ void ParseData::writeTransList( PdaState *state )
 	}
 }
 
-void ParseData::writeDotFile( PdaGraph *graph )
+void Compiler::writeDotFile( PdaGraph *graph )
 {
 	out << 
 		"digraph " << parserName << " {\n"
@@ -106,7 +106,7 @@ void ParseData::writeDotFile( PdaGraph *graph )
 		"}\n";
 }
 
-void ParseData::writeDotFile()
+void Compiler::writeDotFile()
 {
 	writeDotFile( pdaGraph );
 }
diff --git a/colm/lmparse.kh b/colm/lmparse.kh
index ff77d0a6..5523a656 100644
--- a/colm/lmparse.kh
+++ b/colm/lmparse.kh
@@ -30,7 +30,7 @@
 
 struct ColmParser
 {
-	ColmParser( ParseData *pd, const char *fileName, const char *sectionName, const InputLoc &sectionLoc )
+	ColmParser( Compiler *pd, const char *fileName, const char *sectionName, const InputLoc &sectionLoc )
 		: pd(pd), sectionName(sectionName), enterRl(false)
 	{}
 
@@ -87,7 +87,7 @@ struct ColmParser
 	/* Report an error encountered by the parser. */
 	ostream &parse_error( int tokId, Token &token );
 
-	ParseData *pd;
+	Compiler *pd;
 
 	/* The name of the root section, this does not change during an include. */
 	const char *sectionName;
diff --git a/colm/main.cc b/colm/main.cc
index 058f2324..8d89e6a3 100644
--- a/colm/main.cc
+++ b/colm/main.cc
@@ -567,7 +567,7 @@ int main(int argc, const char **argv)
 	if ( gblErrorCount > 0 )
 		exit(1);
 
-	ParseData *pd = new ParseData( inputFileName, "machine", InputLoc(), std::cout );
+	Compiler *pd = new Compiler( inputFileName, "machine", InputLoc(), std::cout );
 	ColmParser *parser = new ColmParser( pd, inputFileName, "machine", InputLoc() );
 	ColmScanner *scanner = new ColmScanner( inputFileName, *inStream, cout, parser, 0 );
 
diff --git a/colm/parsedata.cc b/colm/parsedata.cc
index f1017cae..42d7aac6 100644
--- a/colm/parsedata.cc
+++ b/colm/parsedata.cc
@@ -77,7 +77,7 @@ int countTransitions( FsmGraph *fsm )
 	return numTrans;
 }
 
-Key makeFsmKeyHex( char *str, const InputLoc &loc, ParseData *pd )
+Key makeFsmKeyHex( char *str, const InputLoc &loc, Compiler *pd )
 {
 	/* Reset errno so we can check for overflow or underflow. In the event of
 	 * an error, sets the return val to the upper or lower bound being tested
@@ -99,7 +99,7 @@ Key makeFsmKeyHex( char *str, const InputLoc &loc, ParseData *pd )
 	return Key( (long)ul );
 }
 
-Key makeFsmKeyDec( char *str, const InputLoc &loc, ParseData *pd )
+Key makeFsmKeyDec( char *str, const InputLoc &loc, Compiler *pd )
 {
 	/* Convert the number to a decimal. First reset errno so we can check
 	 * for overflow or underflow. */
@@ -129,7 +129,7 @@ Key makeFsmKeyDec( char *str, const InputLoc &loc, ParseData *pd )
 /* Make an fsm key in int format (what the fsm graph uses) from an alphabet
  * number returned by the parser. Validates that the number doesn't overflow
  * the alphabet type. */
-Key makeFsmKeyNum( char *str, const InputLoc &loc, ParseData *pd )
+Key makeFsmKeyNum( char *str, const InputLoc &loc, Compiler *pd )
 {
 	/* Switch on hex/decimal format. */
 	if ( str[0] == '0' && str[1] == 'x' )
@@ -141,7 +141,7 @@ Key makeFsmKeyNum( char *str, const InputLoc &loc, ParseData *pd )
 /* Make an fsm int format (what the fsm graph uses) from a single character.
  * Performs proper conversion depending on signed/unsigned property of the
  * alphabet. */
-Key makeFsmKeyChar( char c, ParseData *pd )
+Key makeFsmKeyChar( char c, Compiler *pd )
 {
 	if ( keyOps->isSigned ) {
 		/* Copy from a char type. */
@@ -156,7 +156,7 @@ Key makeFsmKeyChar( char c, ParseData *pd )
 /* Make an fsm key array in int format (what the fsm graph uses) from a string
  * of characters. Performs proper conversion depending on signed/unsigned
  * property of the alphabet. */
-void makeFsmKeyArray( Key *result, char *data, int len, ParseData *pd )
+void makeFsmKeyArray( Key *result, char *data, int len, Compiler *pd )
 {
 	if ( keyOps->isSigned ) {
 		/* Copy from a char star type. */
@@ -175,7 +175,7 @@ void makeFsmKeyArray( Key *result, char *data, int len, ParseData *pd )
 /* Like makeFsmKeyArray except the result has only unique keys. They ordering
  * will be changed. */
 void makeFsmUniqueKeyArray( KeySet &result, char *data, int len, 
-		bool caseInsensitive, ParseData *pd )
+		bool caseInsensitive, Compiler *pd )
 {
 	/* Use a transitions list for getting unique keys. */
 	if ( keyOps->isSigned ) {
@@ -208,14 +208,14 @@ void makeFsmUniqueKeyArray( KeySet &result, char *data, int len,
 	}
 }
 
-FsmGraph *dotFsm( ParseData *pd )
+FsmGraph *dotFsm( Compiler *pd )
 {
 	FsmGraph *retFsm = new FsmGraph();
 	retFsm->rangeFsm( keyOps->minKey, keyOps->maxKey );
 	return retFsm;
 }
 
-FsmGraph *dotStarFsm( ParseData *pd )
+FsmGraph *dotStarFsm( Compiler *pd )
 {
 	FsmGraph *retFsm = new FsmGraph();
 	retFsm->rangeStarFsm( keyOps->minKey, keyOps->maxKey );
@@ -223,7 +223,7 @@ FsmGraph *dotStarFsm( ParseData *pd )
 }
 
 /* Make a builtin type. Depends on the signed nature of the alphabet type. */
-FsmGraph *makeBuiltin( BuiltinMachine builtin, ParseData *pd )
+FsmGraph *makeBuiltin( BuiltinMachine builtin, Compiler *pd )
 {
 	/* FsmGraph created to return. */
 	FsmGraph *retFsm = 0;
@@ -391,12 +391,12 @@ bool NameInst::anyRefsRec()
 }
 
 /*
- * ParseData
+ * Compiler
  */
 
 /* Initialize the structure that will collect info during the parse of a
  * machine. */
-ParseData::ParseData( const String &fileName, const String &sectionName, 
+Compiler::Compiler( const String &fileName, const String &sectionName, 
 			const InputLoc &sectionLoc, ostream &out )
 :	
 	nextPriorKey(0),
@@ -447,7 +447,7 @@ ParseData::ParseData( const String &fileName, const String &sectionName,
 }
 
 /* Clean up the data collected during a parse. */
-ParseData::~ParseData()
+Compiler::~Compiler()
 {
 	/* Delete all the nodes in the action list. Will cause all the
 	 * string data that represents the actions to be deallocated. */
@@ -456,7 +456,7 @@ ParseData::~ParseData()
 
 /* Make a name id in the current name instantiation scope if it is not
  * already there. */
-NameInst *ParseData::addNameInst( const InputLoc &loc, char *data, bool isLabel )
+NameInst *Compiler::addNameInst( const InputLoc &loc, char *data, bool isLabel )
 {
 	/* Create the name instantitaion object and insert it. */
 	NameInst *newNameInst = new NameInst( loc, curNameInst, data, nextNameId++, isLabel );
@@ -466,7 +466,7 @@ NameInst *ParseData::addNameInst( const InputLoc &loc, char *data, bool isLabel
 	return newNameInst;
 }
 
-void ParseData::initNameWalk( NameInst *rootName )
+void Compiler::initNameWalk( NameInst *rootName )
 {
 	curNameInst = rootName;
 	curNameChild = 0;
@@ -477,7 +477,7 @@ void ParseData::initNameWalk( NameInst *rootName )
  * properly. It is reset on entry into a scope and advanced on poping of a
  * scope. A call to enterNameScope should be accompanied by a corresponding
  * popNameScope. */
-NameFrame ParseData::enterNameScope( bool isLocal, int numScopes )
+NameFrame Compiler::enterNameScope( bool isLocal, int numScopes )
 {
 	/* Save off the current data. */
 	NameFrame retFrame;
@@ -500,7 +500,7 @@ NameFrame ParseData::enterNameScope( bool isLocal, int numScopes )
 /* Return from a child scope to a parent. The parent info must be specified as
  * an argument and is obtained from the corresponding call to enterNameScope.
  * */
-void ParseData::popNameScope( const NameFrame &frame )
+void Compiler::popNameScope( const NameFrame &frame )
 {
 	/* Pop the name scope. */
 	curNameInst = frame.prevNameInst;
@@ -508,7 +508,7 @@ void ParseData::popNameScope( const NameFrame &frame )
 	localNameScope = frame.prevLocalScope;
 }
 
-void ParseData::resetNameScope( const NameFrame &frame )
+void Compiler::resetNameScope( const NameFrame &frame )
 {
 	/* Pop the name scope. */
 	curNameInst = frame.prevNameInst;
@@ -517,7 +517,7 @@ void ParseData::resetNameScope( const NameFrame &frame )
 }
 
 
-void ParseData::unsetObsoleteEntries( FsmGraph *graph )
+void Compiler::unsetObsoleteEntries( FsmGraph *graph )
 {
 	/* Loop the reference names and increment the usage. Names that are no
 	 * longer needed will be unset in graph. */
@@ -534,7 +534,7 @@ void ParseData::unsetObsoleteEntries( FsmGraph *graph )
 	}
 }
 
-NameSet ParseData::resolvePart( NameInst *refFrom, const char *data, bool recLabelsOnly )
+NameSet Compiler::resolvePart( NameInst *refFrom, const char *data, bool recLabelsOnly )
 {
 	/* Queue needed for breadth-first search, load it with the start node. */
 	NameInstList nameQueue;
@@ -565,7 +565,7 @@ NameSet ParseData::resolvePart( NameInst *refFrom, const char *data, bool recLab
 	return result;
 }
 
-void ParseData::resolveFrom( NameSet &result, NameInst *refFrom, 
+void Compiler::resolveFrom( NameSet &result, NameInst *refFrom, 
 		const NameRef &nameRef, int namePos )
 {
 	/* Look for the name in the owning scope of the factor with aug. */
@@ -658,7 +658,7 @@ void errorStateLabels( const NameSet &resolved )
 }
 
 
-void ParseData::referenceRegions( NameInst *rootName )
+void Compiler::referenceRegions( NameInst *rootName )
 {
 	for ( NameVect::Iter inst = rootName->childVect; inst.lte(); inst++ ) {
 		/* Inc the reference in the name. This will cause the entry point to
@@ -668,7 +668,7 @@ void ParseData::referenceRegions( NameInst *rootName )
 }
 
 /* Walk a name tree starting at from and fill the name index. */
-void ParseData::fillNameIndex( NameInst **nameIndex, NameInst *from )
+void Compiler::fillNameIndex( NameInst **nameIndex, NameInst *from )
 {
 	/* Fill the value for from in the name index. */
 	nameIndex[from->id] = from;
@@ -680,7 +680,7 @@ void ParseData::fillNameIndex( NameInst **nameIndex, NameInst *from )
 		fillNameIndex( nameIndex, *name );
 }
 
-NameInst **ParseData::makeNameIndex( NameInst *rootName )
+NameInst **Compiler::makeNameIndex( NameInst *rootName )
 {
 	/* The number of nodes in the tree can now be given by nextNameId. Put a
 	 * null pointer on the end of the list to terminate it. */
@@ -690,7 +690,7 @@ NameInst **ParseData::makeNameIndex( NameInst *rootName )
 	return nameIndex;
 }
 
-void ParseData::createBuiltin( const char *name, BuiltinMachine builtin )
+void Compiler::createBuiltin( const char *name, BuiltinMachine builtin )
 {
 	Expression *expression = new Expression( builtin );
 	Join *join = new Join( expression );
@@ -701,7 +701,7 @@ void ParseData::createBuiltin( const char *name, BuiltinMachine builtin )
 }
 
 /* Initialize the graph dict with builtin types. */
-void ParseData::initGraphDict( )
+void Compiler::initGraphDict( )
 {
 	createBuiltin( "any", BT_Any );
 	createBuiltin( "ascii", BT_Ascii );
@@ -724,7 +724,7 @@ void ParseData::initGraphDict( )
 
 /* Initialize the key operators object that will be referenced by all fsms
  * created. */
-void ParseData::initKeyOps( )
+void Compiler::initKeyOps( )
 {
 	/* Signedness and bounds. */
 	HostType *alphType = alphTypeSet ? userAlphType : hostLang->defaultAlphType;
@@ -740,7 +740,7 @@ void ParseData::initKeyOps( )
 	thisCondData.nextCondKey.increment();
 }
 
-void ParseData::printNameInst( NameInst *nameInst, int level )
+void Compiler::printNameInst( NameInst *nameInst, int level )
 {
 	for ( int i = 0; i < level; i++ )
 		cerr << "  ";
@@ -752,7 +752,7 @@ void ParseData::printNameInst( NameInst *nameInst, int level )
 }
 
 /* Remove duplicates of unique actions from an action table. */
-void ParseData::removeDups( ActionTable &table )
+void Compiler::removeDups( ActionTable &table )
 {
 	/* Scan through the table looking for unique actions to 
 	 * remove duplicates of. */
@@ -770,7 +770,7 @@ void ParseData::removeDups( ActionTable &table )
 /* Remove duplicates from action lists. This operates only on transition and
  * eof action lists and so should be called once all actions have been
  * transfered to their final resting place. */
-void ParseData::removeActionDups( FsmGraph *graph )
+void Compiler::removeActionDups( FsmGraph *graph )
 {
 	/* Loop all states. */
 	for ( StateList::Iter state = graph->stateList; state.lte(); state++ ) {
@@ -783,7 +783,7 @@ void ParseData::removeActionDups( FsmGraph *graph )
 	}
 }
 
-Action *ParseData::newAction( const String &name, InlineList *inlineList )
+Action *Compiler::newAction( const String &name, InlineList *inlineList )
 {
 	InputLoc loc;
 	loc.line = 1;
@@ -795,7 +795,7 @@ Action *ParseData::newAction( const String &name, InlineList *inlineList )
 	return action;
 }
 
-void ParseData::initLongestMatchData()
+void Compiler::initLongestMatchData()
 {
 	if ( regionList.length() > 0 ) {
 		/* The initActId action gives act a default value. */
@@ -824,7 +824,7 @@ void ParseData::initLongestMatchData()
 	}
 }
 
-void ParseData::finishGraphBuild( FsmGraph *graph )
+void Compiler::finishGraphBuild( FsmGraph *graph )
 {
 	/* Resolve any labels that point to multiple states. Any labels that are
 	 * still around are referenced only by gotos and calls and they need to be
@@ -860,7 +860,7 @@ void ParseData::finishGraphBuild( FsmGraph *graph )
 	graph->compressTransitions();
 }
 
-void ParseData::printNameTree( NameInst *rootName )
+void Compiler::printNameTree( NameInst *rootName )
 {
 	/* Print the name instance map. */
 	cerr << "name tree:" << endl;
@@ -868,7 +868,7 @@ void ParseData::printNameTree( NameInst *rootName )
 		printNameInst( *name, 0 );
 }
 
-void ParseData::printNameIndex( NameInst **nameIndex )
+void Compiler::printNameIndex( NameInst **nameIndex )
 {
 	/* The name index is terminated with a null pointer. */
 	cerr << "name index:" << endl;
@@ -880,7 +880,7 @@ void ParseData::printNameIndex( NameInst **nameIndex )
 }
 
 /* Build the name tree and supporting data structures. */
-NameInst *ParseData::makeJoinNameTree( Join *join )
+NameInst *Compiler::makeJoinNameTree( Join *join )
 {
 	/* Create the root name. */
 	nextNameId = 0;
@@ -895,7 +895,7 @@ NameInst *ParseData::makeJoinNameTree( Join *join )
 
 
 /* Build the name tree and supporting data structures. */
-NameInst *ParseData::makeNameTree()
+NameInst *Compiler::makeNameTree()
 {
 	/* Create the root name. */
 	nextNameId = 0;
@@ -912,7 +912,7 @@ NameInst *ParseData::makeNameTree()
 }
 
 
-FsmGraph *ParseData::makeJoin( Join *join )
+FsmGraph *Compiler::makeJoin( Join *join )
 {
 	/* Build the name tree and supporting data structures. */
 	NameInst *rootName = makeJoinNameTree( join );
@@ -937,7 +937,7 @@ FsmGraph *ParseData::makeJoin( Join *join )
 	return newGraph;
 }
 
-FsmGraph *ParseData::makeAllRegions()
+FsmGraph *Compiler::makeAllRegions()
 {
 	/* Build the name tree and supporting data structures. */
 	NameInst *rootName = makeNameTree( );
@@ -988,7 +988,7 @@ FsmGraph *ParseData::makeAllRegions()
 	return all;
 }
 
-void ParseData::analyzeAction( Action *action, InlineList *inlineList )
+void Compiler::analyzeAction( Action *action, InlineList *inlineList )
 {
 	/* FIXME: Actions used as conditions should be very constrained. */
 	for ( InlineList::Iter item = *inlineList; item.lte(); item++ ) {
@@ -1018,7 +1018,7 @@ void ParseData::analyzeAction( Action *action, InlineList *inlineList )
 	}
 }
 
-void ParseData::analyzeGraph( FsmGraph *graph )
+void Compiler::analyzeGraph( FsmGraph *graph )
 {
 	for ( ActionList::Iter act = actionList; act.lte(); act++ )
 		analyzeAction( act, act->inlineList );
@@ -1046,7 +1046,7 @@ void ParseData::analyzeGraph( FsmGraph *graph )
 	}
 }
 
-FsmGraph *ParseData::makeFsmGraph( Join *join )
+FsmGraph *Compiler::makeFsmGraph( Join *join )
 {
 	/* Make the graph, do minimization. */
 	FsmGraph *fsmGraph = join != 0 ? makeJoin( join ) : makeAllRegions();
@@ -1078,7 +1078,7 @@ FsmGraph *ParseData::makeFsmGraph( Join *join )
 	return fsmGraph;
 }
 
-void ParseData::createDefaultScanner()
+void Compiler::createDefaultScanner()
 {
 	InputLoc loc = { 0, 0, 0 };
 
@@ -1119,7 +1119,7 @@ void ParseData::createDefaultScanner()
 	defaultCharLangEl->tokenDef = tokenDef;
 }
 
-LangEl *ParseData::makeRepeatProd( Namespace *nspace, const String &repeatName, 
+LangEl *Compiler::makeRepeatProd( Namespace *nspace, const String &repeatName, 
 		NamespaceQual *nspaceQual, const String &name )
 {
 	LangEl *prodName = addLangEl( this, nspace, repeatName, LangEl::NonTerm );
@@ -1160,7 +1160,7 @@ LangEl *ParseData::makeRepeatProd( Namespace *nspace, const String &repeatName,
 	return prodName;
 }
 
-LangEl *ParseData::makeListProd( Namespace *nspace, const String &listName, NamespaceQual *nspaceQual, const String &name )
+LangEl *Compiler::makeListProd( Namespace *nspace, const String &listName, NamespaceQual *nspaceQual, const String &name )
 {
 	LangEl *prodName = addLangEl( this, nspace, listName, LangEl::NonTerm );
 	prodName->isList = true;
@@ -1203,7 +1203,7 @@ LangEl *ParseData::makeListProd( Namespace *nspace, const String &listName, Name
 	return prodName;
 }
 
-LangEl *ParseData::makeOptProd( Namespace *nspace, const String &optName, NamespaceQual *nspaceQual, const String &name )
+LangEl *Compiler::makeOptProd( Namespace *nspace, const String &optName, NamespaceQual *nspaceQual, const String &name )
 {
 	LangEl *prodName = addLangEl( this, nspace, optName, LangEl::NonTerm );
 	prodName->isOpt = true;
@@ -1262,7 +1262,7 @@ Namespace *NamespaceQual::searchFrom( Namespace *from, StringVect::Iter &qualPar
 	return from;
 }
 
-Namespace *NamespaceQual::getQual( ParseData *pd )
+Namespace *NamespaceQual::getQual( Compiler *pd )
 {
 	/* Do the search only once. */
 	if ( cachedNspaceQual != 0 )
@@ -1307,7 +1307,7 @@ Namespace *NamespaceQual::getQual( ParseData *pd )
 	return cachedNspaceQual;
 }
 
-void ParseData::initEmptyScanners()
+void Compiler::initEmptyScanners()
 {
 	for ( RegionList::Iter reg = regionList; reg.lte(); reg++ ) {
 		if ( reg->tokenDefList.length() == 0 ) {
@@ -1334,7 +1334,7 @@ void ParseData::initEmptyScanners()
 }
 
 
-void ParseData::parsePatterns()
+void Compiler::parsePatterns()
 {
 	Program *prg = colmNewProgram( runtimeData, 0, 0 );
 
@@ -1401,7 +1401,7 @@ void ParseData::parsePatterns()
 	fillInPatterns( prg );
 }
 
-void ParseData::collectParserEls( BstSet<LangEl*> &parserEls )
+void Compiler::collectParserEls( BstSet<LangEl*> &parserEls )
 {
 	for ( PatternList::Iter pat = patternList; pat.lte(); pat++ ) {
 		/* We assume the reduction action compilation phase was run before
@@ -1437,7 +1437,7 @@ void ParseData::collectParserEls( BstSet<LangEl*> &parserEls )
 }
 
 
-void ParseData::generateOutput()
+void Compiler::generateOutput()
 {
 	FsmCodeGen *fsmGen = new FsmCodeGen("<INPUT>", sectionName,
 			*outStream, redFsm, fsmTables );
diff --git a/colm/parsedata.h b/colm/parsedata.h
index 8d79e662..00caf5e8 100644
--- a/colm/parsedata.h
+++ b/colm/parsedata.h
@@ -53,7 +53,7 @@ void operator<<( std::ostream &out, exit_object & );
 /* Forwards. */
 struct RedFsm;
 struct LangEl;
-struct ParseData;
+struct Compiler;
 struct PdaCodeGen;
 struct FsmCodeGen;
 
@@ -324,7 +324,7 @@ struct ProdEl
 
 struct ProdElList : public DList<ProdEl>
 {
-	PdaGraph *walk( ParseData *pd, Definition *prod );
+	PdaGraph *walk( Compiler *pd, Definition *prod );
 };
 
 /* This should be renamed. It is a literal string in a type reference. */
@@ -516,13 +516,13 @@ struct NameFrame
 
 /* Class to collect information about the machine during the 
  * parse of input. */
-struct ParseData
+struct Compiler
 {
 	/* Create a new parse data object. This is done at the beginning of every
 	 * fsm specification. */
-	ParseData( const String &fileName, const String &sectionName, 
+	Compiler( const String &fileName, const String &sectionName, 
 			const InputLoc &sectionLoc, ostream &out );
-	~ParseData();
+	~Compiler();
 
 	/*
 	 * Setting up the graph dict.
@@ -1040,16 +1040,16 @@ struct ParseData
 };
 
 void afterOpMinimize( FsmGraph *fsm, bool lastInSeq = true );
-Key makeFsmKeyHex( char *str, const InputLoc &loc, ParseData *pd );
-Key makeFsmKeyDec( char *str, const InputLoc &loc, ParseData *pd );
-Key makeFsmKeyNum( char *str, const InputLoc &loc, ParseData *pd );
-Key makeFsmKeyChar( char c, ParseData *pd );
-void makeFsmKeyArray( Key *result, char *data, int len, ParseData *pd );
+Key makeFsmKeyHex( char *str, const InputLoc &loc, Compiler *pd );
+Key makeFsmKeyDec( char *str, const InputLoc &loc, Compiler *pd );
+Key makeFsmKeyNum( char *str, const InputLoc &loc, Compiler *pd );
+Key makeFsmKeyChar( char c, Compiler *pd );
+void makeFsmKeyArray( Key *result, char *data, int len, Compiler *pd );
 void makeFsmUniqueKeyArray( KeySet &result, char *data, int len, 
-		bool caseInsensitive, ParseData *pd );
-FsmGraph *makeBuiltin( BuiltinMachine builtin, ParseData *pd );
-FsmGraph *dotFsm( ParseData *pd );
-FsmGraph *dotStarFsm( ParseData *pd );
+		bool caseInsensitive, Compiler *pd );
+FsmGraph *makeBuiltin( BuiltinMachine builtin, Compiler *pd );
+FsmGraph *dotFsm( Compiler *pd );
+FsmGraph *dotStarFsm( Compiler *pd );
 
 void errorStateLabels( const NameSet &locations );
 
@@ -1058,9 +1058,9 @@ struct ColmParser;
 typedef AvlMap<String, ColmParser *, CmpStr> ParserDict;
 typedef AvlMapEl<String, ColmParser *> ParserDictEl;
 
-LangEl *declareLangEl( ParseData *pd, Namespace *nspace, const String &data, LangEl::Type type );
-LangEl *addLangEl( ParseData *pd, Namespace *nspace, const String &data, LangEl::Type type );
-void declareTypeAlias( ParseData *pd, Namespace *nspace, const String &data, TypeRef *typeRef );
-LangEl *findType( ParseData *pd, Namespace *nspace, const String &data );
+LangEl *declareLangEl( Compiler *pd, Namespace *nspace, const String &data, LangEl::Type type );
+LangEl *addLangEl( Compiler *pd, Namespace *nspace, const String &data, LangEl::Type type );
+void declareTypeAlias( Compiler *pd, Namespace *nspace, const String &data, TypeRef *typeRef );
+LangEl *findType( Compiler *pd, Namespace *nspace, const String &data );
 
 #endif /* _PARSEDATA_H */
diff --git a/colm/parsetree.cc b/colm/parsetree.cc
index f613ff3b..a195f1b7 100644
--- a/colm/parsetree.cc
+++ b/colm/parsetree.cc
@@ -180,7 +180,7 @@ int CmpUniqueParser::compare( const UniqueParser &ut1, const UniqueParser &ut2 )
 	return 0;
 }
 
-FsmGraph *VarDef::walk( ParseData *pd )
+FsmGraph *VarDef::walk( Compiler *pd )
 {
 	/* We enter into a new name scope. */
 	NameFrame nameFrame = pd->enterNameScope( true, 1 );
@@ -214,7 +214,7 @@ FsmGraph *VarDef::walk( ParseData *pd )
 	return rtnVal;
 }
 
-void VarDef::makeNameTree( const InputLoc &loc, ParseData *pd )
+void VarDef::makeNameTree( const InputLoc &loc, Compiler *pd )
 {
 	/* The variable definition enters a new scope. */
 	NameInst *prevNameInst = pd->curNameInst;
@@ -230,7 +230,7 @@ void VarDef::makeNameTree( const InputLoc &loc, ParseData *pd )
 	pd->curNameInst = prevNameInst;
 }
 
-void VarDef::resolveNameRefs( ParseData *pd )
+void VarDef::resolveNameRefs( Compiler *pd )
 {
 	/* Entering into a new scope. */
 	NameFrame nameFrame = pd->enterNameScope( true, 1 );
@@ -257,7 +257,7 @@ InputLoc TokenDef::getLoc()
  *  4. start state of all longest match routines.
  */
 
-Action *TokenRegion::newAction( ParseData *pd, const InputLoc &loc, 
+Action *TokenRegion::newAction( Compiler *pd, const InputLoc &loc, 
 		const String &name, InlineList *inlineList )
 {
 	Action *action = new Action( loc, name, inlineList );
@@ -266,7 +266,7 @@ Action *TokenRegion::newAction( ParseData *pd, const InputLoc &loc,
 	return action;
 }
 
-void TokenRegion::makeActions( ParseData *pd )
+void TokenRegion::makeActions( Compiler *pd )
 {
 	/* Make actions that set the action id. */
 	for ( TokenDefListReg::Iter lmi = tokenDefList; lmi.lte(); lmi++ ) {
@@ -329,7 +329,7 @@ void TokenRegion::makeActions( ParseData *pd )
 	lmActSelect = newAction( pd, loc, "lagsel", il6 );
 }
 
-void TokenRegion::findName( ParseData *pd )
+void TokenRegion::findName( Compiler *pd )
 {
 	NameInst *nameInst = pd->curNameInst;
 	while ( nameInst->name == 0 ) {
@@ -341,7 +341,7 @@ void TokenRegion::findName( ParseData *pd )
 	name = nameInst->name;
 }
 
-void TokenRegion::makeNameTree( ParseData *pd )
+void TokenRegion::makeNameTree( Compiler *pd )
 {
 	/* Create an anonymous scope for the longest match. Will be used for
 	 * restarting machine after matching a token. */
@@ -372,7 +372,7 @@ void TokenRegion::makeNameTree( ParseData *pd )
 	pd->curNameInst = prevNameInst;
 }
 
-void TokenRegion::resolveNameRefs( ParseData *pd )
+void TokenRegion::resolveNameRefs( Compiler *pd )
 {
 	/* The longest match gets its own name scope. */
 	NameFrame nameFrame = pd->enterNameScope( true, 1 );
@@ -395,7 +395,7 @@ void TokenRegion::restart( FsmGraph *graph, FsmTrans *trans )
 	graph->attachTrans( fromState, graph->startState, trans );
 }
 
-void TokenRegion::runLongestMatch( ParseData *pd, FsmGraph *graph )
+void TokenRegion::runLongestMatch( Compiler *pd, FsmGraph *graph )
 {
 	graph->markReachableFromHereStopFinal( graph->startState );
 	for ( StateList::Iter ms = graph->stateList; ms.lte(); ms++ ) {
@@ -576,7 +576,7 @@ void TokenRegion::transferScannerLeavingActions( FsmGraph *graph )
 	}
 }
 
-FsmGraph *TokenRegion::walk( ParseData *pd )
+FsmGraph *TokenRegion::walk( Compiler *pd )
 {
 	/* The longest match has it's own name scope. */
 	NameFrame nameFrame = pd->enterNameScope( true, 1 );
@@ -634,7 +634,7 @@ FsmGraph *TokenRegion::walk( ParseData *pd )
 	return retFsm;
 }
 
-FsmGraph *JoinOrLm::walk( ParseData *pd )
+FsmGraph *JoinOrLm::walk( Compiler *pd )
 {
 	FsmGraph *rtnVal = 0;
 	switch ( type ) {
@@ -648,7 +648,7 @@ FsmGraph *JoinOrLm::walk( ParseData *pd )
 	return rtnVal;
 }
 
-void JoinOrLm::makeNameTree( ParseData *pd )
+void JoinOrLm::makeNameTree( Compiler *pd )
 {
 	switch ( type ) {
 	case JoinType:
@@ -660,7 +660,7 @@ void JoinOrLm::makeNameTree( ParseData *pd )
 	}
 }
 
-void JoinOrLm::resolveNameRefs( ParseData *pd )
+void JoinOrLm::resolveNameRefs( Compiler *pd )
 {
 	switch ( type ) {
 	case JoinType:
@@ -683,7 +683,7 @@ Join::Join( Expression *expr )
 }
 
 /* Walk an expression node. */
-FsmGraph *Join::walk( ParseData *pd )
+FsmGraph *Join::walk( Compiler *pd )
 {
 	assert( exprList.length() == 1 );
 
@@ -699,7 +699,7 @@ FsmGraph *Join::walk( ParseData *pd )
 	return retFsm;
 }
 
-void Join::makeNameTree( ParseData *pd )
+void Join::makeNameTree( Compiler *pd )
 {
 	assert( exprList.length() == 1 );
 
@@ -712,7 +712,7 @@ void Join::makeNameTree( ParseData *pd )
 }
 
 
-void Join::resolveNameRefs( ParseData *pd )
+void Join::resolveNameRefs( Compiler *pd )
 {
 	/* Branch on whether or not there is to be a join. */
 	assert( exprList.length() == 1 );
@@ -743,7 +743,7 @@ Expression::~Expression()
 }
 
 /* Evaluate a single expression node. */
-FsmGraph *Expression::walk( ParseData *pd, bool lastInSeq )
+FsmGraph *Expression::walk( Compiler *pd, bool lastInSeq )
 {
 	FsmGraph *rtnVal = 0;
 	switch ( type ) {
@@ -808,7 +808,7 @@ FsmGraph *Expression::walk( ParseData *pd, bool lastInSeq )
 	return rtnVal;
 }
 
-void Expression::makeNameTree( ParseData *pd )
+void Expression::makeNameTree( Compiler *pd )
 {
 	switch ( type ) {
 	case OrType:
@@ -826,7 +826,7 @@ void Expression::makeNameTree( ParseData *pd )
 	}
 }
 
-void Expression::resolveNameRefs( ParseData *pd )
+void Expression::resolveNameRefs( Compiler *pd )
 {
 	switch ( type ) {
 	case OrType:
@@ -862,7 +862,7 @@ Term::~Term()
 }
 
 /* Evaluate a term node. */
-FsmGraph *Term::walk( ParseData *pd, bool lastInSeq )
+FsmGraph *Term::walk( Compiler *pd, bool lastInSeq )
 {
 	FsmGraph *rtnVal = 0;
 	switch ( type ) {
@@ -960,7 +960,7 @@ FsmGraph *Term::walk( ParseData *pd, bool lastInSeq )
 	return rtnVal;
 }
 
-void Term::makeNameTree( ParseData *pd )
+void Term::makeNameTree( Compiler *pd )
 {
 	switch ( type ) {
 	case ConcatType:
@@ -976,7 +976,7 @@ void Term::makeNameTree( ParseData *pd )
 	}
 }
 
-void Term::resolveNameRefs( ParseData *pd )
+void Term::resolveNameRefs( Compiler *pd )
 {
 	switch ( type ) {
 	case ConcatType:
@@ -1004,7 +1004,7 @@ FactorWithAug::~FactorWithAug()
 		delete[] priorDescs;
 }
 
-void FactorWithAug::assignActions( ParseData *pd, FsmGraph *graph, int *actionOrd )
+void FactorWithAug::assignActions( Compiler *pd, FsmGraph *graph, int *actionOrd )
 {
 	/* Assign actions. */
 	for ( int i = 0; i < actions.length(); i++ )  {
@@ -1194,7 +1194,7 @@ void FactorWithAug::assignConditions( FsmGraph *graph )
 
 
 /* Evaluate a factor with augmentation node. */
-FsmGraph *FactorWithAug::walk( ParseData *pd )
+FsmGraph *FactorWithAug::walk( Compiler *pd )
 {
 	/* Enter into the scopes created for the labels. */
 	NameFrame nameFrame = pd->enterNameScope( false, labels.length() );
@@ -1300,7 +1300,7 @@ FsmGraph *FactorWithAug::walk( ParseData *pd )
 	return rtnVal;
 }
 
-void FactorWithAug::makeNameTree( ParseData *pd )
+void FactorWithAug::makeNameTree( Compiler *pd )
 {
 	/* Add the labels to the tree of instantiated names. Each label
 	 * makes a new scope. */
@@ -1314,7 +1314,7 @@ void FactorWithAug::makeNameTree( ParseData *pd )
 }
 
 
-void FactorWithAug::resolveNameRefs( ParseData *pd )
+void FactorWithAug::resolveNameRefs( Compiler *pd )
 {
 	/* Enter into the name scope created by any labels. */
 	NameFrame nameFrame = pd->enterNameScope( false, labels.length() );
@@ -1387,7 +1387,7 @@ FactorWithRep::~FactorWithRep()
 }
 
 /* Evaluate a factor with repetition node. */
-FsmGraph *FactorWithRep::walk( ParseData *pd )
+FsmGraph *FactorWithRep::walk( Compiler *pd )
 {
 	FsmGraph *retFsm = 0;
 
@@ -1628,7 +1628,7 @@ FsmGraph *FactorWithRep::walk( ParseData *pd )
 	return retFsm;
 }
 
-void FactorWithRep::makeNameTree( ParseData *pd )
+void FactorWithRep::makeNameTree( Compiler *pd )
 {
 	switch ( type ) {
 	case StarType:
@@ -1647,7 +1647,7 @@ void FactorWithRep::makeNameTree( ParseData *pd )
 	}
 }
 
-void FactorWithRep::resolveNameRefs( ParseData *pd )
+void FactorWithRep::resolveNameRefs( Compiler *pd )
 {
 	switch ( type ) {
 	case StarType:
@@ -1681,7 +1681,7 @@ FactorWithNeg::~FactorWithNeg()
 }
 
 /* Evaluate a factor with negation node. */
-FsmGraph *FactorWithNeg::walk( ParseData *pd )
+FsmGraph *FactorWithNeg::walk( Compiler *pd )
 {
 	FsmGraph *retFsm = 0;
 
@@ -1714,7 +1714,7 @@ FsmGraph *FactorWithNeg::walk( ParseData *pd )
 	return retFsm;
 }
 
-void FactorWithNeg::makeNameTree( ParseData *pd )
+void FactorWithNeg::makeNameTree( Compiler *pd )
 {
 	switch ( type ) {
 	case NegateType:
@@ -1727,7 +1727,7 @@ void FactorWithNeg::makeNameTree( ParseData *pd )
 	}
 }
 
-void FactorWithNeg::resolveNameRefs( ParseData *pd )
+void FactorWithNeg::resolveNameRefs( Compiler *pd )
 {
 	switch ( type ) {
 	case NegateType:
@@ -1765,7 +1765,7 @@ Factor::~Factor()
 }
 
 /* Evaluate a factor node. */
-FsmGraph *Factor::walk( ParseData *pd )
+FsmGraph *Factor::walk( Compiler *pd )
 {
 	FsmGraph *rtnVal = 0;
 	switch ( type ) {
@@ -1792,7 +1792,7 @@ FsmGraph *Factor::walk( ParseData *pd )
 	return rtnVal;
 }
 
-void Factor::makeNameTree( ParseData *pd )
+void Factor::makeNameTree( Compiler *pd )
 {
 	switch ( type ) {
 	case LiteralType:
@@ -1809,7 +1809,7 @@ void Factor::makeNameTree( ParseData *pd )
 	}
 }
 
-void Factor::resolveNameRefs( ParseData *pd )
+void Factor::resolveNameRefs( Compiler *pd )
 {
 	switch ( type ) {
 	case LiteralType:
@@ -1858,7 +1858,7 @@ bool Range::verifyRangeFsm( FsmGraph *rangeEnd )
 }
 
 /* Evaluate a range. Gets the lower an upper key and makes an fsm range. */
-FsmGraph *Range::walk( ParseData *pd )
+FsmGraph *Range::walk( Compiler *pd )
 {
 	/* Construct and verify the suitability of the lower end of the range. */
 	FsmGraph *lowerFsm = lowerLit->walk( pd );
@@ -1894,7 +1894,7 @@ FsmGraph *Range::walk( ParseData *pd )
 }
 
 /* Evaluate a literal object. */
-FsmGraph *Literal::walk( ParseData *pd )
+FsmGraph *Literal::walk( Compiler *pd )
 {
 	/* FsmGraph to return, is the alphabet signed. */
 	FsmGraph *rtnVal = 0;
@@ -1942,7 +1942,7 @@ RegExpr::~RegExpr()
 }
 
 /* Evaluate a regular expression object. */
-FsmGraph *RegExpr::walk( ParseData *pd, RegExpr *rootRegex )
+FsmGraph *RegExpr::walk( Compiler *pd, RegExpr *rootRegex )
 {
 	/* This is the root regex, pass down a pointer to this. */
 	if ( rootRegex == 0 )
@@ -1986,7 +1986,7 @@ ReItem::~ReItem()
 }
 
 /* Evaluate a regular expression object. */
-FsmGraph *ReItem::walk( ParseData *pd, RegExpr *rootRegex )
+FsmGraph *ReItem::walk( Compiler *pd, RegExpr *rootRegex )
 {
 	/* The fsm to return, is the alphabet signed? */
 	FsmGraph *rtnVal = 0;
@@ -2058,7 +2058,7 @@ ReOrBlock::~ReOrBlock()
 
 
 /* Evaluate an or block of a regular expression. */
-FsmGraph *ReOrBlock::walk( ParseData *pd, RegExpr *rootRegex )
+FsmGraph *ReOrBlock::walk( Compiler *pd, RegExpr *rootRegex )
 {
 	FsmGraph *rtnVal = 0;
 	switch ( type ) {
@@ -2083,7 +2083,7 @@ FsmGraph *ReOrBlock::walk( ParseData *pd, RegExpr *rootRegex )
 }
 
 /* Evaluate an or block item of a regular expression. */
-FsmGraph *ReOrItem::walk( ParseData *pd, RegExpr *rootRegex )
+FsmGraph *ReOrItem::walk( Compiler *pd, RegExpr *rootRegex )
 {
 	/* The return value, is the alphabet signed? */
 	FsmGraph *rtnVal = 0;
diff --git a/colm/parsetree.h b/colm/parsetree.h
index 29e8d93d..46b7d4b1 100644
--- a/colm/parsetree.h
+++ b/colm/parsetree.h
@@ -151,7 +151,7 @@ typedef BstSet<char> CharSet;
 typedef Vector<unsigned char> UnsignedCharVect;
 
 
-struct ParseData;
+struct Compiler;
 struct TypeRef;
 
 /* Leaf type. */
@@ -320,9 +320,9 @@ struct VarDef
 		: name(name), joinOrLm(joinOrLm) { }
 	
 	/* Parse tree traversal. */
-	FsmGraph *walk( ParseData *pd );
-	void makeNameTree( const InputLoc &loc, ParseData *pd );
-	void resolveNameRefs( ParseData *pd );
+	FsmGraph *walk( Compiler *pd );
+	void makeNameTree( const InputLoc &loc, Compiler *pd );
+	void resolveNameRefs( Compiler *pd );
 
 	String name;
 	JoinOrLm *joinOrLm;
@@ -342,7 +342,7 @@ struct NamespaceQual
 	StringVect qualNames;
 
 	Namespace *searchFrom( Namespace *from, StringVect::Iter &qualPart );
-	Namespace *getQual( ParseData *pd );
+	Namespace *getQual( Compiler *pd );
 };
 
 struct ReCapture
@@ -531,15 +531,15 @@ struct TokenRegion
 	{ }
 
 	/* Tree traversal. */
-	FsmGraph *walk( ParseData *pd );
-	void makeNameTree( ParseData *pd );
-	void resolveNameRefs( ParseData *pd );
-	void runLongestMatch( ParseData *pd, FsmGraph *graph );
+	FsmGraph *walk( Compiler *pd );
+	void makeNameTree( Compiler *pd );
+	void resolveNameRefs( Compiler *pd );
+	void runLongestMatch( Compiler *pd, FsmGraph *graph );
 	void transferScannerLeavingActions( FsmGraph *graph );
-	Action *newAction( ParseData *pd, const InputLoc &loc, const String &name, 
+	Action *newAction( Compiler *pd, const InputLoc &loc, const String &name, 
 			InlineList *inlineList );
-	void makeActions( ParseData *pd );
-	void findName( ParseData *pd );
+	void makeActions( Compiler *pd );
+	void findName( Compiler *pd );
 	void restart( FsmGraph *graph, FsmTrans *trans );
 
 	InputLoc loc;
@@ -601,7 +601,7 @@ struct GenericType
 	const String &getKey() const 
 		{ return name; };
 
-	void declare( ParseData *pd, Namespace *nspace );
+	void declare( Compiler *pd, Namespace *nspace );
 
 	String name;
 	long typeId;
@@ -708,7 +708,7 @@ struct Namespace
 
 	Namespace *next, *prev;
 
-	void declare( ParseData *pd );
+	void declare( Compiler *pd );
 };
 
 typedef DList<Namespace> NamespaceList;
@@ -729,9 +729,9 @@ struct JoinOrLm
 	JoinOrLm( TokenRegion *tokenRegion ) :
 		tokenRegion(tokenRegion), type(LongestMatchType) {}
 
-	FsmGraph *walk( ParseData *pd );
-	void makeNameTree( ParseData *pd );
-	void resolveNameRefs( ParseData *pd );
+	FsmGraph *walk( Compiler *pd );
+	void makeNameTree( Compiler *pd );
+	void resolveNameRefs( Compiler *pd );
 	
 	Join *join;
 	TokenRegion *tokenRegion;
@@ -747,9 +747,9 @@ struct Join
 	Join( Expression *expr );
 
 	/* Tree traversal. */
-	FsmGraph *walk( ParseData *pd );
-	void makeNameTree( ParseData *pd );
-	void resolveNameRefs( ParseData *pd );
+	FsmGraph *walk( Compiler *pd );
+	void makeNameTree( Compiler *pd );
+	void resolveNameRefs( Compiler *pd );
 
 	/* Data. */
 	ExprList exprList;
@@ -790,9 +790,9 @@ struct Expression
 	~Expression();
 
 	/* Tree traversal. */
-	FsmGraph *walk( ParseData *pd, bool lastInSeq = true );
-	void makeNameTree( ParseData *pd );
-	void resolveNameRefs( ParseData *pd );
+	FsmGraph *walk( Compiler *pd, bool lastInSeq = true );
+	void makeNameTree( Compiler *pd );
+	void resolveNameRefs( Compiler *pd );
 
 	/* Node data. */
 	Expression *expression;
@@ -827,9 +827,9 @@ struct Term
 	
 	~Term();
 
-	FsmGraph *walk( ParseData *pd, bool lastInSeq = true );
-	void makeNameTree( ParseData *pd );
-	void resolveNameRefs( ParseData *pd );
+	FsmGraph *walk( Compiler *pd, bool lastInSeq = true );
+	void makeNameTree( Compiler *pd );
+	void resolveNameRefs( Compiler *pd );
 
 	Term *term;
 	FactorWithAug *factorWithAug;
@@ -848,11 +848,11 @@ struct FactorWithAug
 	~FactorWithAug();
 
 	/* Tree traversal. */
-	FsmGraph *walk( ParseData *pd );
-	void makeNameTree( ParseData *pd );
-	void resolveNameRefs( ParseData *pd );
+	FsmGraph *walk( Compiler *pd );
+	void makeNameTree( Compiler *pd );
+	void resolveNameRefs( Compiler *pd );
 
-	void assignActions( ParseData *pd, FsmGraph *graph, int *actionOrd );
+	void assignActions( Compiler *pd, FsmGraph *graph, int *actionOrd );
 	void assignPriorities( FsmGraph *graph, int *priorOrd );
 
 	void assignConditions( FsmGraph *graph );
@@ -896,9 +896,9 @@ struct FactorWithRep
 	~FactorWithRep();
 
 	/* Tree traversal. */
-	FsmGraph *walk( ParseData *pd );
-	void makeNameTree( ParseData *pd );
-	void resolveNameRefs( ParseData *pd );
+	FsmGraph *walk( Compiler *pd );
+	void makeNameTree( Compiler *pd );
+	void resolveNameRefs( Compiler *pd );
 
 	InputLoc loc;
 	FactorWithRep *factorWithRep;
@@ -928,9 +928,9 @@ struct FactorWithNeg
 	~FactorWithNeg();
 
 	/* Tree traversal. */
-	FsmGraph *walk( ParseData *pd );
-	void makeNameTree( ParseData *pd );
-	void resolveNameRefs( ParseData *pd );
+	FsmGraph *walk( Compiler *pd );
+	void makeNameTree( Compiler *pd );
+	void resolveNameRefs( Compiler *pd );
 
 	InputLoc loc;
 	FactorWithNeg *factorWithNeg;
@@ -981,9 +981,9 @@ struct Factor
 	~Factor();
 
 	/* Tree traversal. */
-	FsmGraph *walk( ParseData *pd );
-	void makeNameTree( ParseData *pd );
-	void resolveNameRefs( ParseData *pd );
+	FsmGraph *walk( Compiler *pd );
+	void makeNameTree( Compiler *pd );
+	void resolveNameRefs( Compiler *pd );
 
 	InputLoc loc;
 	Literal *literal;
@@ -1003,7 +1003,7 @@ struct Range
 		: lowerLit(lowerLit), upperLit(upperLit) { }
 
 	~Range();
-	FsmGraph *walk( ParseData *pd );
+	FsmGraph *walk( Compiler *pd );
 	bool verifyRangeFsm( FsmGraph *rangeEnd );
 
 	Literal *lowerLit;
@@ -1018,7 +1018,7 @@ struct Literal
 	Literal( const InputLoc &loc, const String &literal, LiteralType type )
 		: loc(loc), literal(literal), type(type) { }
 
-	FsmGraph *walk( ParseData *pd );
+	FsmGraph *walk( Compiler *pd );
 	
 	InputLoc loc;
 	String literal;
@@ -1038,7 +1038,7 @@ struct RegExpr
 		type(RecurseItem), caseInsensitive(false) { }
 
 	~RegExpr();
-	FsmGraph *walk( ParseData *pd, RegExpr *rootRegex );
+	FsmGraph *walk( Compiler *pd, RegExpr *rootRegex );
 
 	RegExpr *regExp;
 	ReItem *item;
@@ -1059,7 +1059,7 @@ struct ReItem
 		: loc(loc), orBlock(orBlock), star(false), type(type) { }
 
 	~ReItem();
-	FsmGraph *walk( ParseData *pd, RegExpr *rootRegex );
+	FsmGraph *walk( Compiler *pd, RegExpr *rootRegex );
 
 	InputLoc loc;
 	String data;
@@ -1080,7 +1080,7 @@ struct ReOrBlock
 		: orBlock(orBlock), item(item), type(RecurseItem) { }
 
 	~ReOrBlock();
-	FsmGraph *walk( ParseData *pd, RegExpr *rootRegex );
+	FsmGraph *walk( Compiler *pd, RegExpr *rootRegex );
 	
 	ReOrBlock *orBlock;
 	ReOrItem *item;
@@ -1097,7 +1097,7 @@ struct ReOrItem
 	ReOrItem( const InputLoc &loc, char lower, char upper )
 		: loc(loc), lower(lower), upper(upper), type(Range) { }
 
-	FsmGraph *walk( ParseData *pd, RegExpr *rootRegex );
+	FsmGraph *walk( Compiler *pd, RegExpr *rootRegex );
 
 	InputLoc loc;
 	String data;
@@ -1590,17 +1590,17 @@ struct TypeRef
 		repeatType(RepeatNone),
 		nspace(0), uniqueType(uniqueType), searchUniqueType(0), generic(0) {}
 
-	void resolveRepeat( ParseData *pd );
+	void resolveRepeat( Compiler *pd );
 
-	UniqueType *lookupTypeName( ParseData *pd );
-	UniqueType *lookupTypeLiteral( ParseData *pd );
-	UniqueType *lookupTypeMap( ParseData *pd );
-	UniqueType *lookupTypeList( ParseData *pd );
-	UniqueType *lookupTypeVector( ParseData *pd );
-	UniqueType *lookupTypeParser( ParseData *pd );
-	UniqueType *lookupType( ParseData *pd );
-	UniqueType *lookupTypePtr( ParseData *pd );
-	UniqueType *lookupTypeRef( ParseData *pd );
+	UniqueType *lookupTypeName( Compiler *pd );
+	UniqueType *lookupTypeLiteral( Compiler *pd );
+	UniqueType *lookupTypeMap( Compiler *pd );
+	UniqueType *lookupTypeList( Compiler *pd );
+	UniqueType *lookupTypeVector( Compiler *pd );
+	UniqueType *lookupTypeParser( Compiler *pd );
+	UniqueType *lookupType( Compiler *pd );
+	UniqueType *lookupTypePtr( Compiler *pd );
+	UniqueType *lookupTypeRef( Compiler *pd );
 
 	Type type;
 	InputLoc loc;
@@ -1795,15 +1795,15 @@ struct ObjectDef
 	long nextOffset;
 	long firstNonTree;
 
-	void referenceField( ParseData *pd, ObjField *field );
-	void initField( ParseData *pd, ObjField *field );
-	void createCode( ParseData *pd, CodeVect &code );
+	void referenceField( Compiler *pd, ObjField *field );
+	void initField( Compiler *pd, ObjField *field );
+	void createCode( Compiler *pd, CodeVect &code );
 	ObjField *checkRedecl( const String &name );
 	ObjMethod *findMethod( const String &name );
 	ObjField *findFieldInScope( const String &name, ObjNameScope *inScope );
 	ObjField *findField( const String &name );
 	void insertField( const String &name, ObjField *value );
-	void resolve( ParseData *pd );
+	void resolve( Compiler *pd );
 	ObjField *findFieldNum( long offset );
 
 	long size() { return nextOffset; }
@@ -1867,52 +1867,52 @@ struct LangVarRef
 	LangVarRef( const InputLoc &loc, QualItemVect *qual, String name )
 		: loc(loc), qual(qual), name(name) {}
 
-	void resolve( ParseData *pd ) const;
+	void resolve( Compiler *pd ) const;
 
-	UniqueType *loadFieldInstr( ParseData *pd, CodeVect &code, ObjectDef *inObject,
+	UniqueType *loadFieldInstr( Compiler *pd, CodeVect &code, ObjectDef *inObject,
 			ObjField *el, bool forWriting, bool revert ) const;
-	void setFieldInstr( ParseData *pd, CodeVect &code, ObjectDef *inObject, 
+	void setFieldInstr( Compiler *pd, CodeVect &code, ObjectDef *inObject, 
 			ObjField *el, UniqueType *exprUT, bool revert ) const;
 
-	VarRefLookup lookupMethod( ParseData *pd ) ;
-	VarRefLookup lookupField( ParseData *pd ) const;
+	VarRefLookup lookupMethod( Compiler *pd ) ;
+	VarRefLookup lookupField( Compiler *pd ) const;
 
-	VarRefLookup lookupQualification( ParseData *pd, ObjectDef *rootDef ) const;
-	VarRefLookup lookupObj( ParseData *pd ) const;
+	VarRefLookup lookupQualification( Compiler *pd, ObjectDef *rootDef ) const;
+	VarRefLookup lookupObj( Compiler *pd ) const;
 
-	bool isCustom( ParseData *pd ) const;
-	bool isLocalRef( ParseData *pd ) const;
-	bool isContextRef( ParseData *pd ) const;
-	void loadQualification( ParseData *pd, CodeVect &code, ObjectDef *rootObj, 
+	bool isCustom( Compiler *pd ) const;
+	bool isLocalRef( Compiler *pd ) const;
+	bool isContextRef( Compiler *pd ) const;
+	void loadQualification( Compiler *pd, CodeVect &code, ObjectDef *rootObj, 
 			int lastPtrInQual, bool forWriting, bool revert ) const;
-	void loadCustom( ParseData *pd, CodeVect &code, 
+	void loadCustom( Compiler *pd, CodeVect &code, 
 			int lastPtrInQual, bool forWriting ) const;
-	void loadLocalObj( ParseData *pd, CodeVect &code, 
+	void loadLocalObj( Compiler *pd, CodeVect &code, 
 			int lastPtrInQual, bool forWriting ) const;
-	void loadContextObj( ParseData *pd, CodeVect &code, int lastPtrInQual, bool forWriting ) const;
-	void loadGlobalObj( ParseData *pd, CodeVect &code, 
+	void loadContextObj( Compiler *pd, CodeVect &code, int lastPtrInQual, bool forWriting ) const;
+	void loadGlobalObj( Compiler *pd, CodeVect &code, 
 			int lastPtrInQual, bool forWriting ) const;
-	void loadObj( ParseData *pd, CodeVect &code, int lastPtrInQual, bool forWriting ) const;
-	void canTakeRef( ParseData *pd, VarRefLookup &lookup ) const;
+	void loadObj( Compiler *pd, CodeVect &code, int lastPtrInQual, bool forWriting ) const;
+	void canTakeRef( Compiler *pd, VarRefLookup &lookup ) const;
 
-	void setFieldIter( ParseData *pd, CodeVect &code, 
+	void setFieldIter( Compiler *pd, CodeVect &code, 
 			ObjectDef *inObject, UniqueType *objUT, UniqueType *exprType, bool revert ) const;
-	void setFieldSearch( ParseData *pd, CodeVect &code, 
+	void setFieldSearch( Compiler *pd, CodeVect &code, 
 			ObjectDef *inObject, UniqueType *exprType ) const;
-	void setField( ParseData *pd, CodeVect &code, 
+	void setField( Compiler *pd, CodeVect &code, 
 			ObjectDef *inObject, UniqueType *type, bool revert ) const;
 
-	void assignValue( ParseData *pd, CodeVect &code, UniqueType *exprUT ) const;
-	ObjField **evaluateArgs( ParseData *pd, CodeVect &code, 
+	void assignValue( Compiler *pd, CodeVect &code, UniqueType *exprUT ) const;
+	ObjField **evaluateArgs( Compiler *pd, CodeVect &code, 
 			VarRefLookup &lookup, ExprVect *args ) const;
-	void callOperation( ParseData *pd, CodeVect &code, VarRefLookup &lookup ) const;
-	UniqueType *evaluateCall( ParseData *pd, CodeVect &code, ExprVect *args );
-	UniqueType *evaluate( ParseData *pd, CodeVect &code, bool forWriting = false ) const;
-	ObjField *evaluateRef( ParseData *pd, CodeVect &code, long pushCount ) const;
-	ObjField *preEvaluateRef( ParseData *pd, CodeVect &code ) const;
-	void resetActiveRefs( ParseData *pd, VarRefLookup &lookup, ObjField **paramRefs ) const;
-	long loadQualificationRefs( ParseData *pd, CodeVect &code ) const;
-	void popRefQuals( ParseData *pd, CodeVect &code, 
+	void callOperation( Compiler *pd, CodeVect &code, VarRefLookup &lookup ) const;
+	UniqueType *evaluateCall( Compiler *pd, CodeVect &code, ExprVect *args );
+	UniqueType *evaluate( Compiler *pd, CodeVect &code, bool forWriting = false ) const;
+	ObjField *evaluateRef( Compiler *pd, CodeVect &code, long pushCount ) const;
+	ObjField *preEvaluateRef( Compiler *pd, CodeVect &code ) const;
+	void resetActiveRefs( Compiler *pd, VarRefLookup &lookup, ObjField **paramRefs ) const;
+	long loadQualificationRefs( Compiler *pd, CodeVect &code ) const;
+	void popRefQuals( Compiler *pd, CodeVect &code, 
 			VarRefLookup &lookup, ExprVect *args ) const;
 
 	InputLoc loc;
@@ -1995,17 +1995,17 @@ struct LangTerm
 			typeRef(typeRef), generic(generic), parserTypeRef(parserTypeRef),
 			replacement(replacement) {}
 	
-	void resolve( ParseData *pd );
-
-	UniqueType *evaluateParse( ParseData *pd, CodeVect &code, bool stop ) const;
-	UniqueType *evaluateNew( ParseData *pd, CodeVect &code ) const;
-	UniqueType *evaluateConstruct( ParseData *pd, CodeVect &code ) const;
-	UniqueType *evaluateMatch( ParseData *pd, CodeVect &code ) const;
-	UniqueType *evaluate( ParseData *pd, CodeVect &code ) const;
-	void assignFieldArgs( ParseData *pd, CodeVect &code, UniqueType *replUT ) const;
-	UniqueType *evaluateMakeToken( ParseData *pd, CodeVect &code ) const;
-	UniqueType *evaluateMakeTree( ParseData *pd, CodeVect &code ) const;
-	UniqueType *evaluateEmbedString( ParseData *pd, CodeVect &code ) const;
+	void resolve( Compiler *pd );
+
+	UniqueType *evaluateParse( Compiler *pd, CodeVect &code, bool stop ) const;
+	UniqueType *evaluateNew( Compiler *pd, CodeVect &code ) const;
+	UniqueType *evaluateConstruct( Compiler *pd, CodeVect &code ) const;
+	UniqueType *evaluateMatch( Compiler *pd, CodeVect &code ) const;
+	UniqueType *evaluate( Compiler *pd, CodeVect &code ) const;
+	void assignFieldArgs( Compiler *pd, CodeVect &code, UniqueType *replUT ) const;
+	UniqueType *evaluateMakeToken( Compiler *pd, CodeVect &code ) const;
+	UniqueType *evaluateMakeTree( Compiler *pd, CodeVect &code ) const;
+	UniqueType *evaluateEmbedString( Compiler *pd, CodeVect &code ) const;
 
 	InputLoc loc;
 	Type type;
@@ -2041,9 +2041,9 @@ struct LangExpr
 	LangExpr( LangTerm *term )
 		: type(TermType), term(term) {}
 
-	void resolve( ParseData *pd ) const;
+	void resolve( Compiler *pd ) const;
 
-	UniqueType *evaluate( ParseData *pd, CodeVect &code ) const;
+	UniqueType *evaluate( Compiler *pd, CodeVect &code ) const;
 
 	InputLoc loc;
 	Type type;
@@ -2124,15 +2124,15 @@ struct LangStmt
 	LangStmt( Type type ) : 
 		type(type), next(0) {}
 
-	void resolve( ParseData *pd ) const;
-	void resolveParserItems( ParseData *pd ) const;
+	void resolve( Compiler *pd ) const;
+	void resolveParserItems( Compiler *pd ) const;
 
-	void evaluateParserItems( ParseData *pd, CodeVect &code ) const;
-	LangTerm *chooseDefaultIter( ParseData *pd, LangTerm *fromVarRef ) const;
-	void compileWhile( ParseData *pd, CodeVect &code ) const;
-	void compileForIterBody( ParseData *pd, CodeVect &code, UniqueType *iterUT ) const;
-	void compileForIter( ParseData *pd, CodeVect &code ) const;
-	void compile( ParseData *pd, CodeVect &code ) const;
+	void evaluateParserItems( Compiler *pd, CodeVect &code ) const;
+	LangTerm *chooseDefaultIter( Compiler *pd, LangTerm *fromVarRef ) const;
+	void compileWhile( Compiler *pd, CodeVect &code ) const;
+	void compileForIterBody( Compiler *pd, CodeVect &code, UniqueType *iterUT ) const;
+	void compileForIter( Compiler *pd, CodeVect &code ) const;
+	void compile( Compiler *pd, CodeVect &code ) const;
 
 	InputLoc loc;
 	Type type;
@@ -2165,8 +2165,8 @@ struct CodeBlock
 		localFrame(0),
 		context(0) {}
 
-	void compile( ParseData *pd, CodeVect &code ) const;
-	void resolve( ParseData *pd ) const;
+	void compile( Compiler *pd, CodeVect &code ) const;
+	void resolve( Compiler *pd ) const;
 
 	long frameId;
 	StmtList *stmtList;
diff --git a/colm/pdabuild.cc b/colm/pdabuild.cc
index 8d0b92a9..4bce96ce 100644
--- a/colm/pdabuild.cc
+++ b/colm/pdabuild.cc
@@ -97,7 +97,7 @@ LangEl::LangEl( Namespace *nspace, const String &name, Type type )
 {
 }
  
-PdaGraph *ProdElList::walk( ParseData *pd, Definition *prod )
+PdaGraph *ProdElList::walk( Compiler *pd, Definition *prod )
 {
 	PdaGraph *prodFsm = new PdaGraph();
 	PdaState *last = prodFsm->addState();
@@ -146,7 +146,7 @@ PdaGraph *ProdElList::walk( ParseData *pd, Definition *prod )
 }
 
 
-ProdElList *ParseData::makeProdElList( LangEl *langEl )
+ProdElList *Compiler::makeProdElList( LangEl *langEl )
 {
 	ProdElList *prodElList = new ProdElList();
 	UniqueType *uniqueType = findUniqueType( TYPE_TREE, langEl );
@@ -156,7 +156,7 @@ ProdElList *ParseData::makeProdElList( LangEl *langEl )
 	return prodElList;
 }
 
-void ParseData::makeDefinitionNames()
+void Compiler::makeDefinitionNames()
 {
 	for ( LelList::Iter lel = langEls; lel.lte(); lel++ ) {
 		int prodNum = 1;
@@ -170,7 +170,7 @@ void ParseData::makeDefinitionNames()
 /* Make sure there there are no language elements whose type is unkonwn. This
  * can happen when an id is used on the rhs of a definition but is not defined
  * as anything. */
-void ParseData::noUndefindLangEls()
+void Compiler::noUndefindLangEls()
 {
 	for ( LelList::Iter lel = langEls; lel.lte(); lel++ ) {
 		if ( lel->type == LangEl::Unknown )
@@ -178,7 +178,7 @@ void ParseData::noUndefindLangEls()
 	}
 }
 
-void ParseData::makeLangElIds()
+void Compiler::makeLangElIds()
 {
 	/* The first id 0 is reserved for the stack sentinal. A negative id means
 	 * error to the parsing function, inducing backtracking. */
@@ -232,7 +232,7 @@ void ParseData::makeLangElIds()
 	assert( ignoreLangEl->id == LEL_ID_IGNORE );
 }
 
-void ParseData::refNameSpace( LangEl *lel, Namespace *nspace )
+void Compiler::refNameSpace( LangEl *lel, Namespace *nspace )
 {
 	if ( nspace == defaultNamespace || nspace == rootNamespace ) {
 		lel->refName = "::" + lel->refName;
@@ -245,7 +245,7 @@ void ParseData::refNameSpace( LangEl *lel, Namespace *nspace )
 	refNameSpace( lel, nspace->parentNamespace );
 }
 
-void ParseData::makeLangElNames()
+void Compiler::makeLangElNames()
 {
 	for ( LelList::Iter lel = langEls; lel.lte(); lel++ ) {
 		if ( lel->id == LEL_ID_INT ) {
@@ -288,7 +288,7 @@ void ParseData::makeLangElNames()
 }
 
 /* Set up dot sets, shift info, and prod sets. */
-void ParseData::makeProdFsms()
+void Compiler::makeProdFsms()
 {
 	/* There are two items in the index for each production (high and low). */
 	int indexLen = prodList.length() * 2;
@@ -367,7 +367,7 @@ void ParseData::makeProdFsms()
  * it and over tab. If overSrc is the end of the production, find the follow
  * from the table, taking only the characters on which the parent is reduced.
  * */
-void ParseData::findFollow( AlphSet &result, PdaState *overTab, 
+void Compiler::findFollow( AlphSet &result, PdaState *overTab, 
 		PdaState *overSrc, Definition *parentDef )
 {
 	if ( overSrc->isFinState() ) {
@@ -415,7 +415,7 @@ void ParseData::findFollow( AlphSet &result, PdaState *overTab,
 	}
 }
 
-PdaState *ParseData::followProd( PdaState *tabState, PdaState *prodState )
+PdaState *Compiler::followProd( PdaState *tabState, PdaState *prodState )
 {
 	while ( prodState->transMap.length() == 1 ) {
 		TransMap::Iter prodTrans = prodState->transMap;
@@ -426,7 +426,7 @@ PdaState *ParseData::followProd( PdaState *tabState, PdaState *prodState )
 	return tabState;
 }
 
-void ParseData::trySetTime( PdaTrans *trans, long code, long &time )
+void Compiler::trySetTime( PdaTrans *trans, long code, long &time )
 {
 	/* Find the item. */
 	for ( ActDataList::Iter adl = trans->actions; adl.lte(); adl++ ) {
@@ -444,7 +444,7 @@ void ParseData::trySetTime( PdaTrans *trans, long code, long &time )
 }
 
 /* Go down a defintiion and then handle the follow actions. */
-void ParseData::pdaOrderFollow( LangEl *rootEl, PdaState *tabState, 
+void Compiler::pdaOrderFollow( LangEl *rootEl, PdaState *tabState, 
 		PdaTrans *tabTrans, PdaTrans *srcTrans, Definition *parentDef, 
 		Definition *definition, long &time )
 {
@@ -485,7 +485,7 @@ bool regionVectHas( RegionVect &regVect, TokenRegion *region )
 	return false;
 }
 
-void ParseData::addRegion( PdaState *tabState, PdaTrans *tabTrans,
+void Compiler::addRegion( PdaState *tabState, PdaTrans *tabTrans,
 		long pdaKey, bool noPreIgnore, bool noPostIgnore )
 {
 	LangEl *langEl = langElIndex[pdaKey];
@@ -558,7 +558,7 @@ void ParseData::addRegion( PdaState *tabState, PdaTrans *tabTrans,
     orderState( parseTable.startState, startProduction.startState, 1 )
 #endif
 
-void ParseData::pdaOrderProd( LangEl *rootEl, PdaState *tabState, 
+void Compiler::pdaOrderProd( LangEl *rootEl, PdaState *tabState, 
 	PdaState *srcState, Definition *parentDef, long &time )
 {
 	assert( srcState->dotSet.length() == 1 );
@@ -619,7 +619,7 @@ void ParseData::pdaOrderProd( LangEl *rootEl, PdaState *tabState,
 	}
 }
 
-void ParseData::pdaActionOrder( PdaGraph *pdaGraph, LangElSet &parserEls )
+void Compiler::pdaActionOrder( PdaGraph *pdaGraph, LangElSet &parserEls )
 {
 	for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) {
 		assert( (state->stateBits & SB_ISMARKED) == 0 );
@@ -686,7 +686,7 @@ void ParseData::pdaActionOrder( PdaGraph *pdaGraph, LangElSet &parserEls )
 	}
 }
 
-void ParseData::advanceReductions( PdaGraph *pdaGraph )
+void Compiler::advanceReductions( PdaGraph *pdaGraph )
 {
 	/* Loop all states. */
 	for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) {
@@ -745,7 +745,7 @@ void ParseData::advanceReductions( PdaGraph *pdaGraph )
 	pdaGraph->removeUnreachableStates();
 }
 
-void ParseData::sortActions( PdaGraph *pdaGraph )
+void Compiler::sortActions( PdaGraph *pdaGraph )
 {
 	/* Sort the actions. */
 	for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) {
@@ -823,7 +823,7 @@ void ParseData::sortActions( PdaGraph *pdaGraph )
 	}
 }
 
-void ParseData::reduceActions( PdaGraph *pdaGraph )
+void Compiler::reduceActions( PdaGraph *pdaGraph )
 {
 	/* Reduce the actions. */
 	for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) {
@@ -858,7 +858,7 @@ void ParseData::reduceActions( PdaGraph *pdaGraph )
 	}
 }
 
-void ParseData::computeAdvanceReductions( LangEl *langEl, PdaGraph *pdaGraph )
+void Compiler::computeAdvanceReductions( LangEl *langEl, PdaGraph *pdaGraph )
 {
 	/* Get the entry into the graph and traverse over the root. The resulting
 	 * state can have eof, nothing else can. */
@@ -879,7 +879,7 @@ void ParseData::computeAdvanceReductions( LangEl *langEl, PdaGraph *pdaGraph )
 	}
 }
 
-void ParseData::verifyParseStopGrammar( LangEl *langEl, PdaGraph *pdaGraph )
+void Compiler::verifyParseStopGrammar( LangEl *langEl, PdaGraph *pdaGraph )
 {
 	/* Get the entry into the graph and traverse over the root. The resulting
 	 * state can have eof, nothing else can. */
@@ -902,7 +902,7 @@ void ParseData::verifyParseStopGrammar( LangEl *langEl, PdaGraph *pdaGraph )
 	}
 }
 
-LangEl *ParseData::predOf( PdaTrans *trans, long action )
+LangEl *Compiler::predOf( PdaTrans *trans, long action )
 {
 	LangEl *lel;
 	if ( action == SHIFT_CODE )
@@ -913,7 +913,7 @@ LangEl *ParseData::predOf( PdaTrans *trans, long action )
 }
 
 
-bool ParseData::precedenceSwap( long action1, long action2, LangEl *l1, LangEl *l2 )
+bool Compiler::precedenceSwap( long action1, long action2, LangEl *l1, LangEl *l2 )
 {
 	bool swap = false;
 	if ( l2->predValue > l1->predValue )
@@ -927,14 +927,14 @@ bool ParseData::precedenceSwap( long action1, long action2, LangEl *l1, LangEl *
 	return swap;
 }
 
-bool ParseData::precedenceRemoveBoth( LangEl *l1, LangEl *l2 )
+bool Compiler::precedenceRemoveBoth( LangEl *l1, LangEl *l2 )
 {
 	if ( l1->predValue == l2->predValue && l1->predType == PredNonassoc )
 		return true;
 	return false;
 }
 
-void ParseData::resolvePrecedence( PdaGraph *pdaGraph )
+void Compiler::resolvePrecedence( PdaGraph *pdaGraph )
 {
 	for ( PdaStateList::Iter state = pdaGraph->stateList; state.lte(); state++ ) {
 		assert( CmpDotSet::compare( state->dotSet, state->dotSet2 ) == 0 );
@@ -983,7 +983,7 @@ again:
 	}
 }
 
-void ParseData::analyzeMachine( PdaGraph *pdaGraph, LangElSet &parserEls )
+void Compiler::analyzeMachine( PdaGraph *pdaGraph, LangElSet &parserEls )
 {
 	pdaGraph->maxState = pdaGraph->stateList.length() - 1;
 	pdaGraph->maxLelId = nextSymbolId - 1;
@@ -1064,7 +1064,7 @@ void ParseData::analyzeMachine( PdaGraph *pdaGraph, LangElSet &parserEls )
 	}
 }
 
-void ParseData::wrapNonTerminals()
+void Compiler::wrapNonTerminals()
 {
 	/* Make a language element that will be used to make the root productions.
 	 * These are used for making parsers rooted at any production (including
@@ -1087,7 +1087,7 @@ void ParseData::wrapNonTerminals()
 	}
 }
 
-bool ParseData::makeNonTermFirstSetProd( Definition *prod, PdaState *state )
+bool Compiler::makeNonTermFirstSetProd( Definition *prod, PdaState *state )
 {
 	bool modified = false;
 	for ( TransMap::Iter trans = state->transMap; trans.lte(); trans++ ) {
@@ -1129,7 +1129,7 @@ bool ParseData::makeNonTermFirstSetProd( Definition *prod, PdaState *state )
 }
 
 
-void ParseData::makeNonTermFirstSets()
+void Compiler::makeNonTermFirstSets()
 {
 	bool modified = true;
 	while ( modified ) {
@@ -1153,7 +1153,7 @@ void ParseData::makeNonTermFirstSets()
 	}
 }
 
-void ParseData::printNonTermFirstSets()
+void Compiler::printNonTermFirstSets()
 {
 	for ( DefList::Iter prod = prodList; prod.lte(); prod++ ) {
 		cerr << prod->data << ": ";
@@ -1173,7 +1173,7 @@ void ParseData::printNonTermFirstSets()
 	}
 }
 
-bool ParseData::makeFirstSetProd( Definition *prod, PdaState *state )
+bool Compiler::makeFirstSetProd( Definition *prod, PdaState *state )
 {
 	bool modified = false;
 	for ( TransMap::Iter trans = state->transMap; trans.lte(); trans++ ) {
@@ -1227,7 +1227,7 @@ bool ParseData::makeFirstSetProd( Definition *prod, PdaState *state )
 }
 
 
-void ParseData::makeFirstSets()
+void Compiler::makeFirstSets()
 {
 	bool modified = true;
 	while ( modified ) {
@@ -1246,7 +1246,7 @@ void ParseData::makeFirstSets()
 	}
 }
 
-void ParseData::printFirstSets()
+void Compiler::printFirstSets()
 {
 	for ( DefList::Iter prod = prodList; prod.lte(); prod++ ) {
 		cerr << prod->data << ": ";
@@ -1266,7 +1266,7 @@ void ParseData::printFirstSets()
 	}
 }
 
-void ParseData::insertUniqueEmptyProductions()
+void Compiler::insertUniqueEmptyProductions()
 {
 	int limit = prodList.length();
 	for ( DefList::Iter prod = prodList; prod.lte(); prod++ ) {
@@ -1288,7 +1288,7 @@ void ParseData::insertUniqueEmptyProductions()
 	}
 }
 
-void ParseData::makeRuntimeData()
+void Compiler::makeRuntimeData()
 {
 	long count = 0;
 
@@ -1747,7 +1747,7 @@ void fillNodes( Program *prg, int &nextAvail, Bindings *bindings, long &bindId,
 	}
 }
 
-void ParseData::fillInPatterns( Program *prg )
+void Compiler::fillInPatterns( Program *prg )
 {
 	/*
 	 * patReplNodes
@@ -1809,7 +1809,7 @@ void ParseData::fillInPatterns( Program *prg )
 }
 
 
-int ParseData::findIndexOff( PdaTables *pdaTables, PdaGraph *pdaGraph, PdaState *state, int &curLen )
+int Compiler::findIndexOff( PdaTables *pdaTables, PdaGraph *pdaGraph, PdaState *state, int &curLen )
 {
 	for ( int start = 0; start < curLen;  ) {
 		int offset = start;
@@ -1860,7 +1860,7 @@ struct CmpSpan
 	}
 };
 
-PdaGraph *ParseData::makePdaGraph( LangElSet &parserEls )
+PdaGraph *Compiler::makePdaGraph( LangElSet &parserEls )
 {
 	//for ( DefList::Iter prod = prodList; prod.lte(); prod++ )
 	//	cerr << prod->prodId << " " << prod->data << endl;
@@ -1875,7 +1875,7 @@ PdaGraph *ParseData::makePdaGraph( LangElSet &parserEls )
 	return pdaGraph;
 }
 
-PdaTables *ParseData::makePdaTables( PdaGraph *pdaGraph )
+PdaTables *Compiler::makePdaTables( PdaGraph *pdaGraph )
 {
 	int count, pos;
 	PdaTables *pdaTables = new PdaTables;
@@ -2083,7 +2083,7 @@ PdaTables *ParseData::makePdaTables( PdaGraph *pdaGraph )
 	return pdaTables;
 }
 
-void ParseData::makeParser( LangElSet &parserEls )
+void Compiler::makeParser( LangElSet &parserEls )
 {
 	pdaGraph = makePdaGraph( parserEls );
 	pdaTables = makePdaTables( pdaGraph );
diff --git a/colm/pdacodegen.h b/colm/pdacodegen.h
index 274dcae0..8e5e7a3a 100644
--- a/colm/pdacodegen.h
+++ b/colm/pdacodegen.h
@@ -23,11 +23,11 @@
 #ifndef _PDACODEGEN_H
 #define _PDACODEGEN_H
 
-struct ParseData;
+struct Compiler;
 
 struct PdaCodeGen
 {
-	PdaCodeGen( const char *fileName, const char *parserName, ParseData *pd, ostream &out )
+	PdaCodeGen( const char *fileName, const char *parserName, Compiler *pd, ostream &out )
 	:
 		fileName(fileName),
 		parserName(parserName),
@@ -99,7 +99,7 @@ struct PdaCodeGen
 
 	const char *fileName;
 	const char *parserName;
-	ParseData *pd;
+	Compiler *pd;
 	ostream &out;
 };
 
diff --git a/colm/redbuild.cc b/colm/redbuild.cc
index 9a196316..e85d74ca 100644
--- a/colm/redbuild.cc
+++ b/colm/redbuild.cc
@@ -29,7 +29,7 @@
 
 using namespace std;
 
-RedFsmBuild::RedFsmBuild( char *fsmName, ParseData *pd, FsmGraph *fsm )
+RedFsmBuild::RedFsmBuild( char *fsmName, Compiler *pd, FsmGraph *fsm )
 :
 	fsmName(fsmName),
 	pd(pd),
diff --git a/colm/redbuild.h b/colm/redbuild.h
index 5c856500..dbbb3e19 100644
--- a/colm/redbuild.h
+++ b/colm/redbuild.h
@@ -31,7 +31,7 @@
 /* Forwards. */
 struct FsmTrans;
 struct FsmGraph;
-struct ParseData;
+struct Compiler;
 struct FsmCodeGen;
 struct RedFsm;
 struct GenCondSpace;
@@ -84,7 +84,7 @@ struct NextRedTrans
 class RedFsmBuild
 {
 public:
-	RedFsmBuild( char *fsmName, ParseData *pd, FsmGraph *fsm );
+	RedFsmBuild( char *fsmName, Compiler *pd, FsmGraph *fsm );
 	RedFsm *reduceMachine( );
 
 private:
@@ -137,7 +137,7 @@ private:
 	void makeActionExecTE( InlineItem *item );
 
 	char *fsmName;
-	ParseData *pd;
+	Compiler *pd;
 	FsmGraph *fsm;
 	ActionTableMap actionTableMap;
 	int nextActionTableId;
diff --git a/colm/redfsm.h b/colm/redfsm.h
index 456a154a..39b98d5f 100644
--- a/colm/redfsm.h
+++ b/colm/redfsm.h
@@ -49,7 +49,7 @@ using std::string;
 
 struct RedState;
 struct InlineList;
-struct ParseData;
+struct Compiler;
 struct ObjField;
 
 /* Element in list of actions. Contains the string for the code to exectute. */
diff --git a/colm/resolve.cc b/colm/resolve.cc
index 3652896b..a661e68e 100644
--- a/colm/resolve.cc
+++ b/colm/resolve.cc
@@ -29,7 +29,7 @@ using std::cout;
 using std::cerr;
 using std::endl;
 
-UniqueType *TypeRef::lookupTypeName( ParseData *pd )
+UniqueType *TypeRef::lookupTypeName( Compiler *pd )
 {
 	/* Lookup up the qualifiction and then the name. */
 	nspace = nspaceQual->getQual( pd );
@@ -59,7 +59,7 @@ UniqueType *TypeRef::lookupTypeName( ParseData *pd )
 	return 0;
 }
 
-UniqueType *TypeRef::lookupTypeLiteral( ParseData *pd )
+UniqueType *TypeRef::lookupTypeLiteral( Compiler *pd )
 {
 	/* Lookup up the qualifiction and then the name. */
 	nspace = nspaceQual->getQual( pd );
@@ -86,7 +86,7 @@ UniqueType *TypeRef::lookupTypeLiteral( ParseData *pd )
 	return 0;
 }
 
-UniqueType *TypeRef::lookupTypeMap( ParseData *pd )
+UniqueType *TypeRef::lookupTypeMap( Compiler *pd )
 {
 	/* Lookup up the qualifiction and then the name. */
 	nspace = nspaceQual->getQual( pd );
@@ -119,7 +119,7 @@ UniqueType *TypeRef::lookupTypeMap( ParseData *pd )
 	return pd->findUniqueType( TYPE_TREE, inMap->generic->langEl );
 }
 
-UniqueType *TypeRef::lookupTypeList( ParseData *pd )
+UniqueType *TypeRef::lookupTypeList( Compiler *pd )
 {
 	/* Lookup up the qualifiction and then the name. */
 	nspace = nspaceQual->getQual( pd );
@@ -150,7 +150,7 @@ UniqueType *TypeRef::lookupTypeList( ParseData *pd )
 	return pd->findUniqueType( TYPE_TREE, inMap->generic->langEl );
 }
 
-UniqueType *TypeRef::lookupTypeVector( ParseData *pd )
+UniqueType *TypeRef::lookupTypeVector( Compiler *pd )
 {
 	/* Lookup up the qualifiction and then the name. */
 	nspace = nspaceQual->getQual( pd );
@@ -181,7 +181,7 @@ UniqueType *TypeRef::lookupTypeVector( ParseData *pd )
 	return pd->findUniqueType( TYPE_TREE, inMap->generic->langEl );
 }
 
-UniqueType *TypeRef::lookupTypeParser( ParseData *pd )
+UniqueType *TypeRef::lookupTypeParser( Compiler *pd )
 {
 	/* Lookup up the qualifiction and then the name. */
 	nspace = nspaceQual->getQual( pd );
@@ -212,19 +212,19 @@ UniqueType *TypeRef::lookupTypeParser( ParseData *pd )
 	return pd->findUniqueType( TYPE_TREE, inMap->generic->langEl );
 }
 
-UniqueType *TypeRef::lookupTypePtr( ParseData *pd )
+UniqueType *TypeRef::lookupTypePtr( Compiler *pd )
 {
 	typeRef1->lookupType( pd );
 	return pd->findUniqueType( TYPE_PTR, typeRef1->uniqueType->langEl );
 }
 
-UniqueType *TypeRef::lookupTypeRef( ParseData *pd )
+UniqueType *TypeRef::lookupTypeRef( Compiler *pd )
 {
 	typeRef1->lookupType( pd );
 	return pd->findUniqueType( TYPE_REF, typeRef1->uniqueType->langEl );
 }
 
-void TypeRef::resolveRepeat( ParseData *pd )
+void TypeRef::resolveRepeat( Compiler *pd )
 {
 	if ( uniqueType->typeId != TYPE_TREE )
 		error(loc) << "cannot repeat non-tree type" << endp;
@@ -272,7 +272,7 @@ void TypeRef::resolveRepeat( ParseData *pd )
 }
 
 
-UniqueType *TypeRef::lookupType( ParseData *pd )
+UniqueType *TypeRef::lookupType( Compiler *pd )
 {
 	if ( uniqueType != 0 )
 		return uniqueType;
@@ -315,13 +315,13 @@ UniqueType *TypeRef::lookupType( ParseData *pd )
 	return uniqueType;
 }
 
-void ParseData::resolveFactor( ProdEl *fact )
+void Compiler::resolveFactor( ProdEl *fact )
 {
 	fact->typeRef->lookupType( this );
 	fact->langEl = fact->typeRef->uniqueType->langEl;
 }
 
-void LangTerm::resolve( ParseData *pd )
+void LangTerm::resolve( Compiler *pd )
 {
 	switch ( type ) {
 		case ConstructType:
@@ -375,12 +375,12 @@ void LangTerm::resolve( ParseData *pd )
 	}
 }
 
-void LangVarRef::resolve( ParseData *pd ) const
+void LangVarRef::resolve( Compiler *pd ) const
 {
 
 }
 
-void LangExpr::resolve( ParseData *pd ) const
+void LangExpr::resolve( Compiler *pd ) const
 {
 	switch ( type ) {
 		case BinaryType: {
@@ -399,7 +399,7 @@ void LangExpr::resolve( ParseData *pd ) const
 	}
 }
 
-void LangStmt::resolveParserItems( ParseData *pd ) const
+void LangStmt::resolveParserItems( Compiler *pd ) const
 {
 	/* Assign bind ids to the variables in the replacement. */
 	for ( ReplItemList::Iter item = *parserText->list; item.lte(); item++ ) {
@@ -417,7 +417,7 @@ void LangStmt::resolveParserItems( ParseData *pd ) const
 	}
 }
 
-void LangStmt::resolve( ParseData *pd ) const
+void LangStmt::resolve( Compiler *pd ) const
 {
 	switch ( type ) {
 		case PrintType: 
@@ -499,7 +499,7 @@ void LangStmt::resolve( ParseData *pd ) const
 	}
 }
 
-void ObjectDef::resolve( ParseData *pd )
+void ObjectDef::resolve( Compiler *pd )
 {
 	for ( ObjFieldList::Iter fli = *objFieldList; fli.lte(); fli++ ) {
 		ObjField *field = fli->value;
@@ -510,7 +510,7 @@ void ObjectDef::resolve( ParseData *pd )
 	}
 }
 
-void CodeBlock::resolve( ParseData *pd ) const
+void CodeBlock::resolve( Compiler *pd ) const
 {
 	if ( localFrame != 0 )
 		localFrame->resolve( pd );
@@ -519,25 +519,25 @@ void CodeBlock::resolve( ParseData *pd ) const
 		stmt->resolve( pd );
 }
 
-void ParseData::resolveFunction( Function *func )
+void Compiler::resolveFunction( Function *func )
 {
 	CodeBlock *block = func->codeBlock;
 	block->resolve( this );
 }
 
-void ParseData::resolveUserIter( Function *func )
+void Compiler::resolveUserIter( Function *func )
 {
 	CodeBlock *block = func->codeBlock;
 	block->resolve( this );
 }
 
-void ParseData::resolvePreEof( TokenRegion *region )
+void Compiler::resolvePreEof( TokenRegion *region )
 {
 	CodeBlock *block = region->preEofBlock;
 	block->resolve( this );
 }
 
-void ParseData::resolveRootBlock()
+void Compiler::resolveRootBlock()
 {
 	rootLocalFrame->resolve( this );
 
@@ -545,19 +545,19 @@ void ParseData::resolveRootBlock()
 	block->resolve( this );
 }
 
-void ParseData::resolveTranslateBlock( LangEl *langEl )
+void Compiler::resolveTranslateBlock( LangEl *langEl )
 {
 	CodeBlock *block = langEl->transBlock;
 	block->resolve( this );
 }
 
-void ParseData::resolveReductionCode( Definition *prod )
+void Compiler::resolveReductionCode( Definition *prod )
 {
 	CodeBlock *block = prod->redBlock;
 	block->resolve( this );
 }
 
-void ParseData::resolveParseTree()
+void Compiler::resolveParseTree()
 {
 	/* Compile functions. */
 	for ( FunctionList::Iter f = functionList; f.lte(); f++ ) {
@@ -613,7 +613,7 @@ void ParseData::resolveParseTree()
 }
 
 
-void ParseData::resolveUses()
+void Compiler::resolveUses()
 {
 	for ( LelList::Iter lel = langEls; lel.lte(); lel++ ) {
 		if ( lel->objectDefUses != 0 ) {
@@ -630,7 +630,7 @@ void ParseData::resolveUses()
 	}
 }
 
-void ParseData::resolvePatternEls()
+void Compiler::resolvePatternEls()
 {
 	for ( PatternList::Iter pat = patternList; pat.lte(); pat++ ) {
 		for ( PatternItemList::Iter item = *pat->list; item.lte(); item++ ) {
@@ -647,7 +647,7 @@ void ParseData::resolvePatternEls()
 	}
 }
 
-void ParseData::resolveReplacementEls()
+void Compiler::resolveReplacementEls()
 {
 	for ( ReplList::Iter repl = replList; repl.lte(); repl++ ) {
 		for ( ReplItemList::Iter item = *repl->list; item.lte(); item++ ) {
@@ -664,7 +664,7 @@ void ParseData::resolveReplacementEls()
 	}
 }
 
-void ParseData::resolveParserEls()
+void Compiler::resolveParserEls()
 {
 	for ( ParserTextList::Iter accum = parserTextList; accum.lte(); accum++ ) {
 		for ( ReplItemList::Iter item = *accum->list; item.lte(); item++ ) {
@@ -681,7 +681,7 @@ void ParseData::resolveParserEls()
 }
 
 /* Resolves production els and computes the precedence of each prod. */
-void ParseData::resolveProductionEls()
+void Compiler::resolveProductionEls()
 {
 	/* NOTE: as we process this list it may be growing! */
 	for ( DefList::Iter prod = prodList; prod.lte(); prod++ ) {
@@ -704,7 +704,7 @@ void ParseData::resolveProductionEls()
 	}
 }
 
-void ParseData::resolveGenericTypes()
+void Compiler::resolveGenericTypes()
 {
 	for ( NamespaceList::Iter ns = namespaceList; ns.lte(); ns++ ) {
 		for ( GenericList::Iter gen = ns->genericList; gen.lte(); gen++ ) {
@@ -718,7 +718,7 @@ void ParseData::resolveGenericTypes()
 	}
 }
 
-void ParseData::makeTerminalWrappers()
+void Compiler::makeTerminalWrappers()
 {
 	/* Make terminal language elements corresponding to each nonterminal in
 	 * the grammar. */
@@ -739,7 +739,7 @@ void ParseData::makeTerminalWrappers()
 	}
 }
 
-void ParseData::makeEofElements()
+void Compiler::makeEofElements()
 {
 	/* Make eof language elements for each user terminal. This is a bit excessive and
 	 * need to be reduced to the ones that we need parsers for, but we don't know that yet.
@@ -762,7 +762,7 @@ void ParseData::makeEofElements()
 	}
 }
 
-void ParseData::makeIgnoreCollectors()
+void Compiler::makeIgnoreCollectors()
 {
 	for ( RegionList::Iter region = regionList; region.lte(); region++ ) {
 		if ( region->isFullRegion ) {
@@ -777,7 +777,7 @@ void ParseData::makeIgnoreCollectors()
 	}
 }
 
-void ParseData::typeResolve()
+void Compiler::typeResolve()
 {
 	/*
 	 * Type Resolving.