pascalcompiler.cpp

袖珍型的pascal编译器

	RemoveRecord(targetValue);
	if (stepValue)
		RemoveRecord(stepValue);
	delete tmpCode;
}




///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:37:30 PM
// Function name	: CPascalCompiler::InstrCase
// Description	    : 
// Return type		: void 
///////////////////////////////////////////////////////////////

void CPascalCompiler::InstrCase()
{
	if (NextToken() != TT_KW_CASE)
		throw error(SET_EXPECTED, CString("case"));
	ExprInfo type;
	Expr(type);

	// Now the case expression is on the Sack

	if (NextToken() != TT_KW_OF)
		throw error(SET_EXPECTED, CString("of"));
	ListaAltern(type);
	if (NextToken() != TT_KW_END)
		throw error(SET_EXPECTED, CString("end"));
}



///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:37:38 PM
// Function name	: CPascalCompiler::ListaAltern
// Description	    : 
// Return type		: void 
// Argument         : ExprInfo& Info
///////////////////////////////////////////////////////////////

void CPascalCompiler::ListaAltern(ExprInfo& Info)
{
	StackEntry entry;
	CString label, endlabel;
	endlabel.Format("ET%d",m_nLabelCount);
	CList<int,int> endAddressList;
	while (1)
	{
		CList<int,int> addressList;
		m_nLabelCount ++;
		while (1)
		{
			GenerateCode(INSTR_COPY);
			int val = NextToken();
			switch (val)
			{
			case TT_INTEGER:
				if (Info.m_nAtribTip != ET_INTEGER)
					throw error(SET_EXPECTED, CString("integer"));
				
				entry.m_nType = SE_INTEGER;
				CV_INTEGER(entry.m_Info) = (INTEGER) GetNumValue();
				GenerateCode(INSTR_LODI,entry);
				break;
			case TT_REAL:
				if (Info.m_nAtribTip != ET_REAL)
					throw error(SET_EXPECTED, CString("real"));
				
				entry.m_nType = SE_REAL;
				CV_REAL(entry.m_Info) = (REAL) GetNumValue();
				GenerateCode(INSTR_LODI,entry);
				break;
			case TT_CHAR:
				if (Info.m_nAtribTip != ET_CHAR)
					throw error(SET_EXPECTED, CString("char"));
	
				entry.m_nType = SE_CHAR;
				CV_CHAR(entry.m_Info) = (CHAR) GetNumValue();
				GenerateCode(INSTR_LODI,entry);
				
				break;
			default :
				throw error(SET_EXPECTED, CString("Constant"));

			}
			GenerateCode(INSTR_EQU);
			addressList.AddHead(m_Code->GetCurCodePos() + VM_ICSIZE);
			label.Format("ET%d",m_nLabelCount);
			GenerateCode(INSTR_FJP,0,label);
			if (NextToken()!=',')
			{
				PushBack();
				break;
			}
		}


		if (NextToken()!=':')
			throw error(SET_EXPECTED, CString(":"));

		int where = m_Code->GetCurCodePos() + VM_ICSIZE;
		CString tmp = label + ":";
		label.Format("ET%d",++m_nLabelCount);
		GenerateCode(INSTR_UJP,0,label);
		
		InsertLabel(tmp);
		// now setting the jumping stuff addresses
		POSITION pos = addressList.GetHeadPosition();
		while (pos != NULL)
		{
			int place = addressList.GetNext(pos);
			m_Code->SetAddress(place,m_Code->GetCurCodePos());
		}
		addressList.RemoveAll();

		Instr();
		// jump to end
		endAddressList.AddHead(m_Code->GetCurCodePos() + VM_ICSIZE);
		GenerateCode(INSTR_UJP,0,endlabel);

		InsertLabel(label + ":");
		m_Code->SetAddress(where,m_Code->GetCurCodePos());
		if (NextToken()!=';')
			{
				PushBack();
				break;
			}
	}
	if (NextToken() == TT_KW_OTHERWISE)
	{
		Instr();
	}
	else
		PushBack();
		
	// set the jump to end addresses
	POSITION pos = endAddressList.GetHeadPosition();
	while (pos != NULL)
	{
		int place = endAddressList.GetNext(pos);
		m_Code->SetAddress(place,m_Code->GetCurCodePos());
	}	
	InsertLabel(endlabel + ":");

	GenerateCode(INSTR_RED,(OFFSET) 1);	// clear the value from stack
}




