public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List <IExpression> args)
{
var arg = args[0];
var v = lua.FreeVar("v");
var vLua = new LuaLiteral(Typs.String, v);
var mappings = new List <string>();
foreach (var kv in _mapping.StringToResultFunctions)
{
var f = kv.Value;
if (f.Types.First() is Curry)
{
f = f.Apply(vLua);
}
mappings.Add("if (" + v + " == \"" + kv.Key + "\") then\n " + assignTo + " = " + lua.ToLua(f));
}
return(Utils.Lines(
"local " + v,
Snippets.Convert(lua, v, arg),
string.Join("\nelse", mappings),
"end"
));
}
public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List <IExpression> args)
{
var result = Snippets.Convert(lua, assignTo, args[0]);
result += " " + assignTo + " = 1 / " + assignTo;
return(result);
}
public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List <IExpression> args)
{
var neededKeysExpr = args[0];
var funcExpr = args[1];
var tagsExpr = args[2];
var result = "";
var neededKeys = lua.FreeVar("neededKeys");
var tags = "";
if (tagsExpr is LuaLiteral literal)
{
tags = literal.Lua;
}
else
{
tags = lua.FreeVar("tags");
result += $"local {tags}";
result += Snippets.Convert(lua, tags, tagsExpr);
}
result += $"local {neededKeys}\n";
result += Snippets.Convert(lua, neededKeys, neededKeysExpr);
var key = lua.FreeVar("key");
var value = lua.FreeVar("value");
result += $"for _, {key} in ipairs({neededKeys}) do\n";
result += $" local {value} = {tags}[{key}]\n";
result += $" if ({value} == nil) then\n";
result += $" -- The value is nil, so mustmatch probably fails...\n";
throw new System.NotImplementedException();
}
public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List <IExpression> args)
{
// Note how we totally throw away args[0]
var tagsToken = args[1];
var tags = "";
var result = "";
if (tagsToken is LuaLiteral lit)
{
tags = lit.Lua;
}
else
{
tags = lua.FreeVar("tags");
result += "local " + tags + "\n";
result += Snippets.Convert(lua, tags, tagsToken);
}
var r = lua.FreeVar("relationValue");
result += "local " + r + " = " + tags + "[\"_relation:" + lua.Context.AspectName.Replace(".", "_") + "\"]\n";
result += assignTo + " = " + r + " == \"yes\"";
return(result);
}
public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List <IExpression> args)
{
var fCond = args[0].Optimize();
var fValue = args[1];
IExpression fElse = null;
var arg = args[2];
if (args.Count == 4)
{
arg = args[3];
fElse = args[2];
}
var c = lua.FreeVar("cond");
var result = "";
result += "local " + c + "\n";
var condApplied = fCond.Apply(arg);
var isString = condApplied.Types.First().Equals(Typs.String);
result += Snippets.Convert(lua, c, condApplied) + "\n";
result += $"if ( {c} or {c} == \"yes\" ) then \n";
result += " " + Snippets.Convert(lua, assignTo, fValue.Apply(arg)).Indent();
if (fElse != null)
{
result += "else\n";
result += " " + Snippets.Convert(lua, assignTo, fElse.Apply(arg)).Indent();
}
result += "end\n";
return(result);
}
public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List <IExpression> args)
{
var defaultValue = args[0];
var func = args[1];
var funcArg = args[2];
return(Snippets.Convert(lua, assignTo, func.Apply(funcArg))
+ "\n"
+ "if (" + assignTo + " == nil) then\n"
+ " " + assignTo + " = " + lua.ToLua(defaultValue) + "\n"
+ "end");
}
public LuaPrinter1(ProfileMetaData profile, Context context,
List <AspectTestSuite> aspectTestSuites,
List <BehaviourTestSuite> profileTests)
{
_profile = profile;
_context = context;
_aspectTestSuites = aspectTestSuites?.Where(suite => suite != null)
?.Select(testSuite => testSuite.WithoutRelationTests())?.ToList();
_profileTests = profileTests;
_skeleton = new LuaSkeleton.LuaSkeleton(context, false);
_parameterPrinter = new LuaParameterPrinter(profile, _skeleton);
}
public LuaPrinter2(ProfileMetaData profile, string behaviourName,
Context context,
List <AspectTestSuite> aspectTests, IEnumerable <BehaviourTestSuite> behaviourTestSuite,
DateTime lastChangeTime)
{
_skeleton = new LuaSkeleton.LuaSkeleton(context, true);
_profile = profile;
_behaviourName = behaviourName;
_context = context;
_aspectTests = aspectTests;
_behaviourTestSuite = behaviourTestSuite;
_lastChangeTime = lastChangeTime;
_parameterPrinter = new LuaParameterPrinter(_profile, _skeleton);
}
public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List <IExpression> args)
{
var actualArgs = new List <IExpression>();
var mappings = new List <Mapping>();
if (UnApply(
UnApply(IsFunc(Funcs.StringStringToTags),
IsMapping(mappings)),
Assign(actualArgs)
).Invoke(args[0]))
{
var actualArg = actualArgs.First();
var mapping = mappings.First();
if (mapping.StringToResultFunctions.Count != 1)
{
return(null);
}
var(key, func) = mapping.StringToResultFunctions.ToList().First();
var result = "";
var tags = "";
if (actualArg is LuaLiteral l)
{
tags = l.Lua;
}
else
{
tags = lua.FreeVar("tags");
result += "local " + tags + "\n";
result += Snippets.Convert(lua, tags, actualArg);
}
var v = lua.FreeVar("value");
result += "local " + v + " = " + tags + "[\"" + key + "\"]\n";
result += Snippets.Convert(lua, assignTo, func.Apply(new LuaLiteral(Typs.String, v)));
return(result);
}
return(null);
}
public static string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, IExpression e)
{
var opt = e.Optimize();
// Note that optimization might optimize to a _subtype_ of the original expresion - which is fine!
var origType = e.Types.First();
var optType = opt.Types.First();
if (!origType.Equals(optType) && !origType.IsSuperSet(optType))
{
throw new Exception("Optimization went wrong!");
}
e = opt;
var deconstructed = e.DeconstructApply();
if (deconstructed != null)
{
if (deconstructed.Value.f is Mapping m)
{
return(new SimpleMappingSnippet(m).Convert(lua, assignTo, deconstructed.Value.args));
}
if (deconstructed.Value.f is Function f &&
SnippetsIndex.TryGetValue(f.Name, out var snippet))
{
var optimized = snippet.Convert(lua, assignTo, deconstructed.Value.args);
if (optimized != null)
{
return(optimized + "\n");
}
}
}
try {
return(assignTo + " = " + lua.ToLua(e) + "\n");
}
catch (Exception err) {
return("print(\"ERROR COMPILER BUG\");\n");
}
}
public LuaTestPrinter(LuaSkeleton.LuaSkeleton skeleton, List <string> unitTestRunners)
{
_skeleton = skeleton;
unitTestRunners.ForEach(_skeleton.AddDep);
}
public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List <IExpression> args)
{
// Multiply multiplies a list of values - we thus have to handle _each_ arg
// Note: we get a single argument which is an expression resulting in a list of values
var listToMultiply = args[0];
var mappings = new List <Mapping>();
var arg = new List <IExpression>();
if (UnApply(UnApply(
IsFunc(Funcs.StringStringToTags),
IsMapping(mappings)),
Assign(arg)
).Invoke(listToMultiply))
{
var mapping = mappings.First();
var result = assignTo + " = " + _neutralValue + "\n";
var mappingArg = arg.First();
if (!Equals(mappingArg.Types.First(), Typs.Tags))
{
return(null);
}
string tags;
if (mappingArg is LuaLiteral literal)
{
tags = literal.Lua;
}
else
{
tags = lua.FreeVar("tags");
result += "local " + tags + " = nil\n";
result += Snippets.Convert(lua, tags, mappingArg);
}
var m = lua.FreeVar("m");
result += " local " + m + " = nil\n";
foreach (var(key, func) in mapping.StringToResultFunctions)
{
result += "if (" + tags + "[\"" + key + "\"] ~= nil) then\n";
result += m + " = nil\n";
result += " " +
Snippets.Convert(lua, m,
func.Apply(new LuaLiteral(Typs.String, tags + "[\"" + key + "\"]"))).Indent() + "\n";
result += "\n\n if (" + m + " ~= nil) then\n " +
Combine(assignTo, m) +
"\n end\n";
result += "end\n";
}
return(result);
}
var listDotArgs = new List <IExpression>();
if (UnApply(
UnApply(IsFunc(Funcs.ListDot),
Assign(listDotArgs)),
Assign(arg)
).Invoke(listToMultiply))
{
var listDotArg = arg.First();
if (!(listDotArgs.First().Evaluate(lua.Context) is List <IExpression> functionsToApply))
{
return(null);
}
var result = " " + assignTo + " = " + _neutralValue + "\n";
string tags;
if (listDotArg is LuaLiteral literal)
{
tags = literal.Lua;
}
else
{
tags = lua.FreeVar("tags");
result += " local " + tags + "\n";
result += Snippets.Convert(lua, tags, listDotArg);
}
var m = lua.FreeVar("m");
result += " local " + m + "\n";
foreach (var func in functionsToApply)
{
result += " " + m + " = nil\n";
var subMapping = ExtractSubMapping(func);
if (subMapping != null)
{
var(key, f) = subMapping.Value;
var e = f.Apply(new LuaLiteral(Typs.String, tags + "[\"" + key + "\"]"));
e = e.Optimize();
result += Snippets.Convert(lua, m, e).Indent();
}
else
{
result += Snippets.Convert(lua, m, func.Apply(new LuaLiteral(Typs.Tags, "tags")));
}
result += "\n\n if (" + m + " ~= nil) then\n " + Combine(assignTo, m) + "\n end\n";
}
return(result);
}
throw new NotImplementedException();
}
public abstract string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List <IExpression> args);
public LuaParameterPrinter(ProfileMetaData profile, LuaSkeleton.LuaSkeleton skeleton)
{
_profile = profile;
_skeleton = skeleton;
}
public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List <IExpression> args)
{
var c = lua.Context;
if (!(args[0].Evaluate(c) is List <IExpression> order))
{
return(null);
}
List <Mapping> mappings = new List <Mapping>();
if (!UnApply(
IsFunc(Funcs.StringStringToTags),
IsMapping(mappings)
).Invoke(args[1]))
{
return(null);
}
if (mappings.Count != 1)
{
throw new Exception("Multiple possible implementations at this point - should not happen");
}
if (mappings.Count == 0)
{
}
var mapping = mappings.First();
var tags = args[2];
var varName = "tags";
var result = "";
if (tags is LuaLiteral literal)
{
varName = literal.Lua;
}
else
{
result += Snippets.Convert(lua, "tags", tags);
}
// We _reverse_ the order, so that the _most_ important one is at the _bottom_
// The most important one will then _overwrite_ the result value
order.Reverse();
foreach (var t in order)
{
if (!(t.Evaluate(c) is string key))
{
return(null);
}
var func = mapping.StringToResultFunctions[key];
result += "if (" + varName + "[\"" + key + "\"] ~= nil) then\n";
result += " " + Snippets.Convert(lua, assignTo, func.Apply(new LuaLiteral(Typs.String, "tags[\"" + key + "\"]"))).Indent();
result += "\n";
result += "end\n";
// note: we do not do an 'elseif' as we have to fallthrough
if (result.Contains("tags[\"nil\"]"))
{
Console.WriteLine("EUHM");
}
}
return(result);
}
