コード例 #1
0
        /// <summary>
        /// Read game/machine information
        /// </summary>
        /// <param name="reader">XmlReader to use to parse the machine</param>
        /// <param name="dirs">List of dirs to prepend to the game name</param>
        /// <param name="filename">Name of the file to be parsed</param>
        /// <param name="indexId">Index ID for the DAT</param>
        /// <param name="keep">True if full pathnames are to be kept, false otherwise (default)</param>
        private void ReadMachine(
            XmlReader reader,
            List <string> dirs,

            // Standard Dat parsing
            string filename,
            int indexId,

            // Miscellaneous
            bool keep)
        {
            // If we have an empty machine, skip it
            if (reader == null)
            {
                return;
            }

            // Otherwise, add what is possible
            reader.MoveToContent();

            string key           = string.Empty;
            string temptype      = reader.Name;
            bool   containsItems = false;

            // Create a new machine
            MachineType machineType = 0x0;

            if (reader.GetAttribute("isbios").AsYesNo() == true)
            {
                machineType |= MachineType.Bios;
            }

            if (reader.GetAttribute("isdevice").AsYesNo() == true) // Listxml-specific, used by older DATs
            {
                machineType |= MachineType.Device;
            }

            if (reader.GetAttribute("ismechanical").AsYesNo() == true) // Listxml-specific, used by older DATs
            {
                machineType |= MachineType.Mechanical;
            }

            string  dirsString = (dirs != null && dirs.Count() > 0 ? string.Join("/", dirs) + "/" : string.Empty);
            Machine machine    = new Machine
            {
                Name        = dirsString + reader.GetAttribute("name"),
                Description = dirsString + reader.GetAttribute("name"),
                SourceFile  = reader.GetAttribute("sourcefile"),
                Board       = reader.GetAttribute("board"),
                RebuildTo   = reader.GetAttribute("rebuildto"),
                Runnable    = reader.GetAttribute("runnable").AsRunnable(), // Used by older DATs

                CloneOf  = reader.GetAttribute("cloneof"),
                RomOf    = reader.GetAttribute("romof"),
                SampleOf = reader.GetAttribute("sampleof"),

                MachineType = (machineType == 0x0 ? MachineType.NULL : machineType),
            };

            if (Header.Type == "SuperDAT" && !keep)
            {
                string tempout = Regex.Match(machine.Name, @".*?\\(.*)").Groups[1].Value;
                if (!string.IsNullOrWhiteSpace(tempout))
                {
                    machine.Name = tempout;
                }
            }

            while (!reader.EOF)
            {
                // We only want elements
                if (reader.NodeType != XmlNodeType.Element)
                {
                    reader.Read();
                    continue;
                }

                // Get the roms from the machine
                switch (reader.Name)
                {
                case "comment":     // There can be multiple comments by spec
                    machine.Comment += reader.ReadElementContentAsString();
                    break;

                case "description":
                    machine.Description = reader.ReadElementContentAsString();
                    break;

                case "year":
                    machine.Year = reader.ReadElementContentAsString();
                    break;

                case "manufacturer":
                    machine.Manufacturer = reader.ReadElementContentAsString();
                    break;

                case "publisher":     // Not technically supported but used by some legacy DATs
                    machine.Publisher = reader.ReadElementContentAsString();
                    break;

                case "category":     // Not technically supported but used by some legacy DATs
                    machine.Category = reader.ReadElementContentAsString();
                    break;

                case "trurip":     // This is special metadata unique to EmuArc
                    ReadTruRip(reader.ReadSubtree(), machine);

                    // Skip the trurip node now that we've processed it
                    reader.Skip();
                    break;

                case "archive":
                    containsItems = true;

                    DatItem archive = new Archive
                    {
                        Name = reader.GetAttribute("name"),

                        Source = new Source
                        {
                            Index = indexId,
                            Name  = filename,
                        },
                    };

                    archive.CopyMachineInformation(machine);

                    // Now process and add the archive
                    key = ParseAddHelper(archive);

                    reader.Read();
                    break;

                case "biosset":
                    containsItems = true;

                    DatItem biosSet = new BiosSet
                    {
                        Name        = reader.GetAttribute("name"),
                        Description = reader.GetAttribute("description"),
                        Default     = reader.GetAttribute("default").AsYesNo(),

                        Source = new Source
                        {
                            Index = indexId,
                            Name  = filename,
                        },
                    };

                    biosSet.CopyMachineInformation(machine);

                    // Now process and add the biosSet
                    key = ParseAddHelper(biosSet);

                    reader.Read();
                    break;

                case "disk":
                    containsItems = true;

                    DatItem disk = new Disk
                    {
                        Name       = reader.GetAttribute("name"),
                        MD5        = reader.GetAttribute("md5"),
                        SHA1       = reader.GetAttribute("sha1"),
                        MergeTag   = reader.GetAttribute("merge"),
                        ItemStatus = reader.GetAttribute("status").AsItemStatus(),

                        Source = new Source
                        {
                            Index = indexId,
                            Name  = filename,
                        },
                    };

                    disk.CopyMachineInformation(machine);

                    // Now process and add the disk
                    key = ParseAddHelper(disk);

                    reader.Read();
                    break;

                case "media":
                    containsItems = true;

                    DatItem media = new Media
                    {
                        Name    = reader.GetAttribute("name"),
                        MD5     = reader.GetAttribute("md5"),
                        SHA1    = reader.GetAttribute("sha1"),
                        SHA256  = reader.GetAttribute("sha256"),
                        SpamSum = reader.GetAttribute("spamsum"),

                        Source = new Source
                        {
                            Index = indexId,
                            Name  = filename,
                        },
                    };

                    media.CopyMachineInformation(machine);

                    // Now process and add the media
                    key = ParseAddHelper(media);

                    reader.Read();
                    break;

                case "release":
                    containsItems = true;

                    DatItem release = new Release
                    {
                        Name     = reader.GetAttribute("name"),
                        Region   = reader.GetAttribute("region"),
                        Language = reader.GetAttribute("language"),
                        Date     = reader.GetAttribute("date"),
                        Default  = reader.GetAttribute("default").AsYesNo(),
                    };

                    release.CopyMachineInformation(machine);

                    // Now process and add the release
                    key = ParseAddHelper(release);

                    reader.Read();
                    break;

                case "rom":
                    containsItems = true;

                    DatItem rom = new Rom
                    {
                        Name = reader.GetAttribute("name"),
                        Size = Sanitizer.CleanLong(reader.GetAttribute("size")),
                        CRC  = reader.GetAttribute("crc"),
                        MD5  = reader.GetAttribute("md5"),
#if NET_FRAMEWORK
                        RIPEMD160 = reader.GetAttribute("ripemd160"),
#endif
                        SHA1       = reader.GetAttribute("sha1"),
                        SHA256     = reader.GetAttribute("sha256"),
                        SHA384     = reader.GetAttribute("sha384"),
                        SHA512     = reader.GetAttribute("sha512"),
                        SpamSum    = reader.GetAttribute("spamsum"),
                        MergeTag   = reader.GetAttribute("merge"),
                        ItemStatus = reader.GetAttribute("status").AsItemStatus(),
                        Date       = Sanitizer.CleanDate(reader.GetAttribute("date")),
                        Inverted   = reader.GetAttribute("inverted").AsYesNo(),

                        Source = new Source
                        {
                            Index = indexId,
                            Name  = filename,
                        },
                    };

                    rom.CopyMachineInformation(machine);

                    // Now process and add the rom
                    key = ParseAddHelper(rom);

                    reader.Read();
                    break;

                case "sample":
                    containsItems = true;

                    DatItem sample = new Sample
                    {
                        Name = reader.GetAttribute("name"),

                        Source = new Source
                        {
                            Index = indexId,
                            Name  = filename,
                        },
                    };

                    sample.CopyMachineInformation(machine);

                    // Now process and add the sample
                    key = ParseAddHelper(sample);

                    reader.Read();
                    break;

                default:
                    reader.Read();
                    break;
                }
            }

            // If no items were found for this machine, add a Blank placeholder
            if (!containsItems)
            {
                Blank blank = new Blank()
                {
                    Source = new Source
                    {
                        Index = indexId,
                        Name  = filename,
                    },
                };

                blank.CopyMachineInformation(machine);

                // Now process and add the rom
                ParseAddHelper(blank);
            }
        }