public static void AddCodes(NodeBase caller, BlockBase parent, NodeBase target, OpModule codes, string op, Addr32 dest)
{
if (target is TypeOf) target = (target as TypeOf).Target;
var v = target as Variant;
if (v != null && parent.GetFunction(v.Name) == null)
{
var fpname = (target as Variant).Name;
var fpt = Types.GetType(parent, fpname);
if (fpt == null || !fpt.Check())
throw caller.Abort("undefined type: {0}", fpname);
codes.AddCodesV(op, dest, codes.GetTypeObject(fpt));
return;
}
var tt = target.Type;
var tr = tt as TypeReference;
var tts = tt.Type as TypeStruct;
if (tr != null && (tr.IsArray || (tts != null && tts.IsClass)))
{
target.AddCodesV(codes, "mov", null);
var label = new OpCode();
codes.Add(I386.Test(Reg32.EAX, Reg32.EAX));
codes.Add(I386.Jcc(Cc.Z, label.Address));
codes.Add(I386.MovRA(Reg32.EAX, Addr32.NewRO(Reg32.EAX, -16)));
codes.Add(label);
codes.AddCodes(op, dest);
}
else
codes.AddCodesV(op, dest, codes.GetTypeObject(tt));
}
public static void AddCallCodes(OpModule codes, Function f, NodeBase[] args)
{
AddCallCodes2(codes, args, f.CallType, delegate()
{
codes.Add(I386.CallD(f.First));
});
}
public static void AddCallCodes2(
OpModule codes, NodeBase[] args, CallType type, Action delg)
{
for (int i = args.Length - 1; i >= 0; i--)
args[i].AddCodesV(codes, "push", null);
delg();
if (type == CallType.CDecl && args.Length > 0)
{
int p = 4;
bool pop = false;
for (int i = 0; i < args.Length; i++)
{
var arg = args[i];
if (OpModule.NeedsDtor(arg))
{
if (!pop)
{
codes.Add(I386.Push(Reg32.EAX));
pop = true;
}
arg.Type.AddDestructorA(codes, Addr32.NewRO(Reg32.ESP, p));
}
p += 4;
}
if (pop) codes.Add(I386.Pop(Reg32.EAX));
codes.Add(I386.AddR(Reg32.ESP, Val32.New((byte)(args.Length * 4))));
}
}
public override void AddCodes(OpModule codes)
{
int len = values.Count;
if (len == 0)
{
codes.Add(I386.JmpD(Block.First));
return;
}
for (int i = 0; i < values.Count; i++)
{
var v = values[i] as NodeBase;
codes.Add(I386.Push(Reg32.EDX));
if (v.Type is TypeString)
{
v.AddCodesV(codes, "push", null);
codes.Add(codes.GetCall("case", TypeString.Equal));
codes.Add(I386.AddR(Reg32.ESP, Val32.New(8)));
codes.Add(I386.Test(Reg32.EAX, Reg32.EAX));
codes.Add(I386.Jcc(Cc.NZ, Block.First));
}
else
{
v.AddCodesV(codes, "mov", null);
codes.Add(I386.Pop(Reg32.EDX));
codes.Add(I386.Cmp(Reg32.EDX, Reg32.EAX));
codes.Add(I386.Jcc(Cc.E, Block.First));
}
}
if (IsLast) codes.Add(I386.JmpD(Parent.Destruct));
}
public override void AddCodesV(OpModule codes, string op, Addr32 dest)
{
Val32 v;
var m = codes.Module;
if (func != null)
v = func.GetAddress(m);
else
{
var vv = GetVar();
if (vv != null)
{
vv.AddCodesV(codes, op, dest);
return;
}
var c = GetConst();
if (c != null)
{
c.AddCodesV(codes, op, dest);
return;
}
var f = GetFunction();
if (f == null)
{
var g = GetGetter();
if (g != null)
{
Call.NewName(Parent, g.Name).AddCodesV(codes, op, dest);
return;
}
throw Abort("undefined symbol: " + name);
}
v = f.GetAddress(m);
}
codes.AddCodesV(op, dest, v);
}
public override void AddOpCodes(string op, OpModule codes, Addr32 dest)
{
switch (op)
{
case "inc":
case "post-inc":
if (Type.Size == 1)
codes.Add(I386.IncA(dest));
else
codes.Add(I386.AddA(dest, Val32.NewI(Type.Size)));
break;
case "dec":
case "post-dec":
if (Type.Size == 1)
codes.Add(I386.DecA(dest));
else
codes.Add(I386.SubA(dest, Val32.NewI(Type.Size)));
break;
case "add":
codes.Add(I386.MovR(Reg32.EDX, Val32.NewI(Type.Size)));
codes.Add(I386.Mul(Reg32.EDX));
codes.Add(I386.AddAR(dest, Reg32.EAX));
break;
case "sub":
codes.Add(I386.MovR(Reg32.EDX, Val32.NewI(Type.Size)));
codes.Add(I386.Mul(Reg32.EDX));
codes.Add(I386.SubAR(dest, Reg32.EAX));
break;
default:
base.AddOpCodes(op, codes, dest);
break;
}
}
public override void AddOpCodes(string op, OpModule codes, Addr32 dest)
{
switch (op)
{
case "shift-left":
Shift("sal", codes, dest);
break;
case "shift-right":
Shift("sar", codes, dest);
break;
case "mul":
codes.Add(I386.ImulA(dest));
codes.Add(I386.MovAR(dest, Reg32.EAX));
break;
case "div":
codes.Add(I386.XchgRA(Reg32.EAX, dest));
codes.Add(I386.Cdq());
codes.Add(I386.IdivA(dest));
codes.Add(I386.MovAR(dest, Reg32.EAX));
break;
case "mod":
codes.Add(I386.XchgRA(Reg32.EAX, dest));
codes.Add(I386.Cdq());
codes.Add(I386.IdivA(dest));
codes.Add(I386.MovAR(dest, Reg32.EDX));
break;
default:
base.AddOpCodes(op, codes, dest);
break;
}
}
public override void AddDestructor(OpModule codes)
{
codes.Add(I386.MovRA(Reg32.EAX, Addr32.New(Reg32.ESP)));
codes.Add(I386.PushA(Addr32.New(Reg32.EAX)));
codes.Add(codes.GetCall("delegate", DelgFunc.Free));
codes.Add(I386.AddR(Reg32.ESP, Val32.New(4)));
}
protected bool AddConstCodes(OpModule codes, string op, Addr32 dest)
{
var v = GetConst();
if (v == null) return false;
v.AddCodesV(codes, op, dest);
return true;
}
public override void AddConstructor(OpModule codes)
{
var st = GetStruct();
var f1 = st.GetFunction(Define.Initializer);
var f2 = st.GetFunction(Define.Constructor);
codes.Add(I386.CallD(f1.First));
codes.Add(I386.CallD(f2.First));
}
public override void AddCodes(OpModule codes)
{
codes.Add(first);
if (alias != null)
codes.Add(I386.Jmp(codes.Module.GetFunction(module, alias)));
else
codes.Add(I386.Jmp(codes.Module.GetFunction(module, name)));
}
public void AddConstructorA(OpModule codes, Addr32 ad)
{
if (ad != null)
codes.Add(I386.Lea(Reg32.EAX, ad));
codes.Add(I386.Push(Reg32.EAX));
AddConstructor(codes);
codes.Add(I386.AddR(Reg32.ESP, Val32.New(4)));
}
protected override void BeforeAddCodes(OpModule codes)
{
base.BeforeAddCodes(codes);
if (Init != null) Init.AddCodes(codes);
if (Loop != null)
codes.Add(I386.JmpD(Loop.Last));
else
codes.Add(I386.JmpD(Block.Last));
}
public override void AddCodesV(OpModule codes, string op, Addr32 dest)
{
var t = Var.Get(Target);
if (t == null)
throw Abort("addrof: variable required");
var ad = t.GetAddress(codes);
codes.Add(I386.Lea(Reg32.EAX, ad));
codes.AddCodes(op, dest);
}
public override void AddCodes(OpModule codes)
{
var dest = Var.Get(this.dest);
if (dest == null)
{
if (this.dest is Variant)
{
var setter = (this.dest as Variant).GetSetter();
if (setter != null)
{
var args = new NodeBase[1];
args[0] = values[0] as NodeBase;
Call.NewV(Parent, setter, This.New(Parent), args)
.AddCodes(codes);
return;
}
}
throw Abort("set: destination is not variable");
}
var dt = dest.Type;
if (dt is TypeConstChar)
throw Abort("set: can not change constants");
if (dest is Member)
{
var mem = dest as Member;
if (mem.IsSetter)
{
mem.AddSetterCodes(codes, values[0] as NodeBase);
return;
}
}
var v = values[0] as NodeBase;
v.AddCodesV(codes, "push", null);
var ad = dest.GetAddress(codes);
if (!OpModule.NeedsDtor(v))
{
if (ad == null)
{
ad = Addr32.New(Reg32.ESP);
codes.Add(I386.XchgRA(Reg32.EAX, ad));
dt.AddSetCodes(codes, ad);
codes.Add(I386.AddR(Reg32.ESP, Val32.New(4)));
}
else
{
codes.Add(I386.Pop(Reg32.EAX));
dt.AddSetCodes(codes, ad);
}
}
else
{
codes.Add(I386.MovRA(Reg32.EAX, Addr32.New(Reg32.ESP)));
dt.AddSetCodes(codes, ad);
codes.AddDtorCodes(v.Type);
}
}
public override void AddCodes(OpModule codes)
{
if (AddConstCodes(codes, "mov", null)) return;
var v = values[0] as NodeBase;
if (v != null && !OpModule.NeedsDtor(v))
v.AddCodes(codes);
else
AddCodesV(codes, "mov", null);
}
public override void AddCodes(OpModule codes)
{
sentences.Clear();
AddSentence(Block);
if (Loop != null) AddSentence(Loop);
if (Cond == null)
Cond = Cond.New(this, IntValue.One);
Cond.First = Block.First;
AddSentence(Cond);
base.AddCodes(codes);
}
public override void AddCodesV(OpModule codes, string op, Addr32 dest)
{
var t = Type;
var st = Source.Type;
if (st is TypeIntBase && t.Size < st.Size)
{
Source.AddCodesV(codes, "mov", null);
t.AddGetCodes(codes, op, dest, null);
}
else
Source.AddCodesV(codes, op, dest);
}
public override void AddCodes(OpModule codes)
{
var b = Parent;
var ptrs = UsingPointers;
for (; ; ptrs = b.UsingPointers, b = b.Parent)
{
if (b == null || b is Function)
throw Abort("invalid break");
b.AddDestructors(codes, ptrs);
if (b.AcceptsBreak) break;
b.AddExitCodes(codes);
}
codes.Add(I386.JmpD(b.Destruct));
}
public override void AddCodes(OpModule codes)
{
var next = new OpCode();
codes.Add(first);
if (Cond != null)
{
Cond.Next = next.Address;
Cond.AddCodes(codes);
}
Block.AddCodes(codes);
if (Next != null)
codes.Add(I386.JmpD(Parent.Destruct));
codes.Add(next);
}
public override void AddCodesV(OpModule codes, string op, Addr32 dest)
{
if (AddConstCodes(codes, op, dest)) return;
var v = values[0] as NodeBase;
if (!OpModule.NeedsDtor(v))
v.AddCodesV(codes, op, dest);
else
{
v.AddCodesV(codes, "mov", null);
codes.Add(I386.Push(Reg32.EAX));
codes.AddCodes(op, dest);
codes.AddDtorCodes(v.Type);
}
}
// set value
public override void AddSetCodes(OpModule codes, Addr32 ad)
{
var flag = !ad.IsAddress && ad.Register == Var.DestRegister;
if (flag) codes.Add(I386.Push(ad.Register));
codes.Add(I386.Push(Reg32.EAX));
codes.Add(I386.PushA(ad));
codes.Add(codes.GetCall("delegate", DelgFunc.Free));
codes.Add(I386.AddR(Reg32.ESP, Val32.New(4)));
codes.Add(codes.GetCall("delegate", DelgFunc.Duplicate));
codes.Add(I386.AddR(Reg32.ESP, Val32.New(4)));
if (flag) codes.Add(I386.Pop(ad.Register));
base.AddSetCodes(codes, ad);
}
public override void AddCodes(OpModule codes)
{
if (Next != null)
{
(values[0] as NodeBase).AddCodesV(codes, "mov", null);
codes.Add(I386.Test(Reg32.EAX, Reg32.EAX));
codes.Add(I386.Jcc(Cc.Z, Next));
}
else if (First != null)
{
(values[0] as NodeBase).AddCodesV(codes, "mov", null);
codes.Add(I386.Test(Reg32.EAX, Reg32.EAX));
codes.Add(I386.Jcc(Cc.NZ, First));
}
}
public override void AddCodesV(OpModule codes, string op, Addr32 dest)
{
if (AddConstCodes(codes, op, dest)) return;
var last = new OpCode();
for (int i = 0; i < values.Count; i++)
{
var v = values[i] as NodeBase;
v.AddCodesV(codes, "mov", null);
codes.Add(I386.Test(Reg32.EAX, Reg32.EAX));
codes.Add(I386.Jcc(Cc.Z, last.Address));
}
codes.Add(I386.MovR(Reg32.EAX, Val32.New(1)));
codes.Add(last);
codes.AddCodes(op, dest);
}
public override void AddCodes(OpModule codes)
{
switch (Subsystem)
{
case IMAGE_SUBSYSTEM.WINCE_GUI:
codes.Module.Specific.ImageBase = 0x10000;
codes.Module.Specific.SectionAlignment = 0x1000;
break;
}
IsCompiling = true;
OpModule.Root = this;
MakeUpStatics(codes.Module);
MakeUp();
base.AddCodes(codes);
OpModule.Root = null;
IsCompiling = false;
}
public override void AddCodesV(OpModule codes, string op, Addr32 dest)
{
if (AddConstCodes(codes, op, dest)) return;
OpCode last = new OpCode();
for (int i = 0; i < values.Count; i++)
{
(values[i] as NodeBase).AddCodesV(codes, "mov", null);
codes.Add(I386.Test(Reg32.EAX, Reg32.EAX));
if (i < values.Count - 1)
codes.Add(I386.Jcc(Cc.NZ, last.Address));
}
codes.Add(last);
codes.Add(I386.MovR(Reg32.EAX, Val32.New(0)));
codes.Add(I386.Setcc(Cc.NZ, Reg8.AL));
codes.AddCodes(op, dest);
}
public override Addr32 GetAddress(OpModule codes)
{
if (Source is Var)
return (Source as Var).GetAddress(codes);
else if (Source is IntValue)
codes.Add(I386.MovR(Var.DestRegister,
Val32.NewI((Source as IntValue).Value)));
else if (Source is StringValue)
codes.Add(I386.MovR(Var.DestRegister,
codes.GetString((Source as StringValue).Value)));
else
{
Source.AddCodesV(codes, "mov", null);
return null;
}
return Addr32.New(Var.DestRegister);
}
public override void AddCodes(OpModule codes)
{
///if (castFailed != null) throw Abort(castFailed);
var f = Parent.GetBelongFunction();
if (value != null)
{
value.AddCodesV(codes, "mov", null);
var retval = f.GetRetVal(Parent);
var dest = retval.GetAddress(codes);
if (!OpModule.NeedsDtor(value))
{
codes.Add(I386.MovAR(dest, Reg32.EAX));
var tr = value.Type as TypeReference;
if (tr != null && tr.UseGC)
TypeReference.AddReferenceCodes(codes);
}
else
{
codes.Add(I386.Push(Reg32.EAX));
var rt = f.ReturnType;
if (rt == null)
codes.Add(I386.MovAR(dest, Reg32.EAX));
else
{
if (rt is TypeReference)
codes.Add(I386.MovA(dest, Val32.New(0)));
rt.AddSetCodes(codes, dest);
}
codes.AddDtorCodes(value.Type);
}
}
var b = Parent;
var ptrs = UsingPointers;
for (; ; ptrs = b.UsingPointers, b = b.Parent)
{
b.AddDestructors(codes, ptrs);
if (b == f) break;
b.AddExitCodes(codes);
}
if (!IsLast) codes.Add(I386.JmpD(b.Destruct));
}
public override void AddExitCodes(OpModule codes)
{
switch (Subsystem)
{
case IMAGE_SUBSYSTEM.WINDOWS_CUI:
case IMAGE_SUBSYSTEM.WINDOWS_GUI:
if (retVal != null)
GetRetVal(this).AddCodesV(codes, "push", null);
else
codes.Add(I386.PushD(Val32.New(0)));
codes.Add(I386.CallA(codes.Module.GetFunction(
"kernel32.dll", "ExitProcess")));
break;
default:
if (retVal != null)
GetRetVal(this).AddCodesV(codes, "mov", null);
else
codes.Add(I386.Xor(Reg32.EAX, Reg32.EAX));
break;
}
}
protected override void BeforeAddCodes(OpModule codes)
{
ForEachMembers(delegate(VarDeclare p, int pos)
{
p.Address = Addr32.NewD(codes.Module.GetBuffer(p.Name, p.Type.Size));
return false;
}, null);
}
