// As part of instruction compilation, rewrite all instruction so that they correspond to valid emevd commands. // But don't convert them into instructions yet, since we need to edit control things like condition group register allocation and line skipping. public Instr CompileCond(Intermediate im) { // Mainly NoOp and JSStatement shouldn't be passed in here if (im is Instr imInstr) { // Maybe validate Instrs here? Or just do that in AST conversion return(imInstr); } else if (im is Label label) { string cmd = InstructionID(1014, label.Num); return(new Instr { Name = $"Label{label.Num}", Cmd = cmd, Args = new List <object>() }); } else if (im is CondIntermediate condIm) { Cond cond = condIm.Cond; if (cond is ErrorCond) { // Just quit out here. Error is already recorded elsewhere return(null); } else if (cond is OpCond) { throw new Exception($"Internal error: should have expanded out all subconditions in {im}"); } // The only non-synthetic use of WAIT is in condition groups, and these can just be converted to main group eval with no behavior change. ControlType type = condIm.ControlType; if (type == ControlType.WAIT) { type = ControlType.COND; } string docName = cond.DocName; FunctionDoc functionDoc = CondDocs[docName]; if (!functionDoc.Variants.ContainsKey(type)) { string errName = cond.Always ? $"unconditional {type}" : $"{type} {docName}"; StringBuilder sb = new StringBuilder(); sb.Append($"Compiling {errName} is not supported."); sb.Append($" Only [{string.Join(", ", functionDoc.Variants.Keys)}] are supported."); if (type == ControlType.GOTO && functionDoc.Variants.ContainsKey(ControlType.SKIP)) { sb.Append($" Try using a synthetic label instead."); } throw new FancyNotSupportedException(sb.ToString(), im); } string cmd = functionDoc.Variants[type]; ConditionVariant variant = GetVariantByName(docName, cmd); EMEDF.InstrDoc instrDoc = InstrDocs[cmd]; Instr instr = new Instr { Cmd = cmd, Name = instrDoc.DisplayName, Args = Enumerable.Repeat((object)null, instrDoc.Arguments.Length).ToList() }; int controlVal = condIm.ControlArg; int negateVal = cond is CompareCond cmp ? (int)cmp.Type : variant.TrueOp; if (cond != null && cond.Negate) { if (functionDoc.NegateEnum == null) { throw new FancyNotSupportedException($"No way to negate {functionDoc.Name} compiling {docName} to {instr.Name}", im); } negateVal = OppositeOp(functionDoc.ConditionDoc, functionDoc.NegateEnum, negateVal); } variant.SetInstrArgs(instr, cond, controlVal, negateVal); return(instr); } else { throw new Exception($"Internal error: unable to compile unknown instruction {im}"); } }
public static InstructionTranslator GetTranslator(InstructionDocs docs) { ConditionData conds; if (File.Exists("conditions.json")) { conds = ReadFile("conditions.json"); } else if (File.Exists(@"Resources\conditions.json")) { conds = ReadFile(@"Resources\conditions.json"); } else { conds = ReadStream("conditions.json"); } List <string> games = conds.Games.Select(g => g.Name).ToList(); string game = games.Find(g => docs.ResourceString.StartsWith(g + "-common")); if (game == null) { return(null); } EMEDF emedf = docs.DOC; // Mapping from instruction id, like 3[03] or 1003[11], to EMEDF doc // This is the shorthand used by the config. Dictionary <string, EMEDF.InstrDoc> instrs = emedf.Classes .Where(c => c.Index < 2000 && c.Index != 1014) .SelectMany(c => c.Instructions.Select(i => (InstructionID(c.Index, i.Index), i))) .ToDictionary(e => e.Item1, e => e.Item2); // Account for a command. Each condition/control flow statement should have a unique treatment. HashSet <string> visited = new HashSet <string>(); bool processInfo(string type, string instr) { if (instr == null) { return(false); } if (!instrs.TryGetValue(instr, out EMEDF.InstrDoc doc)) { return(false); } // Console.WriteLine($"{type} {instr}: {doc.Name}"); if (visited.Contains(instr)) { throw new Exception($"{instr} appears twice in condition config for {game}"); } visited.Add(instr); return(true); } foreach (string instr in conds.NoControlFlow) { processInfo("Excluded", instr); } int expectArg(string cmd, string name, object requiredType = null, int pos = -1) { EMEDF.InstrDoc doc = instrs[cmd]; int arg; List <string> names = name.Split('|').ToList(); if (pos >= 0) { if (pos >= doc.Arguments.Length) { throw new ArgumentException($"{doc.Name} doesn't have arg {pos}"); } if (!names.Contains(doc.Arguments[pos].Name)) { throw new ArgumentException($"{doc.Name} arg {pos} dooesn't have name {name}, has {string.Join(", ", doc.Arguments.Select(s => s.Name))}"); } arg = pos; } else { arg = doc.Arguments.ToList().FindIndex(a => names.Contains(a.Name)); if (arg == -1) { throw new ArgumentException($"{doc.Name} doesn't have arg named {name}, has {string.Join(", ", doc.Arguments.Select(s => s.Name))}"); } } if (requiredType is string enumName) { if (doc.Arguments[arg].EnumName != enumName) { throw new ArgumentException($"{doc.Name} arg {name} has enum type {doc.Arguments[arg].EnumName}, not {enumName}"); } } else if (requiredType is ArgType argType) { if (doc.Arguments[arg].Type != (long)argType) { throw new ArgumentException($"{doc.Name} arg {name} has type {doc.Arguments[arg].Type}, not {argType}"); } } else if (requiredType != null) { throw new Exception(requiredType.ToString()); } return(arg); } // Indexed by condition function name Dictionary <string, FunctionDoc> condDocs = new Dictionary <string, FunctionDoc>(); // Indexed by command id Dictionary <string, ConditionSelector> selectors = new Dictionary <string, ConditionSelector>(); int asInt(object obj) => int.Parse(obj.ToString()); void addVariants(ConditionSelector selector, ConditionDoc cond, ControlType use, string cmd, int control = -1) { if (selector.Variants.ContainsKey(cmd)) { throw new Exception($"Already added variants of {cond.Name} for {cmd}"); } selector.Variants[cmd] = new List <ConditionVariant>(); selectors[cmd] = selector; EMEDF.InstrDoc doc = instrs[cmd]; int negateArg = -1; string negateName = cond.IsCompare ? "Comparison Type" : cond.NegateField; EMEDF.EnumDoc negateDoc = null; if (negateName != null) { negateArg = expectArg(cmd, negateName, cond.IsCompare ? "Comparison Type" : null); string negateEnum = doc.Arguments[negateArg].EnumName; // Pretend these are compatible if (negateEnum == "ON/OFF") { negateEnum = "ON/OFF/CHANGE"; } negateDoc = emedf.Enums.Where(d => d.Name == negateEnum).FirstOrDefault(); if (negateDoc == null) { throw new ArgumentException($"Command {cmd} for cond {cond.Name} at arg {negateArg} uses enum which does not exist"); } if (selector.NegateEnum == null) { selector.NegateEnum = negateDoc; } else if (selector.NegateEnum.Name != negateEnum) { throw new ArgumentException($"Command {cmd} for {cond.Name} has negate enum {negateEnum} but {selector.NegateEnum.Name} was already used in a different command"); } } void addVariant(BoolVersion bv = null, CompareVersion cv = null) { ConditionVariant variant = new ConditionVariant { Variant = use }; string name = cond.Name; List <int> ignore = new List <int>(); if (control >= 0) { variant.ControlArg = control; ignore.Add(control); } if (negateArg >= 0 && (cv != null || bv != null)) { variant.NegateArg = negateArg; ignore.Add(negateArg); } if (bv != null) { name = bv.Name; if (negateDoc == null) { throw new ArgumentException($"Cond {cond.Name} has boolean variant {name} but no negate_field"); } string trueVal = negateDoc.Name == "BOOL" ? "TRUE" : bv.True; string trueKey = negateDoc.Values.Where(e => e.Value == trueVal).First().Key; variant.TrueOp = asInt(trueKey); if (bv.Required != null) { foreach (FieldValue req in bv.Required) { int reqArg = expectArg(cmd, req.Field); variant.ExtraArgs[reqArg] = req.Value; ignore.Add(reqArg); } } } else if (cv != null) { name = cv.Name; if (cv.Rhs == null) { throw new ArgumentException($"Cond {cond.Name} has compare variant {name} with no RHS specified"); } variant.CompareArg = expectArg(cmd, cv.Rhs); ignore.Add(variant.CompareArg); if (cv.Lhs != null) { variant.CompareArg2 = expectArg(cmd, cv.Lhs); ignore.Add(variant.CompareArg2); } } if (name == null) { throw new ArgumentException($"Name for {cond.Name} and {cmd} is missing"); } EMEDF.ArgDoc optArgDoc = null; // Optional args serve two purposes: to hide noisy default values, and to address inconsistencies between variants. // In all cases, they can be established from the COND variant. if (use == ControlType.COND && cond.OptFields != null) { for (int i = 0; i < cond.OptFields.Count; i++) { if (doc.Arguments[doc.Arguments.Length - cond.OptFields.Count + i].Name != cond.OptFields[i]) { break; } } bool matching = cond.OptFields.Select((a, i) => a == doc.Arguments[doc.Arguments.Length - cond.OptFields.Count + i].Name).All(b => b); // Missing opt args can happen when "# of target character"-type arguments get added over time. // This is mostly a pretty-printing feature. so it might be tedious to specify each individual change between games. if (matching) { int optArg = doc.Arguments.Length - cond.OptFields.Count; if (ignore.Contains(optArg)) { throw new Exception($"Optional arg {cond.OptFields[0]} is not part of the normal argument list for {name} with {cmd}"); } optArgDoc = doc.Arguments[optArg]; } } // Non-control-flow arguments should match for all uses of a condition, across goto/skip/etc. commands // (other than for optional args) List <EMEDF.ArgDoc> condArgs = doc.Arguments.Where((a, i) => !ignore.Contains(i)).ToList(); if (condDocs.TryGetValue(name, out FunctionDoc condDoc)) { string older = string.Join(", ", condDoc.Args.Select(a => a.Name)); string newer = string.Join(", ", condArgs.Select(a => a.Name)); bool matching = older == newer; if (!matching && condDoc.OptionalArgs > 0) { // This is only permissible if the existing definition has optional args, in which case the shared segment should still match. older = string.Join(", ", condDoc.Args.Take(condDoc.Args.Count - condDoc.OptionalArgs).Select(a => a.Name)); matching = older == newer; } if (!matching) { throw new Exception($"Multiple possible definitions found for {name}: [{older}] existing vs [{newer}] for {cmd}. opt args {condDoc.OptionalArgs}"); } } else { condDocs[name] = condDoc = new FunctionDoc { Name = name, Args = condArgs, ConditionDoc = cond, NegateEnum = negateDoc, }; if (optArgDoc != null) { condDoc.OptionalArgs = condArgs.Count - condArgs.IndexOf(optArgDoc); } } condDoc.Variants[use] = cmd; variant.Doc = condDoc; selector.Variants[cmd].Add(variant); } foreach (BoolVersion version in cond.AllBools) { addVariant(bv: version); } foreach (CompareVersion version in cond.AllCompares) { addVariant(cv: version); } addVariant(); } foreach (ConditionDoc cond in conds.Conditions) { ConditionSelector selector = new ConditionSelector { Cond = cond }; if (cond.Games != null && !cond.Games.Contains(game)) { continue; } if (processInfo($"Cond {cond.Name}", cond.Cond)) { // The cond variant should go first, as it can have a superset of other variants' args if marked in the config. expectArg(cond.Cond, "Result Condition Group", "Condition Group", 0); addVariants(selector, cond, ControlType.COND, cond.Cond, 0); } if (processInfo($"Skip {cond.Name}", cond.Skip)) { expectArg(cond.Skip, "Number Of Skipped Lines", EMEVD.Instruction.ArgType.Byte, 0); addVariants(selector, cond, ControlType.SKIP, cond.Skip, 0); } if (processInfo($"End {cond.Name}", cond.End)) { expectArg(cond.End, "Execution End Type", "Event End Type", 0); addVariants(selector, cond, ControlType.END, cond.End, 0); } if (processInfo($"Goto {cond.Name}", cond.Goto)) { expectArg(cond.Goto, "Label", "Label", 0); addVariants(selector, cond, ControlType.GOTO, cond.Goto, 0); } if (processInfo($"Wait {cond.Name}", cond.Wait)) { // Implicit main arg addVariants(selector, cond, ControlType.WAIT, cond.Wait); } } string undocError = string.Join(", ", instrs.Where(e => !visited.Contains(e.Key)).Select(e => $"{e.Key}:{e.Value.Name}")); if (undocError.Length > 0) { // This doesn't have to be an error, but it does mean that condition group decompilation is impossible when these commands are present. throw new ArgumentException($"Present in emedf but not condition config for {game}: {undocError}"); } Dictionary <string, int> labels = new Dictionary <string, int>(); EMEDF.ClassDoc labelClass = emedf[1014]; if (labelClass != null) { labels = labelClass.Instructions.ToDictionary(i => InstructionID(1014, i.Index), i => (int)i.Index); } return(new InstructionTranslator { CondDocs = condDocs, Selectors = selectors, InstrDocs = instrs, LabelDocs = labels, }); }
private static string GenerateNvimMethods( IEnumerable <NvimFunction> functions, string prefixToRemove, bool isVirtualMethod) => string.Join("", functions.Select(function => { if (!function.Name.StartsWith(prefixToRemove)) { throw new Exception( $"Function {function.Name} does not " + $"have expected prefix \"{prefixToRemove}\""); } FunctionDoc doc = null; _functionDocs?.TryGetValue(function.Name, out doc); var camelCaseName = StringUtil.ConvertToCamelCase( function.Name.Substring(prefixToRemove.Length), true); var sendAccess = function.Method ? "_api." : string.Empty; var returnType = NvimTypesMap.GetCSharpType(function.ReturnType); var genericTypeParam = returnType == "void" ? string.Empty : $"<{returnType}>"; var parameters = (isVirtualMethod ? function.Parameters.Skip(1) : function.Parameters) .Select(param => new { param.Type, // Prefix every parameter name with the verbatim identifier `@` // to prevent them from being interpreted as keywords. // In the future, it might be worth considering adding a list // of all C# keywords and only adding the prefix to parameter // names that are in the list. Name = "@" + StringUtil.ConvertToCamelCase(param.Name, false) }).ToArray(); return($@"{string.Join(string.Empty, GetDocElement("summary", doc?.Summary).Concat( doc?.Parameters .Where(param => function.Parameters.Any(p => p.Name == param.Name) && (!isVirtualMethod || param.Name != function.Parameters.First().Name)) .SelectMany(param => GetDocElement("param", param.Description, $@"name=""{ StringUtil.ConvertToCamelCase(param.Name, false)}""")) ?? Enumerable.Empty<string>()).Concat( GetDocElement("returns", doc?.Return)).Concat( GetDocElement("remarks", doc?.Notes)).Select(docLine => $@" /// {docLine}"))} public Task{genericTypeParam} {camelCaseName}({string.Join(", ", parameters.Select(param => $"{NvimTypesMap.GetCSharpType(param.Type)} {param.Name}"))}) => {sendAccess}SendAndReceive{genericTypeParam}(new NvimRequest {{ Method = ""{function.Name}"", Arguments = GetRequestArguments( {string.Join(", ", (isVirtualMethod ? new[] {"_msgPackExtObj"} : Enumerable.Empty<string>()) .Concat(parameters.Select(param => param.Name)))}) }}); "); }));