///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:37:49 PM
// Function name	: CPascalCompiler::ApelProcedura
// Description	    : 
// Return type		: void 
///////////////////////////////////////////////////////////////

void CPascalCompiler::ApelProcedura()
{
	ExprInfo type;
	if (NextToken()!= TT_WORD)
		throw error(SET_EXPECTED, CString("identifier"));
	Symbol *simb = NULL;
	CString procedure = GetStrValue();
	RetreaveSymbol(procedure,simb);
	
	AddComment("Calling: " + GetStrValue());
	
	POSITION pos = simb->m_ListaPar.GetHeadPosition ();
	if (NextToken()=='(')
	{
		while (1)
		{
			if (pos == NULL)
				throw error(SET_GENERAL, CString("Too many parameters"));
			Param par = simb->m_ListaPar .GetNext(pos);

			// This part put's the entire parameters on the stack
			if (par.m_nTransmisie == LV_ADDRESS)
				VariabilaAdr(type);
			else
				Expr(type);
			if (type.m_nAtribTip != par.m_nType )
				throw error(SET_GENERAL, CString("Invalid Parameter type"));
			if (par.m_nTransmisie == LV_ADDRESS && type.m_nAtribLValue== LV_VALUE )
				throw error(SET_GENERAL, CString("Invalid Parameter, must be a variable"));
			if (NextToken()!=',')
			{
				PushBack();
				if (pos != NULL)
					throw error(SET_GENERAL, CString("Too few parameters"));
				break;
			}
		}
		if (NextToken()!=')')
			throw error(SET_EXPECTED, CString(")"));
	}
	else
	{
		PushBack();
		if (simb->m_ListaPar.GetCount () != 0)
			throw error(SET_GENERAL, CString("Some parameters expected"));
	}
	// Generate code for the call
	if (simb->m_nAdrStart == -1)
	{
		AddressPlace place;
		place.m_nPosition = m_Code->GetCurCodePos() + VM_ICSIZE;
		place.m_sSimb = procedure;
		m_AdrList.AddHead(place);
	}
	GenerateCode(INSTR_CALL,(REGISTER)simb->m_nAdrStart, simb->m_sName);
	GenerateCode(INSTR_RED,(OFFSET)simb->m_ListaPar.GetCount());
}




///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:37:58 PM
// Function name	: CPascalCompiler::InstrPrint
// Description	    : 
// Return type		: void 
///////////////////////////////////////////////////////////////

void CPascalCompiler::InstrPrint()
{
	if (NextToken()!=TT_KW_PRINT)
		throw error(SET_EXPECTED, CString("print"));
	if (NextToken()!='(')
		throw error(SET_EXPECTED, CString("("));
	while (1)
	{
		if (NextToken()!=TT_STRING)
		{
			PushBack();
			ExprInfo type;
			Expr(type);
			GenerateCode(INSTR_OUTP);
		}
		else
		{
			// If string
			// generate string printing code
			CString str = GetStrValue();
			for (int i =0 ; i<str.GetLength(); i++)
			{
				StackEntry entry;
				entry.m_nType = SE_CHAR;
				CV_CHAR(entry.m_Info) = str[i];
				GenerateCode(INSTR_LODI,entry);
				GenerateCode(INSTR_OUTP);
			}
		}
		if (NextToken()!=',')
		{
			PushBack();
			break;
		}
	}
	if (NextToken()!=')')
		throw error(SET_EXPECTED, CString(")"));
}




///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:38:06 PM
// Function name	: CPascalCompiler::InstrRead
// Description	    : 
// Return type		: void 
///////////////////////////////////////////////////////////////

void CPascalCompiler::InstrRead()
{
	if (NextToken()!=TT_KW_READ)
		throw error(SET_EXPECTED, CString("read"));
	if (NextToken()!='(')
		throw error(SET_EXPECTED, CString("("));
	while (1)
	{
		ExprInfo type;
		VariabilaAdr(type);
		GenerateCode(INSTR_INP,(BYTE) type.m_nAtribTip);
		GenerateCode(INSTR_STO);

		if (NextToken()!=',')
		{
			PushBack();
			break;
		}
	}
	if (NextToken()!=')')
		throw error(SET_EXPECTED, CString(")"));
}



///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:38:14 PM
// Function name	: error::GetErrStr
// Description	    : 
// Return type		: CString 
///////////////////////////////////////////////////////////////

