public override void CheckSemantic(Scope scope, List<Error> errors)
{
int count = errors.Count();
Id.CheckSemantic(scope, errors);
lval = (TigerNode)Id;
GetLValues(Access, ref lval);
count = errors.Count();
lval.CheckSemantic(scope, errors);
if (count == errors.Count())
ReturnType = lval.ReturnType;
}
public void GetLValues(List<Access> access,ref TigerNode l)
{
if (access.Count() != 0)
{
if (access[0] is AccessArray)
{
AccessArray elem_array = (AccessArray)access[0];
access.RemoveAt(0);
//LValueNode temp = l;
l = new ElemArrayNode(elem_array.Index, l);
GetLValues(access,ref l);
}
else
{
AccessRecord field_record = (AccessRecord)access[0];
access.RemoveAt(0);
//LValueNode temp=l;
l = new FieldRecordNode(field_record.Field, l);
GetLValues(access,ref l);
}
}
return;
}
public WhileNode(TigerNode exprWhile, TigerNode exprDo)
{
ExprWhile = exprWhile; ExprDo = exprDo;
}
public AccessArray(TigerNode index)
{
Index = index;
}
public OrNode(TigerNode expr1,TigerNode expr2)
: base(expr1,expr2)
{
}
public GreaterEqualThanNode(TigerNode expr1,TigerNode expr2)
: base(expr1,expr2)
{
}
public BinaryOpNode(TigerNode expr1, TigerNode expr2)
{
LeftOperand = expr1; RigthOperand = expr2;
}
public IfThenNode(TigerNode exprIf, TigerNode exprThen)
{
ExprIf = exprIf; ExprThen = exprThen;
}
public ElemArrayNode(TigerNode index, TigerNode expr)
{
Expr = expr; Index = index;
}
public ArrayNode(string name, TigerNode length, TigerNode value)
{
Name = name; Length = length; Value = value;
}
public ForNode(string idLoop,TigerNode exprFor, TigerNode exprTo, TigerNode exprDo)
{
ExprFor = exprFor; ExprTo = exprTo; ExprDo = exprDo; IdLoop = idLoop;
}
public MinusUnaryNode(TigerNode expr)
{
Expr = expr;
}
public DistinctNode(TigerNode expr1,TigerNode expr2)
: base(expr1,expr2)
{
}
public LogicOpNode(TigerNode expr1, TigerNode expr2)
: base(expr1, expr2)
{
}
public VariableDeclNode(string id, string type, TigerNode expr)
{
IdVar = id; Expr = expr; IdType = type;
}
public ArithmeticOpNode(TigerNode expr1,TigerNode expr2)
: base(expr1,expr2)
{
}
public VariableDeclNode(string id, TigerNode expr)
: this(id, "", expr)
{
}
public IfThenElseNode(TigerNode exprIf, TigerNode exprThen, TigerNode exprElse)
{
ExprIf = exprIf; ExprElse = exprElse; ExprThen = exprThen;
}
public FunctionDeclNode(string idFunction, string idType, List<Parameter> parameters, TigerNode expr)
{
IdFunction = idFunction; IdType = idType; Expr = expr; Parameters = parameters;
}
public MinusNode(TigerNode expr1,TigerNode expr2)
: base(expr1,expr2)
{
}
public FunctionDeclNode(string idFunction, List<Parameter> parameters, TigerNode expr)
: this(idFunction, "void", parameters, expr)
{
}
public RelationalOpNode(TigerNode expr1,TigerNode expr2)
: base(expr1,expr2)
{
}
public List<Error> Compile(string inputPath)
{
this.inputpath = inputPath;
root = null;
stream = new ANTLRFileStream(inputpath);
lexer = new tiger_grammarLexer(stream);
tokens = new CommonTokenStream(lexer);
parser = new tiger_grammarParser(tokens);
try
{
var result = parser.language();
root = result;
if (parser.Errors.Count() == 0)
{
Errors.Clear();
Scope scope = new Scope(null);
scope.InitiScope();
root.CheckSemantic(scope, Errors);
if (Errors.Count() == 0)
{
GenCode(root);
}
}
else
{
Errors.Clear();
foreach (var item in parser.Errors)
{
Errors.Add(new Error(0,0,item));
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.ReadLine();
}
return Errors;
}
public EqualNode(TigerNode expr1,TigerNode expr2)
: base(expr1,expr2)
{
}
public void GenCode(TigerNode root)
{
Initialize();
if (root == null) throw new Exception(" Fatal Error");
if (Errors.Count == 0)
{
GeneratePredefinitedFunction();
MethodBuilder methodBuilder = typeBuilder.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.Static, typeof(void), Type.EmptyTypes);
asmBluider.SetEntryPoint(methodBuilder, PEFileKinds.ConsoleApplication);
ILGenerator cg = methodBuilder.GetILGenerator();
root.GenCode(typeBuilder, methodBuilder, cg);
if (root is InstructionNode && root.ReturnType.BaseType.Name != "void")
{
cg.Emit(OpCodes.Pop);
}
cg.EmitWriteLine("\n The program finish successfully");
cg.EmitWriteLine("\n Enter for to continue...");
cg.EmitCall(OpCodes.Call, typeof(Console).GetMethod("ReadLine"), null);
cg.Emit(OpCodes.Pop);
cg.Emit(OpCodes.Ret);
typeBuilder.CreateType();
string filename = inputpath.Substring(inputpath.LastIndexOf('\\') + 1);
string namef = filename.Split('.')[0];
asmBluider.Save(namef + ".exe");
System.Diagnostics.Process.Start(namef + ".exe");
}
}
public AssingmentNode(TigerNode left, TigerNode rigth)
{
LeftExpr = left; RigthExpr = rigth;
}
public LessEqualThanNode(TigerNode expr1,TigerNode expr2)
: base(expr1,expr2)
{
}
public FieldRecordNode(string field,TigerNode expr)
{
Field = field; Expr = expr;
}
public ListLValueNode(TigerNode id,List<Access> access)
{
Id = id;
Access = access;
lval = null;
}
