public void GenerateAssembly(string path)
{
_assemblyGen = new AssemblyGen("output", new CompilerOptions {
OutputPath = path, SymbolInfo = true, TargetFrameworkName = "4.5", TargetFrameworkDisplayName = "4.5"
});
using (_assemblyGen.Namespace("Language"))
{
_currentProgram = _assemblyGen.Public.Class("Program");
{
Visit(_program);
}
var type = _currentProgram.GetCompletedType(true);
_currentProgram = _assemblyGen.Public.Class("Runner");
{
CodeGen method = _currentProgram.Public.Static.Method(typeof(void), "Main");
{
Operand obj = method.Local(_currentProgram.ExpressionFactory.New(type));
method.Invoke(obj, "main");
method.WriteLine("Press any key...");
method.Invoke(typeof(Console), "ReadKey");
}
}
}
_assemblyGen.Save();
}
private static void CodeGen()
{
//Integer x = 0;
var code = ScriptParser.ParseProgram("source.fls");
var assembly = new AssemblyGen("FluidTest", "1.0");
code.Compile(assembly);
assembly.Save("FluidTest.dll");
}
public void GenerateCode()
{
_asm = new AssemblyGen(_moduleName);
//LoadClasses(_root, _asm);
LoadClassesExtends(_root, _asm);
LoadClassesMethods(_root, _asm);
_compilerLogger.PrintClassesMethods(_methodsTables);
Generate(_root);
_asm.Save();
}
public void CreateComWrapper(string filePath, string dllPath, string p1, string p2)
{
AssemblyGen ag = new AssemblyGen(filePath);
Assembly asm = Assembly.LoadFrom(dllPath);
ag.Attribute(asm.GetType("WaveTech.Scutex.Model.LicenseAttribute"), p1, p2);
ag.Attribute(typeof(System.Runtime.InteropServices.ComVisibleAttribute), true);
ag.Attribute(typeof(System.Reflection.AssemblyVersionAttribute), "1.0.0.0");
ag.Attribute(typeof(System.Reflection.AssemblyFileVersionAttribute), "1.0.0.0");
ag.Attribute(typeof(System.Runtime.InteropServices.GuidAttribute), "DC7DE67E-EA7A-4D26-89FF-FECEF2937268");
ag.Namespace("ScutexLicensingCCW");
TypeGen ComWrapper = ag.Public.Class(_stringDataGeneratorProvider.GenerateRandomString(10, 50, false, false)).Attribute(typeof(System.Runtime.InteropServices.ClassInterfaceAttribute), System.Runtime.InteropServices.ClassInterfaceType.AutoDual);
{
CodeGen g1 = ComWrapper.Public.Constructor();
CodeGen g2 = ComWrapper.Public.Method(typeof(int), "Validate").Parameter(typeof(int), "interactionMode");
{
Operand licensingManager = g2.Local(Exp.New(asm.GetType("WaveTech.Scutex.Licensing.LicensingManager"), g2.This()));
Operand scutexLicensing = g2.Local(asm.GetType("WaveTech.Scutex.Model.ScutexLicense"));
Operand value = g2.Local(asm.GetType("WaveTech.Scutex.Model.InteractionModes"));
g2.Assign(value, g2.Arg("interactionMode").Cast(asm.GetType("WaveTech.Scutex.Model.InteractionModes")));
g2.Assign(scutexLicensing, licensingManager.Invoke("Validate", value));
g2.Return(0);
}
CodeGen g3 = ComWrapper.Public.Method(typeof(int), "Register").Parameter(typeof(string), "licenseKey");
{
Operand licensingManager = g3.Local(Exp.New(asm.GetType("WaveTech.Scutex.Licensing.LicensingManager"), g3.This()));
Operand scutexLicensing = g3.Local(asm.GetType("WaveTech.Scutex.Model.ScutexLicense"));
g3.Assign(scutexLicensing, licensingManager.Invoke("Register", g3.Arg("licenseKey")));
g3.Return(0);
}
}
ag.Save();
asm = null;
}
static void RunCodeGen()
{
var code = ScriptParser.ParseProgram("source.fls");
var assembly = new AssemblyGen("FluidTest", "1.0");
code.Compile(assembly);
assembly.Save("FluidTest.dll");
if (assembly.Context.TryGetType("Sample", out Type type))
{
if (type is IType)
{
type = type.ReflectedType;
}
object obj = Activator.CreateInstance(type);
Any value = new Any(obj);
var res = value.Invoke("create");
Console.WriteLine(res);
}
}
public void CreateAssembly(string p1, string p2)
{
AssemblyGen ag = new AssemblyGen(_path + @"\DemoHost.exe");
Assembly asm = Assembly.LoadFrom(_path + @"\WaveTech.Scutex.Licensing.dll");
ag.Attribute(asm.GetType("WaveTech.Scutex.Model.LicenseAttribute"), p1, p2);
TypeGen DemoHost = ag.Public.Class("DemoHost");
{
CodeGen g = DemoHost.Public.Static.Method(typeof(void), "Main");
{
g.WriteLine("====================================================");
g.WriteLine("| SCUTEX |");
g.WriteLine("| DEMO HOST FOR TRIAL DIALOG TESTING |");
g.WriteLine("====================================================");
g.WriteLine("");
g.WriteLine("");
g.WriteLine("Your trial dialog or form should display in a few seconds...");
Operand licensingManager = g.Local(Exp.New(asm.GetType("WaveTech.Scutex.Licensing.LicensingManager")));
Operand value = g.Local(asm.GetType("WaveTech.Scutex.Model.InteractionModes"));
Operand value2 = g.Local(typeof(System.Int32));
g.Assign(value2, 1);
g.Assign(value, value2.Cast(asm.GetType("WaveTech.Scutex.Model.InteractionModes")));
Operand scutexLicensing = g.Local(asm.GetType("WaveTech.Scutex.Model.ScutexLicense"));
g.Assign(scutexLicensing, licensingManager.Invoke("Validate", value));
g.Return();
}
}
ag.Save();
asm = null;
}
internal void Start()
{
assembly.Context.Register("Console", typeof(Console));
// code.Compile(assembly);
valueField = typeGen.DefineField("value", typeof(object), FieldAttributes.Private);
valueField.SetCustomAttribute(typeof(DebuggerBrowsableAttribute), typeof(DebuggerBrowsableAttribute).GetInstanceCtor(typeof(DebuggerBrowsableState)), DebuggerBrowsableState.Never);
// ctor
var ctorParams = new ParameterInfo[] { new ParameterInfo("val", 0, typeof(object)) };
ConstructorGenerator ctorGen = typeGen.DefineCtor(ctorParams, MethodAttributes.Public);
ctorGen.SyntaxBody = new BlockStatement(new NodeList <Statement>
{
Expression.Assign(Expression.Member("value"), Expression.Parameter(ctorParams[0]))
});
EmitOpImplicit(typeGen);
EmitOpAddition(typeGen);
EmitToStringMethod();
typeGen.CreateType();
assembly.Save("FluidScript.Runtime.dll");
}
/// <summary>
/// Iterate over all loaded mods and emit new types
/// </summary>
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
Type modLoader = typeof(ModLoader <>).MakeGenericType(modGen);
TypeGen loaderGen =
assembly.Public.Class($"{modType.Name.Replace("PQSMod_", "").Replace("PQS", "")}Regional",
modLoader);
{
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);
}
