public override void Emit(CodeGen cg)
{
bool eoiused = false;
Label eoi = cg.DefineLabel();
foreach (IfStatementTest t in _tests) {
Label next = cg.DefineLabel();
if (t.Test.Span.IsValid)
{
cg.EmitPosition(t.Test.Start, t.Test.End);
}
t.Test.EmitBranchFalse(cg, next);
t.Body.Emit(cg);
// optimize no else case
if (IsNotIfOrReturn(t.Body))
{
eoiused = true;
cg.Emit(OpCodes.Br, eoi);
}
cg.MarkLabel(next);
}
if (_else != null) {
_else.Emit(cg);
}
if (eoiused)
{
cg.MarkLabel(eoi);
}
}
public void FixReturn(CodeGen cg)
{
_argSlot.EmitGet(cg);
_refSlot.EmitGet(cg);
cg.EmitCall(typeof(BinderOps).GetMethod("GetBox").MakeGenericMethod(_argSlot.Type.GetElementType()));
cg.EmitStoreValueIndirect(_argSlot.Type.GetElementType());
}
internal override void EmitGet(CodeGen g)
{
Operand before = g.Local(target);
baseOp.SetOperand(before);
target.EmitSet(g, baseOp, false);
before.EmitGet(g);
}
public IEnumerable<Instruction> EmitDerivation(MethodDef method, ConfuserContext ctx, Local dst, Local src) {
var ret = new List<Instruction>();
var codeGen = new CodeGen(dst, src, method, ret);
codeGen.GenerateCIL(derivation);
codeGen.Commit(method.Body);
return ret;
}
public override void Emit(CodeGen cg)
{
if (_statement != null)
{
_statement.Emit(cg);
}
}
public override void Emit(CodeGen cg)
{
//cg.EmitPosition(Start, End);
// expression needs to be emitted incase it has side-effects.
var ex = Expression.Unwrap(_expression);
ex.EmitAs(cg, typeof(void));
}
public override void Emit(CodeGen cg) {
if (_valueTypeType != null)
{
EmitLocation(cg);
cg.EmitMissingValue(_valueTypeType); // seems ok?
}
else
{
for (int i = 0; i < _parameterInfos.Length; i++)
{
_arguments[i].Emit(cg);
if (_arguments[i].Type != _parameterInfos[i].ParameterType && _arguments[i].Type.IsValueType && typeof(SymbolId) != _arguments[i].Type)
{
cg.EmitBoxing(_arguments[i].Type);
}
}
EmitLocation(cg);
cg.EmitNew(_constructor);
}
if (ScriptDomainManager.Options.LightweightDebugging && Span.IsValid)
{
cg.EmitConstant(SpanToLong(Span));
cg.EmitCall(Debugging.DebugMethods.ExpressionOut);
}
}
internal override void EmitGet(CodeGen g)
{
int[] bits = decimal.GetBits(value);
byte exponent = unchecked((byte)((bits[3] >> 16) & 0x1f));
bool sign = bits[3] < 0;
if (exponent == 0 && bits[2] == 0)
{
if (bits[1] == 0 && (bits[0] > 0 || (bits[0] == 0 && !sign))) // fits in int32 - use the basic int constructor
{
g.EmitI4Helper(sign ? -bits[0] : bits[0]);
g.IL.Emit(OpCodes.Newobj, decimalIntConstructor);
return;
}
if (bits[1] > 0) // fits in int64
{
long l = unchecked((long)(((ulong)(uint)bits[1] << 32) | (ulong)(uint)bits[0]));
g.IL.Emit(OpCodes.Ldc_I8, sign ? -l : l);
g.IL.Emit(OpCodes.Newobj, decimalLongConstructor);
return;
}
}
g.EmitI4Helper(bits[0]);
g.EmitI4Helper(bits[1]);
g.EmitI4Helper(bits[2]);
g.EmitI4Helper(sign ? 1 : 0);
g.EmitI4Helper(exponent);
g.IL.Emit(OpCodes.Newobj, decimalExtConstructor);
}
public override void Emit(CodeGen cg) {
if (_typeOperand.IsAssignableFrom(_expression.Type)) {
// if its always true just emit the bool
cg.EmitConstant(true);
return;
}
_expression.EmitAsObject(cg);
EmitLocation(cg);
cg.Emit(OpCodes.Isinst, _typeOperand);
cg.Emit(OpCodes.Ldnull);
cg.Emit(OpCodes.Cgt_Un);
if (ScriptDomainManager.Options.LightweightDebugging)
{
if (!cg.IsDynamicMethod)
{
var s = SpanToLong(Span);
cg.EmitConstant(s);
cg.EmitCall(Debugging.DebugMethods.ExpressionOut);
}
}
}
public override void Emit(CodeGen cg)
{
if (Span.IsValid)
{
cg.EmitPosition(Start, End);
if (ScriptDomainManager.Options.LightweightDebugging)
{
if (!cg.IsDynamicMethod)
{
var s = SpanToLong(Span);
cg.EmitConstant(s);
cg.EmitCall(Debugging.DebugMethods.ExpressionInTail); // not really but will do for LW debugger
}
}
}
if (_statement != null) {
cg.CheckAndPushTargets(_statement);
}
cg.EmitContinue();
if (_statement != null) {
cg.PopTargets();
}
}
internal override void EmitGet(CodeGen g)
{
op.EmitGet(g);
foreach (OpCode oc in opCodes)
g.IL.Emit(oc);
}
public override void Emit(CodeGen cg) {
// RuntimeHelpers.LookupName(CodeContext, name)
cg.EmitCodeContext();
cg.EmitSymbolId(_name);
cg.EmitUnbox(typeof(SymbolId));
cg.EmitCall(typeof(RuntimeHelpers), "LookupName");
}
public override void Emit(CodeGen cg) {
// emit "this", if any
EmitInstance(cg);
if (ScriptDomainManager.Options.LightweightDebugging && Span.IsValid)
{
cg.EmitConstant(SpanToLong(Span));
cg.EmitCall(Debugging.DebugMethods.ExpressionIn);
}
EmitLocation(cg);
switch (_member.MemberType) {
case MemberTypes.Field:
FieldInfo field = (FieldInfo)_member;
cg.EmitFieldGet(field);
break;
case MemberTypes.Property:
PropertyInfo property = (PropertyInfo)_member;
cg.EmitPropertyGet(property);
break;
default:
Debug.Assert(false, "Invalid member type");
break;
}
if (ScriptDomainManager.Options.LightweightDebugging && Span.IsValid)
{
cg.EmitConstant(SpanToLong(Span));
cg.EmitCall(Debugging.DebugMethods.ExpressionOut);
}
}
public override bool Execute()
{
var codegen = new CodeGen();
if (SchemaFiles != null)
{
foreach (var schemaFile in SchemaFiles)
{
var schema = Schema.Parse(System.IO.File.ReadAllText(schemaFile.ItemSpec));
codegen.AddSchema(schema);
}
}
if (ProtocolFiles != null)
{
foreach (var protocolFile in ProtocolFiles)
{
var protocol = Protocol.Parse(System.IO.File.ReadAllText(protocolFile.ItemSpec));
codegen.AddProtocol(protocol);
}
}
var generateCode = codegen.GenerateCode();
var namespaces = generateCode.Namespaces;
for (var i = namespaces.Count - 1; i >= 0; i--)
{
var types = namespaces[i].Types;
for (var j = types.Count - 1; j >= 0; j--)
{
Log.LogMessage("Generating {0}.{1}", namespaces[i].Name, types[j].Name);
}
}
codegen.WriteTypes(OutDir.ItemSpec);
return true;
}
internal Label EnsureLabel(CodeGen cg) {
if (!_initialized) {
_label = cg.DefineLabel();
_initialized = true;
}
return _label;
}
private void button2_Click(object sender, EventArgs e)
{
label2.ForeColor = Color.Cyan;
label2.Text = "Being Compiled.";
try
{
Scanner scanner = null;
using (TextReader input = File.OpenText(openFileDialog1.FileName))
{
scanner = new Scanner(input);
}
Parser parser = new Parser(scanner.Tokens);
CodeGen codeGen = new CodeGen(parser.Result, Path.GetFileNameWithoutExtension(openFileDialog1.FileName) + ".exe");
label2.ForeColor = Color.Lime;
label2.Text = "Compiled! Check the directory this program is in, or click 'Test File' and check the console.";
button3.Enabled = true;
}
catch (Exception ex)
{
textBox3.Show();
textBox3.Text = ex.Message;
label2.ForeColor = Color.Red;
label2.Text = "Error!";
button3.Enabled = false;
}
}
private static Type GetEnvironmentType(int size, CodeGen cg, out ConstructorInfo ctor, out EnvironmentFactory ef)
{
Type envType;
#region Generated partial factories
// *** BEGIN GENERATED CODE ***
if (size <= 32 && Options.OptimizeEnvironments) {
if (size <= 2) {
envType = typeof(FunctionEnvironment2Dictionary);
} else if (size <= 4) {
envType = typeof(FunctionEnvironment4Dictionary);
} else if (size <= 8) {
envType = typeof(FunctionEnvironment8Dictionary);
} else if (size <= 16) {
envType = typeof(FunctionEnvironment16Dictionary);
} else {
envType = typeof(FunctionEnvironment32Dictionary);
}
ctor = envType.GetConstructor(new Type[] { typeof(FunctionEnvironmentDictionary), typeof(IModuleEnvironment), typeof(SymbolId[]), typeof(SymbolId[]) });
ef = new FieldEnvironmentFactory(envType);
} else {
cg.EmitInt(size);
envType = typeof(FunctionEnvironmentNDictionary);
ctor = envType.GetConstructor(new Type[] { typeof(int), typeof(FunctionEnvironmentDictionary), typeof(IModuleEnvironment), typeof(SymbolId[]), typeof(SymbolId[]) });
ef = new IndexEnvironmentFactory(size);
}
// *** END GENERATED CODE ***
#endregion
return envType;
}
public override void Emit(CodeGen cg)
{
// RuntimeHelpers.RemoveName(CodeContext, name)
cg.EmitCodeContext();
cg.EmitSymbolId(_name);
cg.EmitCall(typeof(RuntimeHelpers), "RemoveName");
}
public override void EmitGet(CodeGen cg)
{
// RuntimeHelpers.LookupName(context, name)
_frame.EmitGet(cg);
cg.EmitSymbolId(_name);
cg.EmitCall(typeof(RuntimeHelpers), "LookupName");
}
public override void Emit(CodeGen cg) {
//EmitLocation(cg);
_value.EmitAsObject(cg);
cg.EmitCodeContext();
cg.EmitSymbolId(_name);
cg.EmitCall(typeof(RuntimeHelpers), "SetNameReorder");
}
protected internal override void EmitGet(CodeGen g)
{
OperandExtensions.SetLeakedState(this, false);
int[] bits = decimal.GetBits(_value);
byte exponent = unchecked((byte)((bits[3] >> 16) & 0x1f));
bool sign = bits[3] < 0;
Type intType = g.TypeMapper.MapType(typeof(int));
if (exponent == 0 && bits[2] == 0)
{
if (bits[1] == 0 && (bits[0] > 0 || (bits[0] == 0 && !sign))) // fits in int32 - use the basic int constructor
{
g.EmitI4Helper(sign ? -bits[0] : bits[0]);
g.IL.Emit(OpCodes.Newobj, (ConstructorInfo)g.TypeMapper.MapType(typeof(decimal)).GetConstructor(new Type[] { intType }));
return;
}
if (bits[1] > 0) // fits in int64
{
long l = unchecked((long)(((ulong)(uint)bits[1] << 32) | (ulong)(uint)bits[0]));
g.IL.Emit(OpCodes.Ldc_I8, sign ? -l : l);
g.IL.Emit(OpCodes.Newobj, (ConstructorInfo)g.TypeMapper.MapType(typeof(decimal)).GetConstructor(new Type[] { g.TypeMapper.MapType(typeof(long)) }));
return;
}
}
g.EmitI4Helper(bits[0]);
g.EmitI4Helper(bits[1]);
g.EmitI4Helper(bits[2]);
g.EmitI4Helper(sign ? 1 : 0);
g.EmitI4Helper(exponent);
g.IL.Emit(OpCodes.Newobj, (ConstructorInfo)g.TypeMapper.MapType(typeof(decimal)).GetConstructor(
new Type[] { intType, intType, intType, g.TypeMapper.MapType(typeof(bool)), g.TypeMapper.MapType(typeof(byte)) }));
}
void LoadArrayAndIndexes(CodeGen g)
{
array.EmitGet(g);
foreach (Operand op in indexes)
g.EmitGetHelper(op, Operand.GetType(op) == typeof(int) ? typeof(int) : typeof(long), false);
}
protected internal override void EmitGet(CodeGen g)
{
OperandExtensions.SetLeakedState(this, false);
Operand before = g.Local(_target);
_baseOp.SetOperand(before);
_target.EmitSet(g, _baseOp, false);
before.EmitGet(g);
}
public override void EmitGetAddr(CodeGen cg)
{
Contract.RequiresNotNull(cg, "cg");
Debug.Assert(cg == _codeGen);
cg.Emit(OpCodes.Ldloca, _localBuilder);
}
internal override void EmitAddress(CodeGen cg, Type asType) {
if (asType != Type || _member.MemberType != MemberTypes.Field) {
base.EmitAddress(cg, asType);
} else {
EmitInstance(cg);
cg.EmitFieldAddress((FieldInfo)_member);
}
}
public override void EmitGet(CodeGen cg)
{
Contract.RequiresNotNull(cg, "cg");
_param.EmitGet(cg);
cg.EmitInt(_index);
cg.Emit(OpCodes.Ldelem_Ref);
}
public override void EmitBranchFalse(CodeGen cg, Label label) {
if (_valueIndex == _expressions.Count - 1) {
Emit(cg, _valueIndex);
_expressions[_valueIndex].EmitBranchFalse(cg, label);
} else {
base.EmitBranchFalse(cg, label);
}
}
protected internal override void EmitGet(CodeGen g)
{
OperandExtensions.SetLeakedState(this, false);
_op.EmitGet(g);
foreach (OpCode oc in _opCodes)
g.IL.Emit(oc);
}
public override void EmitGetAddr(CodeGen cg)
{
Contract.RequiresNotNull(cg, "cg");
_instance.EmitGet(cg);
cg.EmitInt(_index);
cg.Emit(OpCodes.Ldelema, Type);
}
protected internal override void EmitGet(CodeGen g)
{
OperandExtensions.SetLeakedState(this, false);
if (ReferenceEquals(_local, null))
_local = g.Local(_internal);
_local.EmitGet(g);
}
internal override void EmitGet(CodeGen g)
{
g.IL.Emit(OpCodes.Ldstr, _str);
}
public override void Emit(CodeGen cg)
{
CreateGlobalSlots(cg);
body.Emit(cg);
}
public override void EmitStorage(CodeGen cg)
{
cg.EmitNew(StorageType.GetConstructor(ArrayUtils.EmptyTypes));
//cg.Emit(OpCodes.Dup);
//EmitNestedTupleInit(cg, StorageType);
}
internal override void EmitGet(CodeGen g)
{
ctor.EmitArgs(g, args);
g.IL.Emit(OpCodes.Newobj, (ConstructorInfo)ctor.Method.Member);
}
public override EnvironmentSlot CreateEnvironmentSlot(CodeGen cg)
{
return(new ClassEnvironmentSlot(cg.GetNamedLocal(StorageType, "$environment"), StorageType));
}
// example based on the MSDN User-Defined Conversions Sample (structconversion.cs)
public static void GenStructConversion(AssemblyGen ag)
{
TypeGen BinaryNumeral = ag.Struct("BinaryNumeral");
{
FieldGen value = BinaryNumeral.Private.Field(typeof(int), "value");
CodeGen g = BinaryNumeral.Public.Constructor().Parameter(typeof(int), "value");
{
g.Assign(value, g.Arg("value"));
}
g = BinaryNumeral.Public.ImplicitConversionFrom(typeof(int));
{
g.Return(Exp.New(BinaryNumeral, g.Arg("value")));
}
g = BinaryNumeral.Public.ImplicitConversionTo(typeof(string));
{
g.Return("Conversion not yet implemented");
}
g = BinaryNumeral.Public.ExplicitConversionTo(typeof(int), "binary");
{
g.Return(g.Arg("binary").Field("value"));
}
}
TypeGen RomanNumeral = ag.Struct("RomanNumeral");
{
FieldGen value = RomanNumeral.Private.Field(typeof(int), "value");
CodeGen g = RomanNumeral.Public.Constructor().Parameter(typeof(int), "value");
{
g.Assign(value, g.Arg("value"));
}
g = RomanNumeral.Public.ImplicitConversionFrom(typeof(int));
{
g.Return(Exp.New(RomanNumeral, g.Arg("value")));
}
g = RomanNumeral.Public.ImplicitConversionFrom(BinaryNumeral, "binary");
{
g.Return(Exp.New(RomanNumeral, g.Arg("binary").Cast(typeof(int))));
}
g = RomanNumeral.Public.ExplicitConversionTo(typeof(int), "roman");
{
g.Return(g.Arg("roman").Field("value"));
}
g = RomanNumeral.Public.ImplicitConversionTo(typeof(string));
{
g.Return("Conversion not yet implemented");
}
}
TypeGen Test = ag.Class("Test");
{
CodeGen g = Test.Public.Static.Method(typeof(void), "Main");
{
Operand roman = g.Local(RomanNumeral);
g.Assign(roman, 10);
Operand binary = g.Local(BinaryNumeral);
// Perform a conversion from a RomanNumeral to a
// BinaryNumeral:
g.Assign(binary, roman.Cast(typeof(int)).Cast(BinaryNumeral));
// Performs a conversion from a BinaryNumeral to a RomanNumeral.
// No cast is required:
g.Assign(roman, binary);
g.WriteLine(binary.Cast(typeof(int)));
g.WriteLine(binary);
}
}
}
// example based on the MSDN User-Defined Conversions Sample (conversion.cs)
public static void GenConversion(AssemblyGen ag)
{
TypeGen RomanNumeral = ag.Struct("RomanNumeral");
{
FieldGen value = RomanNumeral.Private.Field(typeof(int), "value");
CodeGen g = RomanNumeral.Public.Constructor().Parameter(typeof(int), "value");
{
g.Assign(value, g.Arg("value"));
}
// Declare a conversion from an int to a RomanNumeral. Note the
// the use of the operator keyword. This is a conversion
// operator named RomanNumeral:
g = RomanNumeral.Public.ImplicitConversionFrom(typeof(int));
{
// Note that because RomanNumeral is declared as a struct,
// calling new on the struct merely calls the constructor
// rather than allocating an object on the heap:
g.Return(Exp.New(RomanNumeral, g.Arg("value")));
}
// Declare an explicit conversion from a RomanNumeral to an int:
g = RomanNumeral.Public.ExplicitConversionTo(typeof(int), "roman");
{
g.Return(g.Arg("roman").Field("value"));
}
// Declare an implicit conversion from a RomanNumeral to
// a string:
g = RomanNumeral.Public.ImplicitConversionTo(typeof(string));
{
g.Return("Conversion not yet implemented");
}
}
TypeGen Test = ag.Class("Test");
{
CodeGen g = Test.Public.Static.Method(typeof(void), "Main");
{
Operand numeral = g.Local(RomanNumeral);
g.Assign(numeral, 10);
// Call the explicit conversion from numeral to int. Because it is
// an explicit conversion, a cast must be used:
g.WriteLine(numeral.Cast(typeof(int)));
// Call the implicit conversion to string. Because there is no
// cast, the implicit conversion to string is the only
// conversion that is considered:
g.WriteLine(numeral);
// Call the explicit conversion from numeral to int and
// then the explicit conversion from int to short:
Operand s = g.Local(numeral.Cast(typeof(short)));
g.WriteLine(s);
}
}
}
public void Emit(CodeGen g)
{
_target.EmitSet(g, _baseOp, false);
}
// Use homotopy method with newton's method to find a solution for F(x) = 0.
private static List <Arrow> NSolve(List <Expression> F, List <Arrow> x0, double Epsilon, int MaxIterations)
{
int M = F.Count;
int N = x0.Count;
// Compute JxF, the Jacobian of F.
List <Dictionary <Expression, Expression> > JxF = Jacobian(F, x0.Select(i => i.Left)).ToList();
// Define a function to evaluate JxH(x), where H = F(x) - s*F(x0).
CodeGen code = new CodeGen();
ParamExpr _JxH = code.Decl <double[, ]>(Scope.Parameter, "JxH");
ParamExpr _x0 = code.Decl <double[]>(Scope.Parameter, "x0");
ParamExpr _s = code.Decl <double>(Scope.Parameter, "s");
// Load x_j from the input array and add them to the map.
for (int j = 0; j < N; ++j)
{
code.DeclInit(x0[j].Left, LinqExpr.ArrayAccess(_x0, LinqExpr.Constant(j)));
}
LinqExpr error = code.Decl <double>("error");
// Compile the expressions to assign JxH
for (int i = 0; i < M; ++i)
{
LinqExpr _i = LinqExpr.Constant(i);
for (int j = 0; j < N; ++j)
{
code.Add(LinqExpr.Assign(
LinqExpr.ArrayAccess(_JxH, _i, LinqExpr.Constant(j)),
code.Compile(JxF[i][x0[j].Left])));
}
// e = F(x) - s*F(x0)
LinqExpr e = code.DeclInit <double>("e", LinqExpr.Subtract(code.Compile(F[i]), LinqExpr.Multiply(LinqExpr.Constant((double)F[i].Evaluate(x0)), _s)));
code.Add(LinqExpr.Assign(LinqExpr.ArrayAccess(_JxH, _i, LinqExpr.Constant(N)), e));
// error += e * e
code.Add(LinqExpr.AddAssign(error, LinqExpr.Multiply(e, e)));
}
// return error
code.Return(error);
Func <double[, ], double[], double, double> JxH = code.Build <Func <double[, ], double[], double, double> >().Compile();
double[] x = new double[N];
// Remember where we last succeeded/failed.
double s0 = 0.0;
double s1 = 1.0;
do
{
try
{
// H(F, s) = F - s*F0
NewtonsMethod(M, N, JxH, s0, x, Epsilon, MaxIterations);
// Success at this s!
s1 = s0;
for (int i = 0; i < N; ++i)
{
x0[i] = Arrow.New(x0[i].Left, x[i]);
}
// Go near the goal.
s0 = Lerp(s0, 0.0, 0.9);
}
catch (FailedToConvergeException)
{
// Go near the last success.
s0 = Lerp(s0, s1, 0.9);
for (int i = 0; i < N; ++i)
{
x[i] = (double)x0[i].Right;
}
}
} while (s0 > 0.0 && s1 >= s0 + 1e-6);
// Make sure the last solution is at F itself.
if (s0 != 0.0)
{
NewtonsMethod(M, N, JxH, 0.0, x, Epsilon, MaxIterations);
for (int i = 0; i < N; ++i)
{
x0[i] = Arrow.New(x0[i].Left, x[i]);
}
}
return(x0);
}
public override void EmitGet(CodeGen g)
{
g.IL.Emit(OpCodes.Ldstr, str);
}
/// <summary>
/// Iterate over all loaded mods and emit new types
/// </summary>
protected void Awake()
{
// Generate overloaded PQSMod types
AssemblyGen assembly = new AssemblyGen(Guid.NewGuid().ToString(),
new CompilerOptions {
OutputPath = Path.GetTempFileName()
});
List <Type> modTypes = GetModTypes();
foreach (Type modType in modTypes)
{
if (typeof(PQSMod).IsAssignableFrom(modType))
{
// Get the ModLoader type we want to extend
Type loaderType = modTypes.FirstOrDefault(t =>
t.BaseType != null && t.BaseType.FullName != null &&
t.BaseType.FullName.StartsWith("Kopernicus.Configuration.ModLoader.ModLoader") &&
t.BaseType.GetGenericArguments()[0] == modType);
if (loaderType == null)
{
continue;
}
// Generate the Mod Type
TypeGen modGen = assembly.Public.Class($"{modType.Name}Regional", modType);
{
FieldGen multiplierMap = modGen.Public.Field(typeof(MapSO), "multiplierMap");
FieldGen splitChannels = modGen.Public.Field(typeof(Boolean), "splitChannels");
FieldGen multiplier = modGen.Private.Field(typeof(Color), "multiplier");
FieldGen preBuildColor = modGen.Private.Field(typeof(Color), "preBuildColor");
FieldGen preBuildHeight = modGen.Private.Field(typeof(Double), "preBuildHeight");
// OnVertexBuildHeight
CodeGen onVertexBuild = modGen.Public.Override.Method(typeof(void), "OnVertexBuild")
.Parameter(typeof(PQS.VertexBuildData), "data");
{
ContextualOperand data = onVertexBuild.Arg("data");
onVertexBuild.Assign(multiplier, onVertexBuild.Local(multiplierMap.Invoke(
"GetPixelColor", new TypeMapper(),
data.Field("u"), data.Field("v"))));
onVertexBuild.If(!splitChannels);
{
onVertexBuild.Assign(multiplier.Field("a", new TypeMapper()),
multiplier.Field("r", new TypeMapper()));
}
onVertexBuild.End();
onVertexBuild.Assign(preBuildColor, data.Field("vertColor"));
onVertexBuild.Assign(preBuildHeight, data.Field("vertHeight"));
onVertexBuild.Invoke(onVertexBuild.Base(), "OnVertexBuild", data);
onVertexBuild.Assign(data.Field("vertColor"),
assembly.StaticFactory.Invoke(typeof(Color), "Lerp", preBuildColor,
data.Field("vertColor"), multiplier.Field("a", new TypeMapper())));
onVertexBuild.Assign(data.Field("vertHeight"),
assembly.StaticFactory.Invoke(typeof(UtilMath), "Lerp", preBuildHeight,
data.Field("vertHeight"), multiplier.Field("r", new TypeMapper())));
}
// OnVertexBuildHeight
CodeGen onVertexBuildHeight = modGen.Public.Override.Method(typeof(void), "OnVertexBuildHeight")
.Parameter(typeof(PQS.VertexBuildData), "data");
{
ContextualOperand data = onVertexBuildHeight.Arg("data");
onVertexBuildHeight.Assign(multiplier, onVertexBuildHeight.Local(multiplierMap.Invoke(
"GetPixelColor", new TypeMapper(),
data.Field("u"), data.Field("v"))));
onVertexBuildHeight.If(!splitChannels);
{
onVertexBuildHeight.Assign(multiplier.Field("a", new TypeMapper()),
multiplier.Field("r", new TypeMapper()));
}
onVertexBuildHeight.End();
onVertexBuildHeight.Assign(preBuildColor, data.Field("vertColor"));
onVertexBuildHeight.Assign(preBuildHeight, data.Field("vertHeight"));
onVertexBuildHeight.Invoke(onVertexBuildHeight.Base(), "OnVertexBuildHeight", data);
onVertexBuildHeight.Assign(data.Field("vertColor"),
assembly.StaticFactory.Invoke(typeof(Color), "Lerp", preBuildColor,
data.Field("vertColor"), multiplier.Field("a", new TypeMapper())));
onVertexBuildHeight.Assign(data.Field("vertHeight"),
assembly.StaticFactory.Invoke(typeof(UtilMath), "Lerp", preBuildHeight,
data.Field("vertHeight"), multiplier.Field("r", new TypeMapper())));
}
}
// Generate the Loader Type
modGen.Complete();
Type modLoader = typeof(ModLoader <>).MakeGenericType(modGen.GetCompletedType());
TypeGen loaderGen =
assembly.Public.Class($"{modType.Name.Replace("PQSMod_", "").Replace("PQS", "")}Regional",
modLoader).Attribute(typeof(RequireConfigType), Kopernicus.ConfigParser.Enumerations.ConfigType.Node);
{
PropertyGen multiplierMap = loaderGen.Public.Property(typeof(MapSOParserRGB <MapSO>), "multiplierMap")
.Attribute(typeof(ParserTarget), "multiplierMap");
{
CodeGen getter = multiplierMap.Getter();
{
getter.Return(getter.Base().Property("Mod").Field("multiplierMap"));
}
CodeGen setter = multiplierMap.Setter();
{
setter.Assign(setter.Base().Property("Mod").Field("multiplierMap"),
setter.PropertyValue());
}
}
PropertyGen splitChannels = loaderGen.Public.Property(typeof(NumericParser <Boolean>), "splitChannels")
.Attribute(typeof(ParserTarget), "splitChannels");
{
CodeGen getter = splitChannels.Getter();
{
getter.Return(getter.Base().Property("Mod").Field("splitChannels"));
}
CodeGen setter = splitChannels.Setter();
{
setter.Assign(setter.Base().Property("Mod").Field("splitChannels"),
setter.PropertyValue());
}
}
FieldGen loader = loaderGen.Public.Field(loaderType, "loader")
.BeginAttribute(typeof(ParserTarget), "Mod").SetField("AllowMerge", true).End();
CodeGen create_PQS = loaderGen.Public.Override.Method(typeof(void), "Create")
.Parameter(typeof(PQS), "pqsVersion");
{
ContextualOperand pqsVersion = create_PQS.Arg("pqsVersion");
create_PQS.Invoke(create_PQS.Base(), "Create", pqsVersion);
create_PQS.Assign(loader, assembly.ExpressionFactory.New(loaderType));
create_PQS.Invoke(loader, "Create", create_PQS.Base().Property("Mod"), pqsVersion);
}
CodeGen create_Mod_PQS = loaderGen.Public.Override.Method(typeof(void), "Create")
.Parameter(modGen, "_mod")
.Parameter(typeof(PQS), "pqsVersion");
{
ContextualOperand _mod = create_Mod_PQS.Arg("_mod");
ContextualOperand pqsVersion = create_Mod_PQS.Arg("pqsVersion");
create_Mod_PQS.Invoke(create_Mod_PQS.Base(), "Create", _mod, pqsVersion);
create_Mod_PQS.Assign(loader, assembly.ExpressionFactory.New(loaderType));
create_Mod_PQS.Invoke(loader, "Create", create_Mod_PQS.Base().Property("Mod"), pqsVersion);
}
}
}
}
assembly.Save();
// Hacking into my own mod. Oh well.
modTypes.AddRange(assembly.GetAssembly().GetTypes());
typeof(Parser).GetField("_modTypes", BindingFlags.NonPublic | BindingFlags.Static)
?.SetValue(null, modTypes);
}
/// <summary>
/// Generates the code for the expression, leaving it on
/// the stack typed as object.
/// </summary>
/// <param name="cg">Where to emit the code.</param>
public void EmitAsObject(CodeGen cg)
{
this.Emit(cg); // emit as Type
cg.EmitBoxing(Type);
}
/// <summary>
/// This is the dual of EmitBranchFalse.
/// </summary>
public virtual void EmitBranchTrue(CodeGen cg, Label label)
{
this.EmitAs(cg, typeof(bool));
cg.Emit(OpCodes.Brtrue, label);
}
public override void Emit(CodeGen cg)
{
cg.EmitConstant(_value);
}
protected void CreateClosureSlots(CodeGen cg)
{
CreateClosureSlots(cg.StaticLinkSlot, cg.Names);
}
public override void EmitGet(CodeGen g)
{
op.EmitGet(g);
g.IL.Emit(OpCodes.Isinst, t);
}
protected Slot CreateEnvironment(CodeGen cg)
{
// Get the environment size
int size = CalculateEnvironmentSize();
// Create the array for the names
Slot namesSlot = cg.GetLocalTmp(typeof(SymbolId[]));
cg.EmitInt(size - tempsCount);
cg.Emit(System.Reflection.Emit.OpCodes.Newarr, typeof(SymbolId));
namesSlot.EmitSet(cg);
// Find the right environment type
ConstructorInfo ctor;
EnvironmentFactory esf;
Type envType = GetEnvironmentType(size, cg, out ctor, out esf);
// Emit the static link for the environment constructor
cg.EmitStaticLinkOrNull();
cg.EmitCallerContext();
// Emit the names array for the environment constructor
namesSlot.EmitGet(cg);
cg.EmitNew(ctor);
// Store the environment reference in the local
Slot environmentSlot = cg.GetFrameSlot(envType);
environmentSlot.EmitSet(cg);
// Remember the environment factory for parent access
environmentFactory = esf;
// Create environment references
environment = new Dictionary <Name, EnvironmentReference>();
foreach (KeyValuePair <Name, Binding> kv in names)
{
if (!kv.Value.IsEnvironment)
{
continue;
}
Name name = kv.Key;
EnvironmentReference er = esf.MakeEnvironmentReference(name);
Slot slot = er.CreateSlot(environmentSlot);
Slot current;
if (cg.Names.Slots.TryGetValue(name, out current))
{
slot.EmitSet(cg, current);
}
else
{
slot.EmitSetUninitialized(cg, name);
}
// Set the name into the array
namesSlot.EmitGet(cg);
cg.EmitInt(er.Index);
cg.Emit(OpCodes.Ldelema, typeof(SymbolId));
cg.EmitSymbolIdInt(name.GetString());
cg.Emit(OpCodes.Call, typeof(SymbolId).GetConstructor(new Type[] { typeof(int) }));
// The full slot goes to the codegen's namespace
cg.Names.SetSlot(name, slot);
// Environment reference goes to the environment
environment[name] = er;
}
return(environmentSlot);
}
public override void EmitGetStorageFromContext(CodeGen cg)
{
cg.EmitCodeContext();
cg.EmitPropertyGet(typeof(CodeContext), "Scope");
cg.EmitCall(typeof(RuntimeHelpers).GetMethod("GetStorageData").MakeGenericMethod(StorageType));
}
internal override void EmitGet(CodeGen g)
{
g.EmitGetHelper(_target, g.TypeMapper.MapType(typeof(object)), false);
g.IL.Emit(OpCodes.Ldftn, _method);
g.IL.Emit(OpCodes.Newobj, _delegateConstructor);
}
public override void EmitStorage(CodeGen cg)
{
cg.EmitNew(StorageType.GetConstructor(ArrayUtils.EmptyTypes));
}
protected override IEnumerable <string> CommandLineFlagsForLibrary(PrecompiledLibrary library, CodeGen codegen)
{
// if lib which contains all JNI code is linked statically, then all methods from this lib should be exposed
var entryPoint = library.ToString().Contains("lib_unity_tiny_android.a");
if (entryPoint)
{
yield return("-Wl,--whole-archive");
}
foreach (var flag in base.CommandLineFlagsForLibrary(library, codegen))
{
yield return(flag);
}
if (entryPoint)
{
yield return("-Wl,--no-whole-archive");
}
}
public void SetAppPackagingParameters(String gameName, CodeGen codeGen, IEnumerable <IDeployable> supportFiles)
{
m_gameName = gameName.Replace(".", "-");
m_codeGen = codeGen;
m_supportFiles = supportFiles;
}
public void LogWarning(RuntimeData.WarningID ID, string message, string filename, int line, int col)
{
filename = filename ?? string.Empty;
if (!this.core.Options.IsDeltaExecution && (string.IsNullOrEmpty(filename) ||
line == Constants.kInvalidIndex ||
col == Constants.kInvalidIndex))
{
CodeGen.AuditCodeLocation(core, ref filename, ref line, ref col);
}
var warningMsg = string.Format(StringConstants.kConsoleWarningMessage,
message, filename, line, col);
if (core.Options.Verbose)
{
System.Console.WriteLine(warningMsg);
}
if (WebMessageHandler != null)
{
var outputMessage = new OutputMessage(warningMsg);
WebMessageHandler.Write(outputMessage);
}
if (MessageHandler != null)
{
var outputMessage = new OutputMessage(OutputMessage.MessageType.Warning,
message.Trim(), filename, line, col);
MessageHandler.Write(outputMessage);
}
AssociativeGraph.GraphNode executingGraphNode = null;
var executive = core.CurrentExecutive.CurrentDSASMExec;
if (executive != null)
{
executingGraphNode = executive.Properties.executingGraphNode;
// In delta execution mode, it means the warning is from some
// internal graph node.
if (executingGraphNode != null && executingGraphNode.guid.Equals(System.Guid.Empty))
{
executingGraphNode = core.ExecutingGraphnode;
}
}
var entry = new RuntimeData.WarningEntry
{
ID = ID,
Message = message,
Column = col,
Line = line,
ExpressionID = core.RuntimeExpressionUID,
GraphNodeGuid = executingGraphNode == null ? Guid.Empty : executingGraphNode.guid,
AstID = executingGraphNode == null ? Constants.kInvalidIndex : executingGraphNode.OriginalAstID,
Filename = filename
};
warnings.Add(entry);
if (core.Options.IsDeltaExecution)
{
}
}
protected override IEnumerable <string> CommandLineFlagsFor(NPath destination, CodeGen codegen, IEnumerable <NPath> objectFiles)
{
if (Toolchain.Architecture is ARMv7Architecture)
{
yield return("-arch_only");
yield return("armv7");
}
if (Toolchain.Architecture is Arm64Architecture)
{
yield return("-arch_only");
yield return("arm64");
}
yield return("-static");
foreach (var objectFile in objectFiles)
{
yield return(objectFile.InQuotes());
}
yield return("-o");
yield return(ChangeMainModuleName(destination).InQuotes());
}
public override void EmitGet(CodeGen g)
{
g.EmitGetHelper(target, typeof(object), false);
g.IL.Emit(OpCodes.Ldftn, method);
g.IL.Emit(OpCodes.Newobj, delegateConstructor);
}
protected override IEnumerable <string> CommandLineFlagsForLibrary(PrecompiledLibrary library, CodeGen codegen)
{
if (BundleStaticLibraryDependencies && library.Static)
{
yield return(library.InQuotes());
}
}
public static void LoadAll()
{
string path = Settings.GetRunningDirectory() + "plugins" +
Path.DirectorySeparatorChar;
log.Info("Plugin path: " + path);
if (!Directory.Exists(path))
{
return;
}
// cs plugins are background compiled, and loaded in the ui thread
Task.Run(() =>
{
String[] csFiles = Directory.GetFiles(path, "*.cs");
foreach (var csFile in csFiles)
{
log.Info("Plugin: " + csFile);
//Check if it is disabled (moved out from the previous IF, to make it loggable)
if (DisabledPluginNames.Contains(Path.GetFileName(csFile).ToLower()))
{
log.InfoFormat("Plugin {0} is disabled in config.xml", Path.GetFileName(csFile));
continue;
}
//loadassembly: MissionPlanner.WebAPIs
var content = File.ReadAllText(csFile);
var matches = Regex.Matches(content, @"^\/\/loadassembly: (.*)$", RegexOptions.Multiline);
foreach (Match m in matches)
{
try
{
log.Info("Try load " + m.Groups[1].Value.Trim());
Assembly.Load(m.Groups[1].Value.Trim());
}
catch (Exception ex)
{
log.Error(ex);
}
}
try
{
// csharp 8
var ans = CodeGenRoslyn.BuildCode(csFile);
InitPlugin(ans, Path.GetFileName(csFile));
continue;
}
catch (Exception ex)
{
log.Error(ex);
}
try
{
//csharp 5 max
// create a compiler
var compiler = CodeGen.CreateCompiler();
// get all the compiler parameters
var parms = CodeGen.CreateCompilerParameters();
// compile the code into an assembly
var results = CodeGen.CompileCodeFile(compiler, parms, csFile);
InitPlugin(results?.CompiledAssembly, Path.GetFileName(csFile));
if (results?.CompiledAssembly != null)
{
continue;
}
}
catch (Exception ex)
{
log.Error(ex);
}
}
MainV2.instance.BeginInvokeIfRequired(() =>
{
PluginInit();
});
});
String[] files = Directory.GetFiles(path, "*.dll");
foreach (var s in files)
{
Load(Path.Combine(Environment.CurrentDirectory, s));
}
InitPlugin(Assembly.GetAssembly(typeof(PluginLoader)), "self");
PluginInit();
}
public override void Emit(CodeGen cg)
{
//cg.EmitPosition(Start, End);
cg.EmitYield(_expr, _target);
}
public BuilderGen(CodeGen generator)
: base(generator)
{
}
/// <summary> /// Generates code for this expression in a value position. /// This method will leave the value of the expression /// on the top of the stack typed as Type. /// </summary> /// <param name="cg">Where to generate the code.</param> public abstract void Emit(CodeGen cg);