public static int OppositeOp(ConditionDoc Cond, EMEDF.EnumDoc NegateEnum, int op)
 {
     if (NegateEnum.Name == "Comparison Type")
     {
         return((int)OppositeComparison[(ComparisonType)op]);
     }
     if (NegateEnum.Values.Count == 2)
     {
         if (!NegateEnum.Values.ContainsKey(op.ToString()))
         {
             throw new ArgumentException();
         }
         return(int.Parse(NegateEnum.Values.Where(e => e.Key != op.ToString()).First().Key));
     }
     foreach (BoolVersion version in Cond.AllBools)
     {
         string val = NegateEnum.Values[op.ToString()];
         if (version.True == val)
         {
             return(int.Parse(NegateEnum.Values.Where(e => e.Value == version.False).First().Key));
         }
         if (version.False == val)
         {
             return(int.Parse(NegateEnum.Values.Where(e => e.Value == version.False).First().Key));
         }
     }
     throw new ArgumentException($"Opposite value of {op} not present for enum {NegateEnum.Name}");
 }
Exemple #2
0
        private void BoolConditionListItem(ConditionData.BoolVersion b, InstructionTranslator.FunctionDoc doc, InstructionTranslator.FunctionDoc baseDoc)
        {
            sb.Append($"<li><code>{Escape(doc.Name)}(");
            FunctionArguments(doc.Args, doc.OptionalArgs, false);
            sb.AppendLine($")</code>");

            EMEDF.ArgDoc  negateArg  = baseDoc.Args.Find(a => a.Name == doc.ConditionDoc.NegateField);
            EMEDF.EnumDoc negateEnum = doc.NegateEnum;
            List <string> details    = new List <string>();

            string getReq(EMEDF.ArgDoc arg, object val, object val2)
            {
                string showVal(object v) => Escape(arg.GetDisplayValue(v).ToString());

                return($"<code>{Escape(arg.DisplayName)} = {showVal(val)}{(val2 == null ? "" : " or " + showVal(val2))}</code>");
            }

            if (b.Required != null)
            {
                foreach (ConditionData.FieldValue req in b.Required)
                {
                    EMEDF.ArgDoc reqArg = baseDoc.Args.Find(a => a.Name == req.Field);
                    if (reqArg != null)
                    {
                        details.Add(getReq(reqArg, req.Value, null));
                    }
                }
            }
            if (negateArg != null && negateEnum != null)
            {
                if (b.True != null)
                {
                    int trueNum = int.Parse(negateEnum.Values.FirstOrDefault(e => e.Value == b.True).Key);
                    if (b.False == null)
                    {
                        details.Add(getReq(negateArg, trueNum, InstructionTranslator.OppositeOp(doc.ConditionDoc, negateEnum, trueNum)));
                    }
                    else
                    {
                        int falseNum = int.Parse(negateEnum.Values.FirstOrDefault(e => e.Value == b.False).Key);
                        details.Add(getReq(negateArg, trueNum, falseNum));
                    }
                }
                else
                {
                    details.Add($"{Escape(negateArg.DisplayName)} = true or false");
                }
            }
            sb.AppendLine($"<br/><span class=\"conddetails\">Where <code>{string.Join(" and ", details)}</code></span></li>");
        }
 public void AddDisplayEnums(Instr instr)
 {
     if (InstrDocs.TryGetValue(instr.Cmd, out EMEDF.InstrDoc doc))
     {
         for (int i = 0; i < doc.Arguments.Length; i++)
         {
             if (i >= instr.Args.Count)
             {
                 break;
             }
             EMEDF.EnumDoc edoc = doc.Arguments[i].EnumDoc;
             if (edoc != null && edoc.DisplayValues.TryGetValue(instr.Args[i].ToString(), out string name))
             {
                 instr.Args[i] = new DisplayArg {
                     DisplayValue = name, Value = instr.Args[i]
                 };
             }
         }
     }
 }
        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,
            });
        }