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);
}
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 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);
}
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 void Add(string func, Operand a = null, Operand t = null)
//{
// Optimum.Add(func, a, t);
// new Instruct(func, a, t).Push(_byteCodeMapper.StreamWriter);
//}
internal FieldInfo Compile(Scop scop, Tree tree)
{
if (tree.Kind == Kind.Hyratachy)
{
return(scop.GetCField(tree.Content));
}
if (tree.Kind == Kind.Variable)
{
return(tree.Content == "true"
? ConstInfo.True
: (tree.Content == "false"
? ConstInfo.False
: (tree.Membre ?? scop.GetField(tree.Content, SearcheMode.Deep))));
}
if (tree.Kind == Kind.String)
{
return(tree.Membre = Constants.DeclareConst(tree.Membre == null
? Constants.DeclareString(tree.Content)
: (ConstInfo)tree.Membre));
}
if (tree.Kind != Kind.Numbre)
{
return(tree.GeneratedBy != null?tree.GeneratedBy.Compile(this, scop, tree) : null);
}
if (tree.Membre == null)
{
tree.Membre = Constants.GetConstNumbre(tree.Content);
}
return(tree.Membre.Return.SizeOf() <= 4 ? tree.Membre : Constants.DeclareConst((ConstInfo)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));
}
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 virtual FieldInfo Compile(LoadClasses load, Scop scop, Tree tree)
{
foreach (Tree t in tree)
{
t.GeneratedBy.Compile(load, scop, t);
}
return(null);
}
public FieldInfo Call(Scop scop, MethodInfo method, FieldInfo l, FieldInfo r, FieldInfo ret)
{
switch (method.Name)
{
case "+":
return(add(scop, method, l, r, ret));
case "-":
return(sub(scop, method, l, r, ret));
case "==":
return(eq(scop, method, l, r, ret));
case "*":
return(mul(scop, method, l, r, ret));
case "/":
return(div(scop, method, l, r, ret));
case ">=":
return(ge(scop, method, l, r, ret));
case "<=":
return(le(scop, method, l, r, ret));
case ">":
return(gth(scop, method, l, r, ret));
case "<":
return(lth(scop, method, l, r, ret));
case "!=":
return(ne(scop, method, l, r, ret));
case "&":
return(and(scop, method, l, r, ret));
case "^":
return(xor(scop, method, l, r, ret));
case "|":
return(or(scop, method, l, r, ret));
case "++":
return(inc(scop, method, l, r, ret));
case "--":
return(dec(scop, method, l, r, ret));
case ">>":
return(rsh(scop, method, l, r, ret));
case "<<":
return(lsh(scop, method, l, r, ret));
}
return(RegInfo.eax);
}
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);
}
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);
}
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
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);
}
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));
}
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);
}
public void Return(Scop scop, FieldInfo @return)
{
var met = ((MethodInfo)scop);
if ((@return == null || @return.Return == Assembly.Void) && met._Return == Assembly.Void)
{
return;
}
if (@return.Return == met.Return)
{
Optimum.Return(@return);
}
else
{
LogIn(scop, null, this, "return value incompatible");
return;
}
Optimum.SetGoto("jmp", MethodInfo.ReturnLabel);
}
private FieldInfo add(Scop scop, MethodInfo method, FieldInfo l, FieldInfo r, FieldInfo ret)
{
if (ret == null)
{
throw new Exception("return value cannot be null");
}
var il = GetIndex(l.Return);
var ir = GetIndex(r.Return);
if (il < ir)
{
swap(ref r, ref l);
}
if (l.Return.SizeOf() <= 4 && isSigned_4(r))
{
load.Add("add", l, r);
load.Add("mov", ret, RegInfo.eax);
return(ret);
}
if (l.Return == Assembly.Long && (isSigned_4(r) || r.Return == Assembly.Long))
{
load.Add("mov", Reg.eax, l.Handle.ToDwordPtr);
load.Add("mov", Reg.edx, l.Handle.ToDwordPtr + 4);
load.Add("add", Reg.eax, r.Handle.ToDwordPtr);
load.Add("adc", Reg.edx, r.Return == Assembly.Long ? r.Handle.ToDwordPtr + 4 : new Operand(0));
load.Add("mov", ret.Handle.ToDwordPtr, Reg.eax);
load.Add("mov", ret.Handle.ToDwordPtr + 4, Reg.edx);
return(ret);
}
if (l.Return == r.Return)
{
if (r.Return == Assembly.Float || l.Return == Assembly.Double)
{
load.Add("fld", l);
load.Add("fadd", l);
load.Add("fstp", ret);
return(ret);
}
}
//throw new Exception("Error CPUType");
return(ret);
}
public virtual void Execute(Graph parent, Graph previous, Scop scop)
{
if (!Checked && !(Success && IsCacheable))
{
if (Action == null)
{
return;
}
Success = Action(this, new GraphEventArgs(parent, previous, scop));
if (Success)
{
IfSuccess?.Execute(this, this, scop);
}
else
{
IfFail?.Execute(this, this, scop);
}
}
Finaly?.Execute(parent, this, scop);
}
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)
{
var method = new MethodInfo {
Return = load.ByteCodeMapper.Finder.GetClass(load.ByteCodeMapper.CurrentScop.Root, tree[0].Content),
Parent = scop,
IsConstructor = true,
};
scop.Scops.Add(method);
if (method.Return == null || !method.Return.Finalized)
{
throw new BadImageFormatException();
}
method.Name = tree[0].Content;
load.ByteCodeMapper.OpenScop(method);
var param = tree[1].Children;
foreach (var pr in param)
{
pr.GeneratedBy.Compile(load, method, pr);
method.AddParam((FieldInfo)pr.Membre);
}
return(tree[2].GeneratedBy.Compile(load, method, tree[2]));
}
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree)
{
AsmLabel
label1 = load.Optimum.SetLabel(null, true),
label2 = 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", label2);
var bloc = tree[1];
if (tree.Count == 2 && bloc.GeneratedBy != null)
{
bloc.GeneratedBy.Compile(load, scop, bloc);
}
load.Optimum.SetGoto("jmp", label1);
load.Optimum.SetLabel(label2);
return(RegInfo.eax);
}
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);
}
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree)
{
return(null);
}
protected override FieldInfo BeginCompile(MethodInfo method, FieldInfo ret, FieldInfo l, FieldInfo r,
LoadClasses load, Scop scop)
{
var lsigned = IsSigned(l);
var rsigned = IsSigned(r);
var returnTrue = new AsmLabel("{lasm" + u++ + "}");
var returnFalse = new AsmLabel("{lasm" + u++ + "}");
var @return = new AsmLabel("{lasm" + u++ + "}");
string o = "", oc = "";
var cnc = "";
switch (method.Name)
{
#region +-&^|
case "opers":
return(UintSOperation(ret, l, r, load, o, oc));
case "+":
o = "add";
oc = "adc";
goto case "opers";
case "-":
o = "sub";
oc = "sbb";
goto case "opers";
case "&":
oc = o = "and";
goto case "opers";
case "^":
oc = o = "xor";
goto case "opers";
case "|":
oc = o = "or";
goto case "opers";
#endregion
#region */
case "*":
o = "imul";
goto case "*/";
case "/":
o = "idiv";
goto case "*/";
case "*/":
if (lsigned == rsigned)
{
load.Add(o, l, r);
load.Add("mov", ret, RegInfo.eax);
return(ret);
}
if (lsigned)
{
CallManager.swap(ref l, ref r);
}
ConvertToLong(load, l, true);
load.Add("push", RegInfo.edx);
load.Add("push", RegInfo.eax);
ConvertToLong(load, r, true);
load.Add("push", RegInfo.edx);
load.Add("push", RegInfo.eax);
load.Optimum.Call(method);
Move(load, ret, Reg.eax, Reg.eax);
break;
#endregion
#region none
case ">>":
break;
case "<<":
break;
case "++":
case "--":
load.Add("mov", RegInfo.eax, l);
load.Add(method.Name == "++" ? "inc" : "dec", RegInfo.eax);
load.Add("mov", l, RegInfo.eax);
return(ret);
#endregion
#region == !=
case "==!=":
if (lsigned != rsigned)
{
return(Compile(ret, l, r, load, o, returnFalse, oc, returnTrue, "je", @return, false, true));
}
load.Add("mov", RegInfo.eax, l);
load.Add("cmp", RegInfo.eax, r);
load.Add(cnc, RegInfo.eax);
load.Add("mov", ret, RegInfo.eax);
return(ret);
case "==":
cnc = "sete";
o = "jne";
goto case "==!=";
case "!=":
o = "je";
cnc = "setne";
goto case "==!=";
#endregion
#region <==>
case ">=":
cnc = "sete";
if (lsigned != rsigned)
{
return(Compile(ret, l, r, load, "jg", returnFalse, "jl", returnTrue, "jb", @return, true));
}
goto case "<==>";
case "<==>":
load.Add("mov", RegInfo.eax, l);
load.Add("cmp", RegInfo.eax, r);
if (cnc == "sete")
{
load.Add("sbb", RegInfo.eax, RegInfo.eax);
}
load.Add(cnc, RegInfo.eax);
load.Add("mov", ret, RegInfo.eax);
break;
case "<=":
cnc = "setbe";
if (lsigned != rsigned)
{
return(Compile(ret, l, r, load, "jl", returnFalse, "jb", returnTrue, "ja", @return, true));
}
goto case "<==>";
#endregion
case ">":
#region >
if (lsigned == rsigned)
{
load.Add("mov", RegInfo.eax, l);
load.Add("cmp", RegInfo.eax, r);
load.Add("seta", RegInfo.eax);
load.Add("mov", ret, RegInfo.eax);
return(ret);
}
return(Compile(ret, l, r, load, "jl", returnFalse, "jg", returnTrue, "ja", @return, false));
#endregion
case "<":
#region >
if (lsigned == rsigned)
{
load.Add("mov", RegInfo.eax, l);
load.Add("cmp", RegInfo.eax, r);
load.Add("sbb", RegInfo.eax, RegInfo.eax);
load.Add("neg", RegInfo.eax);
load.Add("mov", ret, RegInfo.eax);
return(ret);
}
return(Compile(ret, l, r, load, "jg", returnFalse, "jl", returnTrue, "jb", @return, false));
#endregion
}
return(ret);
}
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree)
{
return(base.Compile(load, scop, tree));
}
protected abstract FieldInfo BeginCompile(MethodInfo method, FieldInfo ret, FieldInfo l, FieldInfo r, LoadClasses load, Scop scop);
protected override FieldInfo BeginCompile(MethodInfo method, FieldInfo ret, FieldInfo l, FieldInfo r, LoadClasses load, Scop scop)
{
return(null);
throw new NotImplementedException();
}
public override FieldInfo Compile(LoadClasses load, Scop scop, Tree tree)
{
load.Optimum.SetLabel(tree[0].Content, true);
return(null);
}
private FieldInfo eq(Scop scop, MethodInfo method, FieldInfo l, FieldInfo r, FieldInfo ret)
{
throw new NotImplementedException();
}
protected override FieldInfo BeginCompile(MethodInfo method, FieldInfo ret, FieldInfo l, FieldInfo r,
LoadClasses load, Scop scop)
{
var o = (string)null;
switch (method.Name)
{
case "+":
o = "add";
break;
case "-":
o = "sub";
break;
case "*":
o = "imul";
break;
case "/":
o = "idiv";
break;
case "&":
o = "and";
break;
case "^":
o = "xor";
break;
case "|":
o = "or";
break;
case ">>":
o = "shr";
break;
case "<<":
o = "shl";
break;
case "++":
load.Add("mov", RegInfo.eax, l);
load.Add("inc", RegInfo.eax);
load.Add("mov", l, RegInfo.eax);
return(ret);
case "--":
load.Add("mov", RegInfo.eax, l);
load.Add("dec", RegInfo.eax);
load.Add("mov", l, RegInfo.eax);
return(ret);
case "==":
load.Add("mov", RegInfo.eax, l);
load.Add("cmp", RegInfo.eax, r);
load.Add("sete", RegInfo.eax);
break;
case ">=":
load.Add("mov", RegInfo.eax, l);
load.Add("cmp", RegInfo.eax, r);
load.Add("setge", RegInfo.eax);
break;
case "<=":
load.Add("mov", RegInfo.eax, l);
load.Add("cmp", RegInfo.eax, r);
load.Add("setle", RegInfo.eax);
break;
case ">":
load.Add("cmp", l, r);
load.Add("setg", RegInfo.eax);
break;
case "<":
load.Add("cmp", l, r);
load.Add("setl", RegInfo.eax);
break;
case "!=":
load.Add("cmp", l, r);
load.Add("setne", RegInfo.eax);
break;
}
if (o != null)
{
load.Add(o, l, r);
}
load.Add("mov", ret, RegInfo.eax);
return(ret);
}
