private void AssignStat()
{
ISymbolTableEntry entry = symbolTable.Lookup(lexeme.ToString());
ISymbolTableEntry Eplace = null;
string code = "";
if (entry != null && (entry.TypeOfEntry == EntryType.classEntry || entry.TypeOfEntry == EntryType.tableEntry))
{
MethodCall();
}
else if (entry != null && entry.TypeOfEntry == EntryType.varEntry)
{
Match(Token.idt);
Match(Token.assignopt);
ISymbolTableEntry entry2 = symbolTable.Lookup(lexeme.ToString());
if (entry2 != null && entry2.TypeOfEntry == EntryType.classEntry)
{
MethodCall();
intermediateCodeGenerator.Emit($"{entry.Lexeme} = _AX");
}
else
{
Expr(ref Eplace);
intermediateCodeGenerator.GenerateFinalExpression(entry, Eplace, ref code);
intermediateCodeGenerator.Emit(code);
}
}
else
{
// undeclared lexeme
}
}
private void MoreTerm(ref ISymbolTableEntry Rplace)
{
string code = "";
string tempVarName = "";
ISymbolTableEntry Tplace = null;
if (token == Token.addopt)
{
intermediateCodeGenerator.CreateTempVariable(ref tempVarName, Rplace);
intermediateCodeGenerator.GenerateThreeAddressCodeSegment(ref code, tempVarName, Rplace);
//tempVars.Push(temporaryVariable);
AddOp();
//stack.Push(code);
Term(ref Tplace);
//code = stack.Pop();
code += Tplace.OffsetNotation;
string value = Rplace.OffsetNotation;
if (tempVarName != Rplace.OffsetNotation)
{
Rplace.OffsetNotation = tempVarName;
}
else
{
Rplace.OffsetNotation = value;
}
intermediateCodeGenerator.Emit(ref code);
MoreTerm(ref Rplace);
}
}
/// <summary>
/// The ClassDeclaration method for the Syntax Analyzer.
/// </summary>
private void ClassDeclaration()
{
Match(Token.classt);
ISymbolTableEntry entry = symbolTable.CreateTableEntry(EntryType.tableEntry);
context = EntryType.classEntry;
Match(Token.idt);
if (token == Token.extendst)
{
Match(Token.extendst);
Match(Token.idt);
}
Match(Token.lcurlyt);
depth++;
VariableDeclaration();
offset = 0;
MethodDeclaration();
Match(Token.rcurlyt);
symbolTable.ConvertEntryToClassEntry(entry);
sizeOfLocalVariables = 0;
listOfVariableNames.Clear();
listOfMethodNames.Clear();
//symbolTable.WriteTable(depth);
//symbolTable.DeleteDepth(depth);
depth--;
}
/// <summary>
/// The IdentifierList method for the Syntax Analyzer.
/// </summary>
private void IdentifierList()
{
ISymbolTableEntry entry = symbolTable.CreateTableEntry(EntryType.tableEntry);
if (context == EntryType.classEntry)
{
listOfVariableNames.Add(lexeme.ToString());
sizeOfLocalVariables += size;
}
else
{
sizeOfLocalMethodVariables += size;
}
BpOffsetNotation = $"_BP-{offset}";
symbolTable.ConvertEntryToVariableEntry(intermediateCodeGenerator, entry, false);
offset += (int)dataType;
Match(Token.idt);
if (token == Token.commat)
{
Match(Token.commat);
IdentifierList();
}
else if (token == Token.idt)
{
ExceptionHandler.ThrowUnexpectedTokenException(Token.commat);
}
else if (token != Token.semit)
{
ExceptionHandler.ThrowUnexpectedTokenException(Token.semit);
}
}
/// <summary>
/// The FormalRest method for the Syntax Analyzer.
/// </summary>
private void FormalRest()
{
if (token == Token.commat)
{
Match(Token.commat);
if (Types.Contains(token))
{
Type();
ISymbolTableEntry entry = symbolTable.CreateTableEntry(EntryType.tableEntry);
BpOffsetNotation = $"_BP+{sizeOfFormalParameters}";
sizeOfFormalParameters += size;
numOfParameters++;
parameterType.Add(dataType);
Match(Token.idt);
symbolTable.ConvertEntryToVariableEntry(intermediateCodeGenerator, entry, true);
FormalRest();
offset += (int)dataType;
}
}
else if (token != Token.rparentt)
{
ExceptionHandler.ThrowUnexpectedTokenException(Token.commat);
}
}
public void GenerateTempExpressionTAC(ref ISymbolTableEntry Tplace)
{
string tempVarName = "";
CreateTempVariable(ref tempVarName, Tplace);
Emit($"{tempVarName} = {Tplace.OffsetNotation}");
Tplace.OffsetNotation = tempVarName;
}
/// <summary>
/// Checks the symbol table for a duplicate entry at the same depth.
/// </summary>
/// <returns></returns>
private void CheckDuplicates()
{
ISymbolTableEntry duplicateEntryFound = symbolTable[Hash(lexeme.ToString())].FirstOrDefault(duplicate => duplicate.Lexeme == lexeme.ToString() && duplicate.Depth == depth);
if (duplicateEntryFound != null)
{
ExceptionHandler.ThrowDuplicateIdentifierException(lexeme.ToString());
}
}
/// <summary>
/// The MethodDeclaration method for the Syntax Analyzer.
/// </summary>
private void MethodDeclaration()
{
ISymbolTableEntry Eplace = null;
if (token == Token.publict)
{
Match(Token.publict);
if (Types.Contains(token))
{
Type();
context = EntryType.methodEntry;
ISymbolTableEntry entry = symbolTable.CreateTableEntry(EntryType.tableEntry);
intermediateCodeGenerator.Emit($"proc {entry.Lexeme}");
listOfMethodNames.Add(lexeme.ToString());
returnType = dataType;
Match(Token.idt);
Match(Token.lparentt);
depth++;
sizeOfFormalParameters = 4;
FormalList();
Match(Token.rparentt);
Match(Token.lcurlyt);
offset = 2; //TODO
intermediateCodeGenerator.tempVariableOffset = offset;
VariableDeclaration();
//temporaryVariableCounter = offset - 2;
SequenceOfStatements();
//temporaryVariableCounter = 0;
Match(Token.returnt);
Expr(ref Eplace);
Match(Token.semit);
Match(Token.rcurlyt);
symbolTable.ConvertEntryToMethodEntry(entry);
intermediateCodeGenerator.Emit($"endp {entry.Lexeme}");
parameterType.Clear();
numOfParameters = 0;
sizeOfLocalMethodVariables = 0;
sizeOfFormalParameters = 0;
symbolTable.WriteTable(depth);
symbolTable.DeleteDepth(depth);
depth--;
MethodDeclaration();
}
else
{
ExceptionHandler.ThrowCustomMessageException("return type");
}
}
else if (token != Token.rcurlyt)
{
ExceptionHandler.ThrowUnexpectedTokenException(Token.publict);
}
}
private void Expr(ref ISymbolTableEntry Eplace)
{
ISymbolTableEntry Tplace = null;
if (FactorTokens.Contains(token))
{
Relation(ref Tplace);
Eplace = Tplace;
}
}
/// <summary>
/// Method that converts a table entry to a class entry.
/// </summary>
/// <param name="tableEntry"></param>
public void ConvertEntryToClassEntry(ISymbolTableEntry tableEntry)
{
Class entry = tableEntry as SymbolTableEntry;
entry.SizeOfLocalVariables = sizeOfLocalVariables;
entry.ListOfVariableNames = listOfVariableNames;
entry.ListOfMethodNames = listOfMethodNames;
entry.TypeOfEntry = EntryType.classEntry;
Insert(entry);
/* Use for testing: DisplayClassEntry(entry); */
}
/// <summary>
/// Method that converts a table entry to a const double entry.
/// </summary>
/// <param name="tableEntry"></param>
public void ConvertEntryToConstantEntry(ISymbolTableEntry tableEntry, dynamic value)
{
Constant entry = tableEntry as SymbolTableEntry;
entry.Value = value;
entry.TypeOfConst = dataType;
entry.Offset = offset;
entry.TypeOfEntry = EntryType.constEntry;
entry.OffsetNotation = BpOffsetNotation;
Insert(entry);
/* Use for testing: DisplayConstDoubleEntry(entry); */
}
/// <summary>
/// Method that converts a table entry to a method entry.
/// </summary>
/// <param name="tableEntry"></param>
public void ConvertEntryToMethodEntry(ISymbolTableEntry tableEntry)
{
Method entry = tableEntry as SymbolTableEntry;
entry.SizeOfLocalVariables = sizeOfLocalMethodVariables;
entry.SizeOfFormalParameters = sizeOfFormalParameters;
entry.NumberOfParameters = numOfParameters;
entry.ReturnType = returnType;
entry.ParameterType = parameterType;
entry.TypeOfEntry = EntryType.methodEntry;
Insert(entry);
/* Use for testing: DisplayMethodEntry(entry); */
}
/// <summary>
/// The VariableDeclaration method for the Syntax Analyzer.
/// </summary>
private void VariableDeclaration()
{
if (token == Token.finalt)
{
Match(Token.finalt);
if (Types.Contains(token))
{
Type();
ISymbolTableEntry entry = symbolTable.CreateTableEntry(EntryType.tableEntry);
if (context == EntryType.classEntry)
{
listOfVariableNames.Add(lexeme.ToString());
sizeOfLocalVariables += size;
}
else
{
sizeOfLocalMethodVariables += size;
}
Match(Token.idt);
Match(Token.assignopt);
BpOffsetNotation = $"_BP-{offset}";
if (value != null)
{
symbolTable.ConvertEntryToConstantEntry(entry, value);
}
else if (valueR != null)
{
symbolTable.ConvertEntryToConstantEntry(entry, valueR);
}
offset += (int)dataType;
Match(Token.numt);
Match(Token.semit);
VariableDeclaration();
}
else
{
ExceptionHandler.ThrowCustomMessageException("return type");
}
}
else if (Types.Contains(token))
{
Type();
IdentifierList();
Match(Token.semit);
VariableDeclaration();
}
}
/// <summary>
/// Inserts the lexemes, token, and depth into a record in the symbol table.
/// </summary>
public void Insert(ISymbolTableEntry symbolTableEntry)
{
uint hashIndex = Hash(symbolTableEntry.Lexeme);
if (symbolTableEntry.TypeOfEntry != EntryType.tableEntry)
{
int index = symbolTable[hashIndex].FindIndex(tableEntry => tableEntry.Lexeme == symbolTableEntry.Lexeme && tableEntry.Depth == symbolTableEntry.Depth);
symbolTable[hashIndex][index] = symbolTableEntry;
}
else
{
symbolTable[hashIndex].Insert(0, symbolTableEntry);
}
}
/// <summary>
/// The MainClass method for the Syntax Analyzer.
/// </summary>
private void MainClass()
{
Match(Token.finalt);
Match(Token.classt);
ISymbolTableEntry entry = symbolTable.CreateTableEntry(EntryType.tableEntry);
Match(Token.idt);
Match(Token.lcurlyt);
depth++;
Match(Token.publict);
Match(Token.statict);
Match(Token.voidt);
context = EntryType.methodEntry;
ISymbolTableEntry mainEntry = symbolTable.CreateTableEntry(EntryType.tableEntry);
intermediateCodeGenerator.Emit($"proc {mainEntry.Lexeme}");
listOfMethodNames.Add(lexeme.ToString());
returnType = DataType.voidType;
Match(Token.maint);
Match(Token.lparentt);
depth++;
Match(Token.Stringt);
Match(Token.lbrackt);
Match(Token.rbrackt);
Match(Token.idt);
Match(Token.rparentt);
Match(Token.lcurlyt);
SequenceOfStatements();
Match(Token.rcurlyt);
intermediateCodeGenerator.Emit($"endp {mainEntry.Lexeme}");
symbolTable.WriteTable(depth);
symbolTable.DeleteDepth(depth);
depth--;
Match(Token.rcurlyt);
symbolTable.ConvertEntryToClassEntry(entry);
sizeOfLocalVariables = 0;
listOfVariableNames.Clear();
listOfMethodNames.Clear();
symbolTable.WriteTable(depth);
symbolTable.DeleteDepth(depth);
depth--;
}
public void CreateTempVariable(ref string tempVarName, ISymbolTableEntry entry)
{
Variable var = entry as Variable;
tempVarName = $"_bp-{sizeOfLocalMethodVariables + tempVariableOffset}";
if (var != null)
{
tempVariableOffset += 2;
}
//if (var != null && var.TypeOfEntry != EntryType.tableEntry)
//{
// tempVariableOffset += 2;
//}
//else
//{
// CalculateSize();
//}
}
/// <summary>
/// The FormalList method for the Syntax Analyzer.
/// </summary>
private void FormalList()
{
if (Types.Contains(token))
{
Type();
offset = 0;
ISymbolTableEntry entry = symbolTable.CreateTableEntry(EntryType.tableEntry);
BpOffsetNotation = $"_BP+{sizeOfFormalParameters}";
sizeOfFormalParameters += size;
numOfParameters++;
parameterType.Add(dataType);
Match(Token.idt);
symbolTable.ConvertEntryToVariableEntry(intermediateCodeGenerator, entry, true);
FormalRest();
offset += (int)dataType;
}
}
private void MethodCall()
{
Match(Token.idt);
Match(Token.periodt);
ISymbolTableEntry entry = symbolTable.Lookup(lexeme.ToString());
if (entry != null)
{
if (entry.TypeOfEntry == EntryType.methodEntry)
{
Match(Token.idt);
Match(Token.lparentt);
Params();
if (referenceParameters.Count > 0)
{
for (int i = referenceParameters.Count - 1; i >= 0; i--)
{
ISymbolTableEntry tableEntry = symbolTable.Lookup(referenceParameters[i]);
Variable parameterEntry = tableEntry as Variable;
intermediateCodeGenerator.Emit($"push {parameterEntry.OffsetNotation}");
}
referenceParameters.Clear();
}
intermediateCodeGenerator.Emit($"call {entry.Lexeme}");
Match(Token.rparentt);
}
else
{
ExceptionHandler.ThrowUndeclaredIdentifierException(lexeme.ToString());
}
}
else
{
ExceptionHandler.ThrowUndeclaredIdentifierException(lexeme.ToString());
}
}
///// <summary>
///// Method that converts a table entry to a const int entry.
///// </summary>
///// <param name="tableEntry"></param>
//public void ConvertEntryToIntConstantEntry(ISymbolTableEntry tableEntry)
//{
// Constant<int?> entry = tableEntry as SymbolTableEntry;
// entry.Value = value;
// entry.TypeOfConst = dataType;
// entry.Offset = offset;
// entry.TypeOfEntry = EntryType.constEntry;
// entry.OffsetNotation = BpOffsetNotation;
// Insert(entry);
// /* Use for testing: DisplayConstIntEntry(entry); */
//}
/// <summary>
/// Method that converts a table entry to a var entry.
/// </summary>
/// <param name="tableEntry"></param>
public void ConvertEntryToVariableEntry(IntermediateCodeGenerator intermediateCodeGenerator, ISymbolTableEntry tableEntry, bool isParameter)
{
Variable entry = tableEntry as SymbolTableEntry;
entry.TypeOfVariable = dataType;
entry.Offset = offset;
entry.OffsetNotation = BpOffsetNotation;//isParameter ? intermediateCodeGenerator.CalculateParameterOffsetNotation(entry) : intermediateCodeGenerator.CalculateLocalVariableOffsetNotation(entry);
entry.Size = size;
entry.TypeOfEntry = EntryType.varEntry;
entry.OffsetNotation = BpOffsetNotation;
Insert(entry);
/* Use for testing: DisplayVariableEntry(entry); */
}
public void GenerateFinalExpression(ISymbolTableEntry entry, ISymbolTableEntry Eplace, ref string code)
{
code = $"{entry.OffsetNotation} = {Eplace.OffsetNotation}";
Emit(ref code);
}
private void Term(ref ISymbolTableEntry Tplace)
{
Factor(ref Tplace);
MoreFactor(ref Tplace);
}
private void SimpleExpr(ref ISymbolTableEntry Tplace)
{
Term(ref Tplace);
//Rplace = Tplace;
MoreTerm(ref Tplace);
}
private void Relation(ref ISymbolTableEntry Tplace)
{
SimpleExpr(ref Tplace);
}
private void Factor(ref ISymbolTableEntry Tplace)
{
if (token == Token.idt)
{
//Tplace = symbolTable.Lookup(lexeme.ToString()) as Variable;
ISymbolTableEntry Xplace = symbolTable.Lookup(lexeme.ToString());
if (Xplace.TypeOfEntry == EntryType.constEntry)
{
Tplace = Xplace as Constant;
}
else
{
Tplace = Xplace as Variable;
}
if (Tplace != null)
{
Match(Token.idt);
}
else
{
// lexeme is undeclared
}
}
else if (token == Token.numt)
{
Tplace = new Variable();
Tplace.OffsetNotation = lexeme.ToString();
intermediateCodeGenerator.GenerateTempExpressionTAC(ref Tplace);
//Tplace.Lexeme = lexeme.ToString();
Match(Token.numt);
}
else if (token == Token.lparentt)
{
Match(Token.lparentt);
Expr(ref Tplace);
Match(Token.rparentt);
}
else if (token == Token.negateopt)
{
Match(Token.negateopt);
Factor(ref Tplace);
}
else if (token == Token.addopt && lexeme.ToString() == "-")
{
string code = "";
string tempVarName = "";
Tplace = new Variable();
Tplace.TypeOfEntry = EntryType.varEntry;
Tplace.OffsetNotation = "0";
intermediateCodeGenerator.CreateTempVariable(ref tempVarName, Tplace);
intermediateCodeGenerator.GenerateThreeAddressCodeSegment(ref code, tempVarName, Tplace);
SignOp();
Factor(ref Tplace);
code += Tplace.OffsetNotation;
Tplace.OffsetNotation = tempVarName;
intermediateCodeGenerator.Emit(ref code);
}
else if (token == Token.truet)
{
Match(Token.truet);
}
else if (token == Token.falset)
{
Match(Token.falset);
}
else
{
ExceptionHandler.ThrowInvalidExpressionException(lexeme.ToString());
}
}
public void GenerateThreeAddressCodeSegment(ref string code, string tempVarName, ISymbolTableEntry Rplace)
{
code = $"{tempVarName} = {Rplace.OffsetNotation} {lexeme.ToString()} ";
}
