public override void Emit(IlBuilder builder)
{
base.Emit(builder);
builder.PushValue(_val);
_op.Emit(builder);
}
public virtual void Emit(IlBuilder builder)
{
builder.EmitString(".method");
foreach (string flag in Flags)
{
builder.EmitString(" " + flag);
}
builder.EmitLine($" {ReturnType.Name} {Name}({ArgList}) cil managed");
builder.EmitLine("{");
if (!IsAbstract && Instructions.Count > 0)
{
builder.Output.AddIndentation();
//TODO: Allow for selection of entrypoint
if (Name == "Main")
{
builder.EmitLine(".entrypoint");
}
int startLoc = builder.Output.ReserveLocation();
if (Locals.Count > 0)
{
string types = "";
foreach (var t in Locals)
{
types += t.Type.Name + ",";
}
builder.EmitLine(".locals init (" + types[..^ 1] + ")");
public override void Emit(IlBuilder builder)
{
List <string> metadata = new List <string>();
if (Properties.ContainsKey("Version"))
{
metadata.Add($".ver {Properties["Version"].Replace('.', ':')}");
}
if (Properties.ContainsKey("PublicKeyToken"))
{
metadata.Add($".publickeytoken = ({Properties["PublicKeyToken"].ToUpper()})");
}
if (metadata.Count == 0)
{
builder.EmitLine($".assembly extern {Name}{{}}");
}
else
{
builder.EmitLine($".assembly extern {Name}");
builder.EmitLine("{");
builder.Output.AddIndentation();
foreach (string m in metadata)
{
builder.EmitLine(m);
}
builder.Output.ReduceIndentation();
builder.EmitLine("}");
}
}
public override void ConvertFrom(CodeValue val, IlBuilder builder)
{
Debug.Assert(val.Type is UserType);
//Console.WriteLine("WARING: trying to convert from Usertype " + Name + " to " + val.Type.Name);
builder.PushValue(val);
builder.EmitOpCode(OpCodes.Castclass, ShortName);
}
public override void Emit(IlBuilder builder)
{
if (Instructions.Count == 0)
{
return;
}
base.Emit(builder);
}
public override void Emit(IlBuilder builder)
{
base.Emit(builder);
_symbolConversion?.Emit(builder);
if (_method.IsInstance)
{
if (((Owner == null || Owner.IsStatic) && _thisPtr == null) || _staticCall)
{
ErrorManager.ExitWithError(new Exception("Can't call instance function from static context"));
}
if (!_valueType)
{
builder.PushValue(_thisPtr ?? Owner.ThisPointer);
}
else
{
builder.PushAddress(_thisPtr as CodeSymbol);
}
}
foreach (var p in _parameters)
{
builder.PushValue(p);
}
if (_method.IsVirtual && !_baseAccess)
{
if (_valueType)
{
//NOTE: This is sometimes emitted while not needed, like with System.Int32.ToString(), as these methods appear
//as virtual but actually aren't. I don't know why, but it still works so whatever.
builder.EmitLine("constrained. " + _thisPtr.Type.Name);
}
builder.EmitOpCode(OpCodes.Callvirt, _method.FullSignature);
}
else
{
builder.EmitOpCode(OpCodes.Call, _method.FullSignature);
}
builder.ShrinkStack(_parameters.Length);
if (_return != CodeType.Void)
{
if (!_expression)
{
builder.EmitOpCode(OpCodes.Pop);
}
else
{
builder.ExpandStack(1);
}
}
}
public virtual void Emit(IlBuilder builder)
{
if (Label == "")
{
return;
}
builder.Output.ReduceIndentationForLine();
builder.EmitString(Label + ": ");
}
public override void Emit(IlBuilder builder)
{
base.Emit(builder);
if (hasValue)
{
_exp.Push(builder);
}
builder.EmitOpCode(OpCodes.Ret);
}
public override void Push(IlBuilder builder)
{
if (Index <= 3)
{
builder.EmitOpCode(OpCodeUtil.GetOpcode("Ldloc_" + Index));
}
else
{
builder.EmitOpCode(OpCodeUtil.GetOpcode("Ldloc"), Index);
}
}
public override void Store(IlBuilder builder, CodeValue source)
{
if (IsField)
{
_field.Store(builder, source);
}
else
{
_property.Store(builder, source);
}
}
public override void PushAddress(IlBuilder builder)
{
if (IsField)
{
_field.PushAddress(builder);
}
else
{
_property.PushAddress(builder);
}
}
public override void Push(IlBuilder builder)
{
if (_convertCall == null)
{
Type.ConvertTo(Original, builder, Type);
}
else
{
_convertCall.Emit(builder);
}
}
public override void PushAddress(IlBuilder builder)
{
if (Index <= 255)
{
builder.EmitOpCode(OpCodes.Ldloca_S, Index);
}
else
{
builder.EmitOpCode(OpCodes.Ldloca, Index);
}
}
public override void PushAddress(IlBuilder builder)
{
if (!Field.IsStatic)
{
builder.PushValue(_owner);
builder.EmitOpCode(OpCodes.Ldflda, Type.ArgumentName, $"{ReferenceName}::{ID}");
}
else
{
builder.EmitOpCode(OpCodes.Ldsflda, Type.ArgumentName, $"{ReferenceName}::{ID}");
}
}
public override void Store(IlBuilder builder, CodeValue val)
{
builder.PushValue(val);
if (Index <= 3)
{
builder.EmitOpCode(OpCodeUtil.GetOpcode("Stloc_" + Index));
}
else
{
builder.EmitOpCode(OpCodeUtil.GetOpcode("Stloc"), Index);
}
}
public override void ConvertTo(CodeValue val, IlBuilder builder, CodeType to)
{
if (to == BaseType)
{
builder.PushValue(val);
builder.EmitOpCode(OpCodes.Unbox_Any, Name);
}
else
{
base.ConvertTo(val, builder, to);
}
}
public override void Push(IlBuilder builder)
{
if (_indexerCall == null)
{
builder.PushValue(_array);
builder.PushValue(_index);
builder.EmitOpCode(OpCodeUtil.GetOpcode("Ldelem_" + Type.OpName));
}
else
{
_indexerCall.Emit(builder);
}
}
public override void ConvertFrom(CodeValue val, IlBuilder builder)
{
var type = UserType.ToUserType(val.Type);
Debug.Assert(type != null);
//TODO: Add non-symbol support
var call = new InterCall(convCalls[val.Type], true, val);
call.Emit(builder);
//Don't shrink stack, value is popped and then string is pushed
}
public override void Emit(IlBuilder builder)
{
base.Emit(builder);
foreach (var p in _parameters)
{
builder.PushValue(p);
}
builder.EmitOpCode(OpCodes.Newobj, _constructor.FullSignature);
builder.ShrinkStack(_parameters.Length);
builder.ExpandStack(1);
}
public override void Store(IlBuilder builder, CodeValue store)
{
if (!Field.IsStatic)
{
builder.PushValue(_owner);
builder.PushValue(store);
builder.EmitOpCode(OpCodes.Stfld, Type.ArgumentName, $"{ReferenceName}::{ID}");
}
else
{
builder.PushValue(store);
builder.EmitOpCode(OpCodes.Stsfld, Type.ArgumentName, $"{ReferenceName}::{ID}");
}
}
public override void Store(IlBuilder builder, CodeValue source)
{
if (_indexerCall == null)
{
builder.PushValue(_array);
builder.PushValue(_index);
builder.PushValue(source);
builder.EmitOpCode(OpCodeUtil.GetOpcode("Stelem_" + Type.OpName));
}
else
{
throw new NotImplementedException();
}
}
public override void Emit(IlBuilder builder)
{
base.Emit(builder);
if (_overload != null)
{
_overload.Emit(builder);
return;
}
builder.PushValue(_op1);
builder.PushValue(_op2);
Op.Emit(builder);
}
public override void Emit(IlBuilder builder)
{
base.Emit(builder);
_op?.Push(builder);
OpCode op = Condition switch
{
BranchCondition.Always => OpCodes.Br,
BranchCondition.OnFalse => OpCodes.Brfalse,
BranchCondition.Leave => OpCodes.Leave,
_ => OpCodes.Brtrue
};
builder.EmitOpCode(op, _label);
}
//TODO: Add back pre-emit type conversion
public override void Emit(IlBuilder builder)
{
base.Emit(builder);
if (!Owner.IsStatic && FieldOrPropertySymbol.IsFieldOrProperty(_target))
{
var forp = FieldOrPropertySymbol.ToFieldOrPropertySymbol(_target);
if (!forp.HasOwner())
{
forp.SetOwner(Owner.ThisPointer);
_target = forp;
}
}
_target.Store(builder, _source);
//builder.EmitOpCode(_target.Location.GetStoreOpcode(), "For ID " + _target.ID);
}
static void Main(string[] args)
{
if (args.Length == 0)
{
ShowHelp();
return;
}
try
{
using (var s = new FileStream(args[0], FileMode.Open))
{
if (args.Length == 2)
{
if (args[1].StartsWith("-out:"))
{
var exeName = args[1].Substring(5);
if (!string.IsNullOrEmpty(exeName))
{
var builder = new IlBuilder(exeName);
var v = new CompilerVisitor(builder);
Run(v, s);
return;
}
}
else if (args[1] == "-jit")
{
var builder = new JitBuilder();
var v = new CompilerVisitor(builder);
Run(v, s);
builder.GenType.RunMain();
return;
}
ShowHelp();
}
else
{
Run(new InterpreterVisitor(new Channel()), s);
}
}
}
catch (ParserRuleContextException ex)
{
Console.WriteLine(ex);
}
}
public void Emit(IlBuilder builder)
{
string instance = IsStatic ? "" : "instance ";
builder.EmitLine($".property {instance}{Type.Name} {Name} ()");
builder.EmitLine("{");
builder.Output.AddIndentation();
if (Get != null)
{
builder.EmitLine(".get " + Get.CallSignature);
}
if (Set != null)
{
builder.EmitLine(".set " + Set.CallSignature);
}
builder.Output.ReduceIndentation();
builder.EmitLine("}");
}
public override void Emit(IlBuilder builder)
{
base.Emit(builder);
builder.PushValue(_rank);
builder.EmitOpCode(OpCodes.Newarr, _typeof.TypeOf.Name);
if (_entries == null)
{
return;
}
for (int i = 0; i < _entries.Length; i++)
{
builder.EmitOpCode(OpCodes.Dup);
builder.PushValue(new CodeValue(BasicType.Int32, i));
builder.PushValue(_entries[i]);
builder.EmitOpCode(OpCodeUtil.GetOpcode("Stelem_" + _typeof.TypeOf.OpName));
}
}
public void Emit(IlBuilder builder)
{
string genericParams =
IsGeneric ? '<' + string.Join(',', NamespaceContext.GenericParameters.Keys) + '>' : "";
builder.EmitLine($".class private {string.Join(' ', Flags)} auto ansi beforefieldinit {FullName}{genericParams} extends {BaseType.ShortName}");
builder.EmitLine("{");
builder.EmitLine();
builder.Output.AddIndentation();
foreach (var field in Fields)
{
field.Emit(builder);
}
foreach (var property in Properties)
{
property.Emit(builder);
}
builder.EmitLine();
Initializer.Emit(builder);
foreach (var c in Constructors)
{
c.Emit(builder);
}
foreach (var method in Methods)
{
method.Emit(builder);
}
builder.Output.ReduceIndentation();
builder.EmitLine("}");
builder.EmitLine("");
}
public override void Emit(IlBuilder builder)
{
base.Emit(builder);
bool or = _op.Type == Operator.OperatorType.Or;
string label1 = Owner.LabelManager.NextLabel;
string label2 = Owner.LabelManager.NextLabel;
builder.PushValue(_op1);
builder.EmitOpCode(or ? OpCodes.Brtrue : OpCodes.Brfalse, label1);
builder.PushValue(_op2);
builder.EmitOpCode(OpCodes.Br, label2);
builder.Output.ReduceIndentationForLine();
builder.EmitString(label1 + ": ");
builder.PushValue(new CodeValue(CodeType.Int32, or ? 1 : 0));
builder.Output.ReduceIndentationForLine();
builder.EmitString(label2 + ": ");
builder.EmitOpCode(OpCodes.Nop);
}
public override void Emit(IlBuilder builder)
{
base.Emit(builder);
if (_opening)
{
if (_type == null)
{
builder.EmitLine(_name);
}
else
{
builder.EmitLine(_name + " " + _type.ShortName);
}
builder.EmitLine("{");
builder.Output.AddIndentation();
}
else
{
builder.Output.ReduceIndentation();
builder.EmitLine("}");
}
}
