public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree) { var hasElse = tree.Count == 3; AsmLabel debElse = load.Optimum.SetLabel(null, false), finElse = load.Optimum.SetLabel(null, false); var condition = load.Compile(scop, tree[0]); if (condition == null || condition.Return != Assembly.Bool) { load.LogIn(scop, tree, condition, "Condition Value Must be Of Type System.Bool"); } load.Add("test", condition, FieldInfo.Immediate(0)); load.Optimum.SetGoto("jne", debElse); if (tree[1].GeneratedBy != null) { tree[1].GeneratedBy.Compile(load, scop, tree[1]); load.Optimum.SetLabel(debElse); if (!hasElse) { return(null); } load.Optimum.SetGoto("jmp", finElse); tree[2].GeneratedBy.Compile(load, scop, tree[2]); load.Optimum.SetLabel(finElse); } else { load.Optimum.SetLabel(debElse); } return(null); }
private static void ConvertToLong(LoadClasses load, FieldInfo f, bool left) { if (IsSigned(f)) { if (left) { load.Add("mov", RegInfo.eax, f); load.Add("cdq"); } else { load.Add("mov", RegInfo.ecx, f); load.Add("mov", RegInfo.ebx, RegInfo.ecx); load.Add("sar", RegInfo.ebx, new ConstInfo(Assembly.Byte, new[] { (byte)0x1F })); } } else if (left) { load.Add("mov", RegInfo.eax, f); load.Add("xor", RegInfo.edx, RegInfo.edx); } else { load.Add("mov", RegInfo.ecx, f); load.Add("xor", RegInfo.ebx, RegInfo.ebx); } }
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree) { if (tree.Count == 3 && tree[2].Kind == Kind.Numbre) { } var dataPortor = scop as DataPortor; var l = load.SetVariable(dataPortor, tree); tree[1].BaseCall = tree.BaseCall = dataPortor; tree[1].Type = tree.Type = l.Return; tree[1].Membre = tree.Membre = l; tree[1].Compiled = true; tree.Compiled = true; if (tree.Children.Count == 2) { return(null); } var fieldInfo = load.Compile(scop, tree[2]); if (l != fieldInfo) { load.Optimum.Assign(l, fieldInfo); } return(l); }
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree) { if (tree.Method == null) { tree.Method = load.GetMethod(tree[0], tree[1].Children); } if (tree.Method == null) { load.LogIn(scop, tree, this, "Function(" + tree[0].Content + ") Entrer cannot be found"); return(null); } if (tree.Method.ISCPUMethod) { var parm = new List <FieldInfo>(2); foreach (Tree e in tree[1]) { parm.Add(load.Compile(scop, e)); } } foreach (Tree e in tree[1]) { var z = load.Compile(scop, e); load.Optimum.PushParam(z); } load.Optimum.Call(tree.Method); return(tree.Membre = RegInfo.eax); }
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree) { if (!new TypeCalc(load.ByteCodeMapper).CalcTypes(tree)) { load.LogIn(scop, tree, this, "there are undefined variables or methods in expression : " + tree.Content); return(tree[0].Membre); } tree.Parcure(tree.Parent, (MethodInfo)scop); var m = load.Compile(scop, tree[0]); var n = tree.Count == 3 ? load.Compile(scop, tree[2]) : null; if (tree.Method is CPUMethodInfo) { var e = Qs.Pdb.CPU.CPUType.Call(load, scop, tree.Membre, tree.Method, tree[0].Membre, tree[2].Membre); //TODO :Obsolete load.Caller.Call(scop, tree.Method, m, n, tree.Membre); } else { load.Optimum.PushParam(m); if (n != null) { load.Optimum.PushParam(n); } load.Optimum.Call(tree.Method); } return(tree.Membre); }
public static FieldInfo Call(LoadClasses load, Scop scop, FieldInfo ret, MethodInfo method, FieldInfo l, FieldInfo r) { var cpuTypeL = instants[l.Return]; var cpuTypeR = instants[r.Return]; return((cpuTypeL.Index < cpuTypeR.Index ? cpuTypeL : cpuTypeR).BeginCompile(method, ret, l, r, load, scop)); }
internal static void pushParam(LoadClasses load, Operand l, bool first, bool signed, bool islong = true) { if (first) { load.Add("mov", Reg.eax, l); if (islong) { load.Add("mov", Reg.edx, l + 4); } else if (signed) { load.Add("cdq"); } else { load.Add("xor", Reg.edx, Reg.edx); } } else { load.Add("mov", Reg.ecx, l); if (signed) { load.Add("mov", Reg.ebx, Reg.ecx); load.Add("sar", RegInfo.ebx, c1F); } else { load.Add("xor", Reg.ebx, Reg.ebx); } } }
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree) { var ret = load.Compile(scop, tree[1]); //.GeneratedBy.Compile(load, scop, tree[0]); load.Return(scop, ret); return(null); }
internal void pushParam(LoadClasses load, Operand l, bool first, bool isigned, bool islong, bool iscpucall) { if (iscpucall) { pushParam(load, l, first, isigned, islong); } else //if (first) if (islong) { load.Add("push", l + 4); load.Add("push", l); } else if (isigned) { load.Add("mov", Reg.eax, l); load.Add("cdq"); load.Add("push", Reg.edx); load.Add("push", Reg.eax); } else { load.Add("xor", Reg.edx, Reg.edx); load.Add("push", Reg.edx); load.Add("push", l); } }
private static FieldInfo @return(LoadClasses load, FieldInfo ret) { var _ret = ret.Handle; load.Add("mov", _ret, Reg.eax); load.Add("mov", _ret + 4, Reg.eax); return(ret); }
public virtual FieldInfo Compile(LoadClasses load, Scop scop, Tree tree) { foreach (Tree t in tree) { t.GeneratedBy.Compile(load, scop, t); } return(null); }
protected override FieldInfo BeginCompile(MethodInfo method, FieldInfo ret, FieldInfo l, FieldInfo r, LoadClasses load, Scop scop) { switch (method.Name) { case "+": return(add(ret, l, r, load)); case "-": return(sub(ret, l, r, load)); case "*": case "/": return(mul(method, ret, l, r, load)); case "&": return(and(ret, l, r, load)); case "^": return(xor(ret, l, r, load)); case "|": return(or(ret, l, r, load)); case ">>": return(shr(method, ret, l, r, load)); case "<<": return(shl(method, ret, l, r, load)); case "++": return(inc(l, load)); case "--": return(dec(l, load)); case "==": return(eq_ne(ret, l, r, load, true)); case "!=": return(eq_ne(ret, l, r, load)); case ">=": return(lte_gte(ret, l, r, load, false)); case "<=": return(lte_gte(ret, l, r, load, true)); case ">": return(lt_gt(ret, l, r, load, false)); case "<": return(lt_gt(ret, l, r, load, true)); } return(ret); }
private static FieldInfo Compile(FieldInfo ret, FieldInfo l, FieldInfo r, LoadClasses load, string o, AsmLabel returnFalse, string oc, AsmLabel returnTrue, string cn, AsmLabel @return, bool orEqual, bool IsEquality = false) { PushParams(load, l, r); load.Add("cmp", RegInfo.edx, RegInfo.ebx); load.Optimum.SetGoto(o, returnFalse); if (!IsEquality) { load.Optimum.SetGoto(oc, returnTrue); } FPReturn(ret, load, cn, returnTrue, returnFalse, @return, orEqual); return(ret); }
private AsmLabel PushParams(FieldInfo l, FieldInfo r, LoadClasses load, out AsmLabel trueLabel, out AsmLabel returnLabel) { trueLabel = new AsmLabel("{asm3}"); returnLabel = new AsmLabel("{ret}" + CPUUInt.u); pushParam(load, l.Handle, true, IsSigned(l.Return), l.Return == Assembly.Long); if (r.Return != Assembly.Long) { pushParam(load, r.Handle, false, IsSigned(r.Return), false); } return(new AsmLabel("{asm1}")); }
internal static void call(LoadClasses load, string op, string cop, Operand r = null) { if (r == null) { load.Add(op, Reg.eax, Reg.ecx); load.Add(cop, Reg.edx, Reg.ebx); } else { load.Add(op, Reg.eax, r); load.Add(cop, Reg.edx, r + 4); } }
FieldInfo mul(MethodInfo method, FieldInfo ret, FieldInfo l, FieldInfo r, LoadClasses load) { var ol = l.Handle; var or = r.Handle; var rsigned = r.Return == Assembly.Int || r.Return == Assembly.Short; var lsigned = l.Return == Assembly.Int || l.Return == Assembly.Short; pushParam(load, ol, true, lsigned, l.Return == Assembly.Long, false); pushParam(load, or, true, rsigned, l.Return == Assembly.Long, false); load.Optimum.Call(method); @return(load, ret); return(ret); }
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree) { var method = scop as MethodInfo; var l = load.SetVariable(method, tree); tree.BaseCall = method; tree.Type = l.Return; tree.Membre = l; tree.Compiled = true; if (tree.Children.Count == 2) { return(l); } return(l); }
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree) { var space = scop.GetSpace(tree[0].Content, SearcheMode.Flaten); load.ByteCodeMapper.OpenScop(space); foreach (Tree t in tree) { if (t.GeneratedBy != null) { t.GeneratedBy.Compile(load, space, t); } } load.ByteCodeMapper.CloseScop(); return(null); }
internal static FieldInfo sub(FieldInfo ret, FieldInfo l, FieldInfo r, LoadClasses load) { var ol = l.Handle; var or = r.Handle; var rsigned = r.Return == Assembly.Int || r.Return == Assembly.Short; var lsigned = l.Return == Assembly.Int || l.Return == Assembly.Short; pushParam(load, ol, true, lsigned, l.Return == Assembly.Long); if (instants[l.Return].Index <= instants[r.Return].Index && r.Return != Assembly.Long) { pushParam(load, or, false, rsigned); } call(load, "sub", "sbb", r.Return == Assembly.Long ? or : null); return(@return(load, ret)); }
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree) { var label1 = load.Optimum.SetLabel(null, true); load.Compile(scop, tree[0]); var condition = tree[1].GeneratedBy.Compile(load, scop, tree[1]); if (condition == null || condition.Return != Assembly.Bool) { load.LogIn(scop, tree, tree[1], "Condition Value Must be Of Type System.Bool"); } load.Add("test", condition, FieldInfo.Immediate(0)); load.Optimum.SetGoto("jne", label1); return(RegInfo.eax); }
internal static FieldInfo add(FieldInfo ret, FieldInfo l, FieldInfo r, LoadClasses load) { if (instants[l.Return].Index > instants[r.Return].Index) { CallManager.swap(ref l, ref r); } var ol = l.Handle; var or = r.Handle; pushParam(load, ol, true, false); if (r.Return != Assembly.Long) { pushParam(load, or, false, r.Return == Assembly.Int || r.Return == Assembly.Short); } call(load, "add", "adc", r.Return == Assembly.Long ? or : null); return(@return(load, ret)); }
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree) { var dataPortor = scop as DataPortor; var l = load.SetVariable(dataPortor, tree[0]); tree.BaseCall = dataPortor; tree.Type = l.Return; tree.Membre = l; tree.Compiled = true; if (tree.Children.Count == 2) { return(null); } var fieldInfo = load.Compile(scop, tree[1]); return(load.Add("mov", l, fieldInfo)); }
private static void Return(FieldInfo ret, LoadClasses load, AsmLabel returnTrue, AsmLabel returnFalse, AsmLabel @return, bool OrEqual) { //Return True load.Optimum.SetLabel(returnTrue); load.Add("mov", RegInfo.eax, ConstInfo.True); //Return False load.Optimum.SetLabel(returnFalse); load.Add("xor", RegInfo.eax, RegInfo.eax); load.Optimum.SetGoto("jmp", @return); //Return load.Optimum.SetLabel(@return); if (OrEqual) { load.Add("test", RegInfo.eax, RegInfo.eax); load.Add("sete", RegInfo.eax); } load.Add("mov", ret, RegInfo.eax); }
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree) { var @class = scop.GetClass(tree[0].Content, SearcheMode.Flaten); load.ByteCodeMapper.OpenScop(@class); foreach (Tree t in tree) { if (t.Kind == Kind.Function || t.Kind == Kind.Constructor) { if (t.GeneratedBy != null) { t.GeneratedBy.Compile(load, @class, t); } } } load.ByteCodeMapper.CloseScop(); return(null); }
private static FieldInfo lt_gt(FieldInfo ret, FieldInfo l, FieldInfo r, LoadClasses load, bool is_lt_gt) { string jm1, jm2, jm3; if (is_lt_gt) { jm1 = "jg"; jm2 = "jl"; jm3 = "jb"; } else { jm1 = "jl"; jm2 = "jg"; jm3 = "ja"; } AsmLabel falseLabel = new AsmLabel("{asm1}"), trueLabel = new AsmLabel("{asm3}"), returnLabel = new AsmLabel("{ret}" + CPUUInt.u); var r_islong = r.Return == Assembly.Long; pushParam(load, l.Handle, true, IsSigned(l.Return), l.Return == Assembly.Long); if (!r_islong) { pushParam(load, r.Handle, false, IsSigned(r.Return), false); } load.Add("cmp", Reg.edx, !r_islong ? Reg.ebx : r.GetHandle(4)); load.Optimum.SetGoto(jm1, trueLabel, load, cByte.Clone()); load.Optimum.SetGoto(jm2, falseLabel, load, cByte.Clone()); load.Add("cmp", RegInfo.eax, !r_islong ? RegInfo.ecx : r); load.Optimum.SetGoto(jm3, trueLabel, load, cByte.Clone()); load.Optimum.SetLabel(falseLabel); load.Add("xor", RegInfo.eax, RegInfo.eax); load.Optimum.SetGoto("jmp", returnLabel, load, new Operand(0xFF, DataType.Byte)); load.Optimum.SetLabel(trueLabel); load.Add("mov", Reg.eax, new Operand(1, DataType.Byte)); load.Optimum.SetLabel(returnLabel); load.Add("mov", ret, RegInfo.eax); return(ret); }
private FieldInfo lte_gte(FieldInfo ret, FieldInfo l, FieldInfo r, LoadClasses load, bool is_lte_gte) { string jm1; string jm2; string jm3; if (is_lte_gte) { jm1 = "jl"; jm2 = "jg"; jm3 = "ja"; } else { jm1 = "jg"; jm2 = "jl"; jm3 = "jb"; } var r_islong = r.Return == Assembly.Long; AsmLabel trueLabel; AsmLabel returnLabel; var falseLabel = PushParams(l, r, load, out trueLabel, out returnLabel); load.Add("cmp", Reg.edx, r_islong ? r.Handle + 4 : Reg.ebx); load.Optimum.SetGoto(jm1, trueLabel, load, cByte.Clone()); load.Optimum.SetGoto(jm2, falseLabel, load, cByte.Clone()); load.Add("cmp", RegInfo.eax, r_islong ? r : RegInfo.ecx); load.Optimum.SetGoto(jm3, trueLabel, load, cByte.Clone()); load.Optimum.SetLabel(falseLabel); load.Add("xor", RegInfo.eax, RegInfo.eax); load.Optimum.SetGoto("jmp", returnLabel, load, new Operand(0xFF, DataType.Byte)); load.Optimum.SetLabel(trueLabel); load.Add("mov", Reg.eax, new Operand(1, DataType.Byte)); load.Optimum.SetLabel(returnLabel); load.Add("test", RegInfo.eax, RegInfo.eax); load.Add("sete", RegInfo.eax); load.Add("mov", ret, RegInfo.eax); return(ret); }
public static void _Test() { while (true) { __test(); var parse = new BasicParse { Pile = new Pile(Prg_Example) }; var parent = new Tree(parse.Pile, null, Kind.Program); var glob = CurrentScop.Initialize("globe"); Update(parse); var s = new Space(parse); if (s.Parse(parent)) { var byteCode = new ByteCodeMapper(glob); var load = new LoadClasses(byteCode); load.Add(parent[0]); load.Compile(); var inst = load.Optimum.Instructs; var sw = new IO.Stream.StreamWriter(true); for (int i = 0; i < inst.Count; i++) { inst[i].Push(sw); } var tt = inst[0].Length; var sr = new IO.Stream.StreamReader(sw); for (int i = 0; i < inst.Count; i++) { var x = Instruct.Pop(sr); var isieq = x.Equals(inst[i]); if (!isieq) { } } } } }
private FieldInfo eq_ne(FieldInfo ret, FieldInfo l, FieldInfo r, LoadClasses load, bool iseq = false) { var r_islong = r.Return == Assembly.Long; AsmLabel trueLabel; AsmLabel returnLabel; var falseLabel = PushParams(l, r, load, out trueLabel, out returnLabel); load.Add("cmp", Reg.edx, r_islong ? r.GetHandle(4) : Reg.ebx); load.Optimum.SetGoto("jne", iseq ? falseLabel : trueLabel, load, new Operand(0xFFFF, DataType.Byte)); load.Add("cmp", RegInfo.eax, r_islong ? r : RegInfo.ecx); load.Optimum.SetGoto(iseq ? "je" : "jne", trueLabel, load, new Operand(0xFFFF, DataType.Byte)); load.Optimum.SetLabel(falseLabel); load.Add("xor", RegInfo.eax, RegInfo.eax); load.Optimum.SetGoto("jmp", returnLabel, load, new Operand(0xFFFF, DataType.Byte)); load.Optimum.SetLabel(trueLabel); load.Add("mov", Reg.eax, new Operand(1, DataType.Byte)); load.Optimum.SetLabel(returnLabel); load.Add("mov", ret, RegInfo.eax); return(ret); }
private bool Initialize(LoadClasses load, Scop scop, Tree tree, out MethodInfo method) { if (tree.Method == null) { load.LogIn(scop, tree, this, "Method Name " + tree[1].Content + " not founded"); method = null; return(false); } method = tree.Method; if (method.Return == null) { method.Return = load.ByteCodeMapper.Finder.GetClass(load.ByteCodeMapper.CurrentScop.Root, tree[0].Content); } if (method.Return == null || !method.Return.Finalized) { throw new BadImageFormatException(); } method.Offset = load.ByteCodeMapper.StreamWriter.Offset; load.ByteCodeMapper.OpenScop(method); return(true); }
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree) { MethodInfo method; if (!Initialize(load, scop, tree, out method)) { return(null); } load.Optimum.Reset(method); #region Function Head var param = tree[2].Children; load.Optimum.Add("mov", Reg.esi, Reg.ebp); load.Optimum.Add("pop", Reg.ebp); Operand op = new Operand(0xFFFF); load.Optimum.Add("add", Reg.esp, op); for (var i = param.Count - 1; i >= 0; i--) { var pr = param[i]; load.Optimum.PopParam(pr.GeneratedBy.Compile(load, method, pr)); } load.Optimum.Add("push", Reg.esi); #endregion var fieldInfo = tree[3].GeneratedBy.Compile(load, method, tree[3]); #region Function Feet load.Optimum.SetLabel(MethodInfo.ReturnLabel); load.Optimum.Add("pop", Reg.ebp); load.Optimum.Add("sub", Reg.esp, op); load.Optimum.Add("ret", (Operand)null); #endregion op.Imm = method.DataSize; load.ByteCodeMapper.CloseScop(); load.Optimum.Finalize(); return(fieldInfo); }