Esempio n. 1
0
        private Dictionary <string, MxeEntryType> DiscoverTypes(FileStream stream)
        {
            Dictionary <string, List <string> > discoveredTypes = new Dictionary <string, List <string> >();

            foreach (MxeIndexEntry mie in _indexes.Values)
            {
                if (mie.Block.Type == MxeEntryType.Other)
                {
                    string        key       = mie.GetVmTitle();
                    List <string> currTypes = mie.SuggestTypes(stream);
                    if (!discoveredTypes.ContainsKey(key))
                    {
                        discoveredTypes[key] = currTypes;
                    }
                    else
                    {
                        MergeTypeLists(discoveredTypes[key], currTypes);
                    }
                }
            }

            Dictionary <string, MxeEntryType> dts = new Dictionary <string, MxeEntryType>();

            foreach (KeyValuePair <string, List <string> > entry in discoveredTypes)
            {
                MxeEntryType newType = new MxeEntryType(entry.Key, entry.Value);
                MxeEntryType.KnownTypes.Add(entry.Key, newType);
                dts.Add(entry.Key, newType);
                ConfigDiscovery.AddNewMxeType(newType);
            }

            return(dts);
        }
Esempio n. 2
0
        public static MxeEntryType GetEntryType(MxeIndexEntry mie)
        {
            int          length = BitConverter.ToInt32(mie.TypeCode.GetBytes(), 0);
            string       name   = mie.GetVmTitle();
            MxeEntryType ret    = _other;

            if (_knownTypes.ContainsKey(name))
            {
                ret = CheckTypeLength(mie, name, ret);
            }
            else if (name.StartsWith(VIM_PART))
            {
                string oldName = StripAdditionalName(name);
                if (_knownTypes.ContainsKey(oldName))
                {
                    MxeEntryType newType = new MxeEntryType(name, mie.GetExpectedByteWords());
                    newType.Headers = _knownTypes[oldName].Headers.ToArray().ToList(); //cheater clone?
                    while (newType.Headers.Count < newType.Length)
                    {
                        newType.Headers.Add(String.Empty);
                    }

                    ConfigDiscovery.AddNewMxeType(newType);
                    _knownTypes.Add(newType.Type1, newType);
                    ret = newType;
                }
            }

            return(ret);
        }
Esempio n. 3
0
        static void Main(string[] args)
        {
            string fn = @"C:\Program Files (x86)\Steam\steamapps\common\Valkyria Chronicles\data\mx\game_info_game_param.mxe";

            bool wasGivenFile = false;
            bool isSync       = false;
            bool isTest       = false;
            bool isHelp       = false;
            bool writeHex     = false;
            bool writeIndex   = false;

            for (int i = 0; i < args.Length; i++)
            {
                switch (args[i])
                {
                case "-q":
                case "-Q":
                    MxeWord.Verbose = false;
                    break;

                case "-l":
                case "-L":
                    MxeWord.Literal = true;
                    break;

                case "-h":
                case "-H":
                    writeHex = true;
                    break;

                case "-i":
                case "-I":
                    writeIndex = true;
                    break;

                case "-s":
                case "-S":
                    isSync = true;
                    isTest = true;
                    break;

                case "-t":
                case "-T":
                    isTest = true;
                    break;

                case "-r":
                case "-R":
                    isSync = false;
                    isTest = false;
                    break;

                case "help":
                case "Help":
                case "-help":
                case "-Help":
                case "--help":
                case "--Help":
                    isHelp = true;
                    break;

                default:
                    if (args[i].StartsWith("-"))
                    {
                        WriteOutArgumentError(args[i]);
                        return;
                    }
                    else
                    {
                        fn           = args[i];
                        wasGivenFile = true;
                        WriteTargetFile(fn);
                    }
                    break;
                }
            }

            if (!isHelp)
            {
                FigureOutWhatFileToUse(ref fn, ref wasGivenFile);

                Parser.HandleFileOrMethod(fn, isSync, isTest, writeHex, writeIndex);

                if (ConfigDiscovery.HasDiscoveries())
                {
                    ConfigDiscovery.PrintDiscoveries();
                }
                else
                {
                    ConfigDiscovery.DeleteDiscoveryFile();
                }
            }
            else
            {
                WriteOutHelp();
            }

            Console.Out.WriteLine("Closing program...");
        }