/************************/
/*** Public Functions ***/
/************************/
public void Add(ProgNode argument)
{
if (argument != null)
{
argList.Add(argument);
}
}
public void Add(ProgNode node)
{
if (node != null)
{
nodeList.Add(node);
}
}
public override void Visit(ProgNode node)
{
CSharpString.Append("using System;");
PrettyPrintNewLine();
CSharpString.Append("using System.Collections.Generic;");
PrettyPrintNewLine();
CSharpString.Append("using System.Linq;");
PrettyPrintNewLine();
CSharpString.Append("using System.Text;");
PrettyPrintNewLine();
CSharpString.Append("public class Program__");
PrettyPrintNewLine();
CSharpString.Append("{");
IndentationLevel++;
PrettyPrintNewLine();
GenerateStandardFunctions();
foreach (TopDclNode DclNode in node.TopDclNodes)
{
CSharpString.Append("public ");
DclNode.Accept(this);
PrettyPrintNewLine();
}
IndentationLevel--;
PrettyPrintNewLine();
CSharpString.Append("}");
}
public CodeGenVisitor(ProgNode node, IScope Scope)
{
this.Scope = Scope;
ClassManager = new ClassMgr(Scope);
VariableManager = new ThreeAddressHandler();
Code = new List <CodeLine>();
VariableManager.PushVariableCounter();
StepOne();
VariableManager.PopVariableCounter();
node.Accept(this);
VariableManager.PushVariableCounter();
Code.Add(new LabelCodeLine("start"));
int size = ClassManager.GetClassSize("Main");
Code.Add(new AllocateCodeLine(VariableManager.PeekVariableCounter(), size));
Code.Add(new PushParamCodeLine(VariableManager.PeekVariableCounter()));
Code.Add(new CallLblCodeLine(new LabelCodeLine("Main", "constructor")));
Code.Add(new PopParamCodeLine(1));
Code.Add(new PushParamCodeLine(VariableManager.PeekVariableCounter()));
Code.Add(new CallLblCodeLine(new LabelCodeLine("Main", "main")));
Code.Add(new PopParamCodeLine(1));
VariableManager.PopVariableCounter();
}
public ProgNode Check(ProgNode node, List <string> errors, IScope scope)
{
this.errors = errors;
this.scope = scope;
node.Accept(this);
return(node);
}
public void Add(ProgNode node)
{
if (node != null)
{
arguments.Add(node);
}
}
/**************************/
/*** Override Functions ***/
/**************************/
public override ProgNode Interpret(Script script)
{
ProgNodeDeclare command = new ProgNodeDeclare();
Token varName = new Token();
Token nextToken = new Token();
while (!nextToken.IsEos())
{
ProgNode expression = null;
varName = script.GetToken();
nextToken = script.GetToken();
if (nextToken.IsAssign())
{
expression = script.Expression();
nextToken = expression.EndingToken;
}
command.Delcare(varName, Type, new ProgNodeValue(1), expression);
}
return(command);
}
/*******************/
/*** Constructor ***/
/*******************/
public Declaration(string name, SymbolTableRecType type, ProgNode size, ProgNode initialize)
{
Name = name;
Type = type;
Size = size;
Initialize = initialize;
}
public override ProgNode Interpret(Script script)
{
ProgNode expression = script.Expression();
ProgNode codeBlock = script.ReadCodeBlock();
return(new ProgNodeWhile(expression, codeBlock));
}
/*******************/
/*** Constructor ***/
/*******************/
public ProgNodeBinaryOper(ProgNode leftExp, ProgNode rightExp)
{
this.leftExp = leftExp;
this.rightExp = rightExp;
this.boxing = new int[NUMBER_OF_SCRIPT_TYPES, NUMBER_OF_SCRIPT_TYPES];
InitBoxing();
}
public override ProgNode Interpret(Script script)
{
Token eos = script.GetToken();
ProgNode codeBlock = script.ReadCodeBlock();
return(codeBlock);
}
public override void Visit(ProgNode node)
{
foreach (TopDclNode DclNode in node.TopDclNodes)
{
DclNode.Accept(this);
PrettyPrintNewLine();
}
}
public void Visit(ProgNode node)
{
List <ClassNode> sorted = new List <ClassNode>();
sorted.AddRange(node.classes);
sorted.Sort((x, y) => (Scope.GetType(x.type.Text) <= Scope.GetType(y.type.Text) ? 1 : -1));
foreach (var @class in sorted)
{
ClassManager.DefineClass(@class.type.Text);
List <PropertyNode> properties = new List <PropertyNode>();
List <MethodNode> methods = new List <MethodNode>();
foreach (var feature in @class.features)
{
if (feature is PropertyNode)
{
properties.Add(feature as PropertyNode);
}
else
{
methods.Add(feature as MethodNode);
}
}
foreach (var method in methods)
{
List <string> params_type = new List <string>();
foreach (var x in method.paramsFormal)
{
params_type.Add(x.type.Text);
}
ClassManager.DefineMethod(@class.type.Text, method.id.text, params_type);
}
foreach (var property in properties)
{
ClassManager.DefineProperty(@class.type.Text, property.formal.id.text, property.formal.type.Text);
}
}
foreach (var @class in sorted)
{
@class.Accept(this);
}
}
public ProgNode ReadCodeBlock()
{
ProgNodeExec codeBlock = new ProgNodeExec();
ProgNode command = GetCommand();
while ((command != null) && (!command.IsEndOfCodeBlock))
{
codeBlock.Add(command);
command = GetCommand();
}
return(codeBlock);
}
/*******************/
/*** Constructor ***/
/*******************/
public Script(Parser parser)
{
this.parser = parser;
while (!parser.IsEof())
{
ProgNode node = GetCommand();
if (!errorSwitch)
{
ProgNodeContext context = new ProgNodeContext();
node.Evaluate(context);
}
}
}
private void PopOperStack(Stack <Token> operStack, Stack <ProgNode> varStack)
{
ProgNode node = null;
ProgNode right = varStack.Pop();
ProgNode left = varStack.Pop();
TokenType type = operStack.Pop().GetDataType();
switch (type)
{
case TokenType.PLUS:
node = new ProgNodePlus(left, right);
break;
case TokenType.MULTIPLY:
node = new ProgNodeMultiply(left, right);
break;
case TokenType.MINUS:
node = new ProgNodeMinus(left, right);
break;
case TokenType.DIVIDE:
node = new ProgNodeDivide(left, right);
break;
case TokenType.POWER:
node = new ProgNodePower(left, right);
break;
case TokenType.MODULUS:
node = new ProgNodeMod(left, right);
break;
case TokenType.LT:
case TokenType.LE:
case TokenType.GT:
case TokenType.GE:
case TokenType.NE:
node = new ProgNodeLogicalOper(type, left, right);
break;
}
varStack.Push(node);
}
private static bool CheckSemantic(ProgNode program, Scope scope)
{
var errors = new List <string>();
var programnode = new FirstSemanticVisit().Check(program, errors, scope);
if (SemanticAlgorithm.ReportError(errors))
{
return(false);
}
programnode = new SemanticVisit().Check(programnode, errors, scope);
if (SemanticAlgorithm.ReportError(errors))
{
return(false);
}
return(true);
}
public ProgNode Expression()
{
Stack <Token> operStack = new Stack <Token>();
Stack <ProgNode> varStack = new Stack <ProgNode>();
operStack.Push(new Token(TokenType.BOTTOM_EXP_STACK));
Token token = parser.GetToken();
while (!token.IsEoe())
{
if (token.IsOperator())
{
PushOperOnStack(token, operStack, varStack);
}
else if (token.IsLeftParen())
{
PushLeftParen(token, operStack);
}
else if (token.IsRightParen())
{
PopLeftParen(operStack, varStack);
}
else
{
PushVarStack(token, varStack);
}
token = parser.GetToken();
}
// Pop the operator stack until the bottom is reached
//---------------------------------------------------
while (!operStack.Peek().IsBottomOfOperStack())
{
PopOperStack(operStack, varStack);
}
ProgNode value = varStack.Peek();
value.EndingToken = token;
return(value);
}
private ArgList GetArgList()
{
ArgList argList = null;
if (parser.IsSkipLeftBracket())
{
argList = new ArgList();
if (!parser.IsSkipRightBracket())
{
ProgNode argument = null;
do
{
argument = Expression();
argList.Add(argument);
} while (!argument.EndingToken.IsRightBacket());
}
}
return(argList);
}
static void Main(string[] args)
{
if (args.Length == 0)
{
return;
}
var input = new AntlrFileStream(args[0]);
var lexer = new CoolLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new CoolParser(tokens);
var tree = parser.program();
Context_to_AST astbuilder = new Context_to_AST();
ProgNode program = astbuilder.VisitProgram(tree) as ProgNode;
var scope = new Scope();
Console.WriteLine(CheckSemantic(program, scope));
Console.WriteLine("\n");
var code_visitor = new CodeGenVisitor(program, scope);
var code = code_visitor.GetIntermediateCode();
foreach (var line in code)
{
Console.WriteLine(line);
}
MIPSCodeGenerator generator = new MIPSCodeGenerator();
var mips = generator.GenerateCode(code);
Console.WriteLine(mips);
File.WriteAllText("result.mips", mips);
}
public ProgNode GetCommand()
{
ProgNode node = null;
string variable = parser.GetToken().GetString();
string keyword = variable.ToUpper();
ProgCmd command = parser.GetProgCmd(keyword);
if (command != null)
{
node = command.Interpret(this);
}
else
{
Token assignToken = parser.GetToken();
ProgNode expression = Expression();
node = new ProgNodeAssign(variable, expression);
}
return(node);
}
/************************/
/*** Public Functions ***/
/************************/
public void Delcare(Token variable, SymbolTableRecType type, ProgNode size, ProgNode initialize)
{
string name = variable.GetString();
variables.Add(new Declaration(name, type, size, initialize));
}
/*******************/
/*** Constructor ***/
/*******************/
public ProgNodeDivide(ProgNode leftExp, ProgNode rightExp)
: base(leftExp, rightExp)
{
}
public ProgNodePower(ProgNode leftExp, ProgNode rightExp)
: base(leftExp, rightExp)
{
}
internal abstract void Visit(ProgNode node);
public ProgNodeAssign(string variable, ProgNode expression)
{
this.variable = variable;
this.expression = expression;
}
/*******************/
/*** Constructor ***/
/*******************/
public ProgNodeMinus(ProgNode leftExp, ProgNode rightExp)
: base(leftExp, rightExp)
{
}
/*******************/
/*** Constructor ***/
/*******************/
public ProgNodeMultiply(ProgNode leftExp, ProgNode rightExp)
: base(leftExp, rightExp)
{
}
/*******************/
/*** Constructor ***/
/*******************/
public ProgNodeLogicalOper(TokenType type, ProgNode leftExp, ProgNode rightExp)
: base(leftExp, rightExp)
{
this.type = type;
}
public void Visit(ProgNode node)
{
//queda pasar los scope
node.classes.ForEach(x => x.Accept(new SemanticVisit(errors, x.Scope)));
}