CString error::GetErrStr()
{
	CString estr;
	switch (m_nType)
	{
	case SET_GENERAL: estr.Format("Syntax ERROR, %s",m_sData);break;
	case SET_EXPECTED: estr.Format("%s expected",m_sData);break;
	case SET_INVALID_OP_TYPES: estr.Format("Invalid operation between different types, %s",m_sData);break;
	case SET_INVALID_OP: estr.Format("Invalid operation , %s",m_sData);break;
	default: estr = _T("Syntax ERROR");
	}
	return estr;
}




///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:38:22 PM
// Function name	: CPascalCompiler::GetErrStr
// Description	    : 
// Return type		: CString 
// Argument         : error &e
///////////////////////////////////////////////////////////////

CString CPascalCompiler::GetErrStr(error &e)
{
	CString str;
	str.Format("%s  at : %d", e.GetErrStr(), LineNo ());	
	return str;
}






///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:38:30 PM
// Function name	: SymbolTableCollection::SymbolTableCollection
// Description	    : 
// Return type		: 
///////////////////////////////////////////////////////////////

SymbolTableCollection::SymbolTableCollection()
{
}




///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:38:37 PM
// Function name	: SymbolTableCollection::~SymbolTableCollection
// Description	    : 
// Return type		: 
///////////////////////////////////////////////////////////////

SymbolTableCollection::~SymbolTableCollection()
{
	POSITION pos = GetHeadPosition();
	while (pos!=NULL)
	{
		SymbolTable *table = GetNext(pos);
		delete table;
	}
}




///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:38:44 PM
// Function name	: SymbolTableCollection::IncreaseLevel
// Description	    : 
// Return type		: void 
///////////////////////////////////////////////////////////////

void SymbolTableCollection::IncreaseLevel()
{
	SymbolTable *ntable = new SymbolTable();
	ntable->InitHashTable( MAX_SYMB );
	AddHead(ntable);
}




///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:38:51 PM
// Function name	: SymbolTableCollection::DecreaseLevel
// Description	    : 
// Return type		: void 
///////////////////////////////////////////////////////////////

void SymbolTableCollection::DecreaseLevel()
{
	SymbolTable *ntable = GetHead();
	delete ntable;
	RemoveHead();
}



///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:38:57 PM
// Function name	: SymbolTableCollection::InsertSymbol
// Description	    : 
// Return type		: void 
// Argument         : Symbol *s
///////////////////////////////////////////////////////////////

void SymbolTableCollection::InsertSymbol(Symbol *s)
{
	SymbolTable *ntable = GetHead();
	(*ntable)[s->m_sName] = s;
}




///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:39:04 PM
// Function name	: SymbolTableCollection::RetreaveSymbolCL
// Description	    : 
// Return type		: BOOL 
// Argument         : CString& name
// Argument         : Symbol *&simb
///////////////////////////////////////////////////////////////

BOOL SymbolTableCollection::RetreaveSymbolCL(CString& name, Symbol *&simb)
{
	SymbolTable *ntable = GetHead();
	return ntable->Lookup(name,simb);
}




///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:39:12 PM
// Function name	: CPascalCompiler::RetreaveSymbol
// Description	    : 
// Return type		: BOOL 
// Argument         : CString &name
// Argument         : Symbol *&simb
///////////////////////////////////////////////////////////////

BOOL CPascalCompiler::RetreaveSymbol(CString &name, Symbol *&simb)
{
	return m_SymbTableCollection.RetreaveSymbolAL (name,simb);
}



///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:39:18 PM
// Function name	: CPascalCompiler::IncreaseLevel
// Description	    : 
// Return type		: void 
///////////////////////////////////////////////////////////////

void CPascalCompiler::IncreaseLevel()
{
	m_SymbTableCollection.IncreaseLevel ();	
	m_nVNivel++;
}



///////////////////////////////////////////////////////////////
// Programmer		: Zoly Farkas
// Creation Date	: 8/3/99 4:39:24 PM
// Function name	: CPascalCompiler::DecreaseLevel
// Description	    : 
// Return type		: void 
///////////////////////////////////////////////////////////////

void CPascalCompiler::DecreaseLevel()
{
	m_SymbTableCollection.DecreaseLevel ();	
	m_nVNivel--;
}


///////////////////////////////////////////////////////////////
// Programm