// Display token header to screen and output file
public void DisplayTokenHeader()
{
string[] headingData = new string[] { "Lexeme", "Token", "Attribute" };
string headerRule = Environment.NewLine + new string('-', 79);
CommonTools.WriteOutput(string.Format(OutputFormat, headingData) + headerRule);
}
// Helper function to write given list of nodes to screen
private void WriteNodes(IEnumerable <Node> nodeList)
{
foreach (Node node in nodeList)
{
string[] outputData = new string[] { node.Lexeme, node.GetClass(), node.Depth.ToString() };
CommonTools.WriteOutput(string.Format(OutputFormat, outputData));
}
}
// Display detailed table header to screen and output file
private void DisplayDetailedSymbolTableHeader(int depth)
{
CommonTools.WriteOutput($"** Symbol Table at Depth {depth} **");
string[] headingData = new string[] { "Lexeme", "Class", "Depth", "Offset", "Type", "Size", "Value(r)" };
string headerRule = Environment.NewLine + new string('-', 80);
CommonTools.WriteOutput(string.Format(OutputDetailedFormat, headingData) + headerRule);
}
// Display symbol table header to screen and output file
private void DisplaySymbolTableHeader(int depth)
{
CommonTools.WriteOutput($"** Symbol Table at Depth {depth} **");
string[] headingData = new string[] { "Lexeme", "Class", "Depth" };
string headerRule = Environment.NewLine + new string('-', 75);
CommonTools.WriteOutput(string.Format(OutputFormat, headingData) + headerRule);
}
// Helper function to output data for functions
private void OutputDetailedConstant(Node node)
{
ConstantNode outputNode = (ConstantNode)node;
var outputValue = outputNode.Value ?? outputNode.ValueReal;
string[] outputData = new string[] { outputNode.Lexeme, outputNode.GetClass(), outputNode.Depth.ToString(),
"-", "-", "-", outputValue.ToString() };
CommonTools.WriteOutput(string.Format(OutputDetailedFormat, outputData));
}
// Helper function to output data for variables
private void OutputDetailedVariable(Node node)
{
VariableNode outputNode = (VariableNode)node;
string[] outputData = new string[] { outputNode.Lexeme, outputNode.GetClass(), outputNode.Depth.ToString(),
outputNode.Offset.ToString(), outputNode.Type.ToString(),
outputNode.Size.ToString(), "-" };
CommonTools.WriteOutput(string.Format(OutputDetailedFormat, outputData));
}
// Validates that a single comman line argument exists and its path is valid
private static bool ValidateArguments(string[] arguments)
{
if (arguments.Length == 1)
{
return(CommonTools.CheckFilePathExists(arguments[0]));
}
CommonTools.WriteOutput("ERROR: Usage expected 1 command line argument");
return(false);
}
private bool CheckMainDeclared()
{
if (!(SymbolTable.LookupNode("main") is FunctionNode))
{
CommonTools.WriteOutput("ERROR: No required function \"main\" exists");
return(false);
}
OutputThreeAddressCode("START PROC main");
return(true);
}
// Display next token to screen and output file
public void DisplayCurrentToken()
{
if (Token != Token.EndOfFileToken)
{
dynamic attribute = Value ?? ValueReal;
attribute = attribute ?? Literal;
string[] outputData = new string[] { Lexeme, Token.ToString(), attribute.ToString() };
CommonTools.WriteOutput(string.Format(OutputFormat, outputData));
}
}
// Displays given depth's detailed symbol table information to output
public void OutputDetailedSymbolTable(int depth)
{
DisplayDetailedSymbolTableHeader(depth);
foreach (LinkedList <Node> nodeList in HashTable)
{
if (nodeList != null)
{
WriteDetailedNodes(nodeList.Where(item => item.Depth == depth));
}
}
CommonTools.WriteOutput(Environment.NewLine);
}
// Process a comment token
private void SkipComment()
{
while (Character != Char.MinValue)
{
GetNextCharacter();
if (CommentEndSearch())
{
return;
}
}
CommonTools.WriteOutput("ERROR: Expected comment end '*/' not found");
}
// Displays given depth/scope level to output
public void OutputSymbolTable(int depth)
{
if (CommonTools.SemanticAnalysisDebug && !CommonTools.ThreeAddressCodeRun)
{
OutputDetailedSymbolTable(depth);
return;
}
if (!CommonTools.ParserDebug && !CommonTools.ThreeAddressCodeRun)
{
DisplaySymbolTableHeader(depth);
WriteNodes(GetSymbolTableDepth(depth));
CommonTools.WriteOutput(Environment.NewLine);
}
}
// Helper function to output data for functions
private void OutputDetailedFunction(Node node)
{
string[] outputData;
FunctionNode outputNode = (FunctionNode)node;
outputData = new string[] { outputNode.Lexeme, outputNode.GetClass(), outputNode.Depth.ToString(),
"-", outputNode.ReturnType.ToString(), outputNode.LocalsSize.ToString(), "-" };
CommonTools.WriteOutput(string.Format(OutputDetailedFormat, outputData));
foreach (ParameterNode item in outputNode.Parameters)
{
outputData = new string[] { "-", "Parameter", "-", "-", item.Type.ToString(), "-", "-" };
CommonTools.WriteOutput(string.Format(OutputDetailedFormat, outputData));
}
}
public bool Start()
{
bool programCorrect = ProcessProgram() && CheckMainDeclared();
if (LexicalAnaylzer.Token != Token.EndOfFileToken && programCorrect)
{
CommonTools.PromptProgramErrorExit(
$"ERROR: Line {LexicalAnaylzer.LineNumber} " +
$"Unexpected tokens in source file, expected End-of-File Token");
}
if ((CommonTools.ThreeAddressCodeRun) && programCorrect)
{
CommonTools.WriteOutput(ThreeAddressCodeOutput);
}
return(programCorrect);
}
// Initializes and runs Parser module
public static void StartParser(string[] arguments)
{
ValidateArguments(arguments);
CommonTools.SetupOutputs(new string[] { GlobalConfiguration.ParserOutputPath });
CommonTools.ClearOutputDisplays();
LexicalAnalyzer lexicalAnalyzer = new LexicalAnalyzer(arguments[0]);
lexicalAnalyzer.GetNextToken();
SymbolTable symbolTable = new SymbolTable();
Parser parser = new Parser(lexicalAnalyzer, symbolTable);
if (parser.Start())
{
symbolTable.OutputSymbolTable(1);
}
CommonTools.WriteOutput($"Completed processing {Path.GetFileName(arguments[0])}");
CommonTools.PromptProgramExit();
}
// Writes given array of outputs to screen at index columns
public void OutputAssembly(string[] outputs)
{
CommonTools.WriteOutput(string.Format(OutputFormat, outputs));
}
