mirror of
https://github.com/claunia/SabreTools.git
synced 2025-12-16 19:14:27 +00:00
435 lines
18 KiB
C#
435 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using SabreTools.Core;
|
|
using SabreTools.Core.Tools;
|
|
using SabreTools.DatItems;
|
|
using SabreTools.DatItems.Formats;
|
|
using SabreTools.IO;
|
|
|
|
namespace SabreTools.DatFiles.Formats
|
|
{
|
|
/// <summary>
|
|
/// Represents writing a SoftwareList
|
|
/// </summary>
|
|
internal partial class SoftwareList : DatFile
|
|
{
|
|
/// <inheritdoc/>
|
|
protected override ItemType[] GetSupportedTypes()
|
|
{
|
|
return new ItemType[]
|
|
{
|
|
ItemType.DipSwitch,
|
|
ItemType.Disk,
|
|
ItemType.Info,
|
|
ItemType.Rom,
|
|
ItemType.SharedFeature,
|
|
};
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
protected override List<DatItemField> GetMissingRequiredFields(DatItem datItem)
|
|
{
|
|
List<DatItemField> missingFields = new();
|
|
|
|
switch (datItem.ItemType)
|
|
{
|
|
case ItemType.DipSwitch:
|
|
DipSwitch dipSwitch = datItem as DipSwitch;
|
|
if (!dipSwitch.PartSpecified)
|
|
{
|
|
missingFields.Add(DatItemField.Part_Name);
|
|
missingFields.Add(DatItemField.Part_Interface);
|
|
}
|
|
else
|
|
{
|
|
if (string.IsNullOrWhiteSpace(dipSwitch.Part.Name))
|
|
missingFields.Add(DatItemField.Part_Name);
|
|
if (string.IsNullOrWhiteSpace(dipSwitch.Part.Interface))
|
|
missingFields.Add(DatItemField.Part_Interface);
|
|
}
|
|
if (string.IsNullOrWhiteSpace(dipSwitch.Name))
|
|
missingFields.Add(DatItemField.Name);
|
|
if (string.IsNullOrWhiteSpace(dipSwitch.Tag))
|
|
missingFields.Add(DatItemField.Tag);
|
|
if (string.IsNullOrWhiteSpace(dipSwitch.Mask))
|
|
missingFields.Add(DatItemField.Mask);
|
|
if (dipSwitch.ValuesSpecified)
|
|
{
|
|
if (dipSwitch.Values.Any(dv => string.IsNullOrWhiteSpace(dv.Name)))
|
|
missingFields.Add(DatItemField.Part_Feature_Name);
|
|
if (dipSwitch.Values.Any(dv => string.IsNullOrWhiteSpace(dv.Value)))
|
|
missingFields.Add(DatItemField.Part_Feature_Value);
|
|
}
|
|
|
|
break;
|
|
|
|
case ItemType.Disk:
|
|
Disk disk = datItem as Disk;
|
|
if (!disk.PartSpecified)
|
|
{
|
|
missingFields.Add(DatItemField.Part_Name);
|
|
missingFields.Add(DatItemField.Part_Interface);
|
|
}
|
|
else
|
|
{
|
|
if (string.IsNullOrWhiteSpace(disk.Part.Name))
|
|
missingFields.Add(DatItemField.Part_Name);
|
|
if (string.IsNullOrWhiteSpace(disk.Part.Interface))
|
|
missingFields.Add(DatItemField.Part_Interface);
|
|
}
|
|
if (!disk.DiskAreaSpecified)
|
|
{
|
|
missingFields.Add(DatItemField.AreaName);
|
|
}
|
|
else
|
|
{
|
|
if (string.IsNullOrWhiteSpace(disk.DiskArea.Name))
|
|
missingFields.Add(DatItemField.AreaName);
|
|
}
|
|
if (string.IsNullOrWhiteSpace(disk.Name))
|
|
missingFields.Add(DatItemField.Name);
|
|
break;
|
|
|
|
case ItemType.Info:
|
|
Info info = datItem as Info;
|
|
if (string.IsNullOrWhiteSpace(info.Name))
|
|
missingFields.Add(DatItemField.Name);
|
|
break;
|
|
|
|
case ItemType.Rom:
|
|
Rom rom = datItem as Rom;
|
|
if (!rom.PartSpecified)
|
|
{
|
|
missingFields.Add(DatItemField.Part_Name);
|
|
missingFields.Add(DatItemField.Part_Interface);
|
|
}
|
|
else
|
|
{
|
|
if (string.IsNullOrWhiteSpace(rom.Part.Name))
|
|
missingFields.Add(DatItemField.Part_Name);
|
|
if (string.IsNullOrWhiteSpace(rom.Part.Interface))
|
|
missingFields.Add(DatItemField.Part_Interface);
|
|
}
|
|
if (!rom.DataAreaSpecified)
|
|
{
|
|
missingFields.Add(DatItemField.AreaName);
|
|
missingFields.Add(DatItemField.AreaSize);
|
|
}
|
|
else
|
|
{
|
|
if (string.IsNullOrWhiteSpace(rom.DataArea.Name))
|
|
missingFields.Add(DatItemField.AreaName);
|
|
if (!rom.DataArea.SizeSpecified)
|
|
missingFields.Add(DatItemField.AreaSize);
|
|
}
|
|
break;
|
|
|
|
case ItemType.SharedFeature:
|
|
SharedFeature sharedFeature = datItem as SharedFeature;
|
|
if (string.IsNullOrWhiteSpace(sharedFeature.Name))
|
|
missingFields.Add(DatItemField.Name);
|
|
break;
|
|
default:
|
|
// Unsupported ItemTypes should be caught already
|
|
return null;
|
|
}
|
|
|
|
return missingFields;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
|
|
{
|
|
try
|
|
{
|
|
logger.User($"Writing to '{outfile}'...");
|
|
FileStream fs = System.IO.File.Create(outfile);
|
|
|
|
// If we get back null for some reason, just log and return
|
|
if (fs == null)
|
|
{
|
|
logger.Warning($"File '{outfile}' could not be created for writing! Please check to see if the file is writable");
|
|
return false;
|
|
}
|
|
|
|
XmlTextWriter xtw = new(fs, new UTF8Encoding(false))
|
|
{
|
|
Formatting = Formatting.Indented,
|
|
IndentChar = '\t',
|
|
Indentation = 1
|
|
};
|
|
|
|
// Write out the header
|
|
WriteHeader(xtw);
|
|
|
|
// Write out each of the machines and roms
|
|
string lastgame = null;
|
|
|
|
// Use a sorted list of games to output
|
|
foreach (string key in Items.SortedKeys)
|
|
{
|
|
ConcurrentList<DatItem> datItems = Items.FilteredItems(key);
|
|
|
|
// If this machine doesn't contain any writable items, skip
|
|
if (!ContainsWritable(datItems))
|
|
continue;
|
|
|
|
// Resolve the names in the block
|
|
datItems = DatItem.ResolveNames(datItems);
|
|
|
|
for (int index = 0; index < datItems.Count; index++)
|
|
{
|
|
DatItem datItem = datItems[index];
|
|
|
|
// If we have a different game and we're not at the start of the list, output the end of last item
|
|
if (lastgame != null && lastgame.ToLowerInvariant() != datItem.Machine.Name.ToLowerInvariant())
|
|
WriteEndGame(xtw);
|
|
|
|
// If we have a new game, output the beginning of the new item
|
|
if (lastgame == null || lastgame.ToLowerInvariant() != datItem.Machine.Name.ToLowerInvariant())
|
|
WriteStartGame(xtw, datItem);
|
|
|
|
// Check for a "null" item
|
|
datItem = ProcessNullifiedItem(datItem);
|
|
|
|
// Write out the item if we're not ignoring
|
|
if (!ShouldIgnore(datItem, ignoreblanks))
|
|
WriteDatItem(xtw, datItem);
|
|
|
|
// Set the new data to compare against
|
|
lastgame = datItem.Machine.Name;
|
|
}
|
|
}
|
|
|
|
// Write the file footer out
|
|
WriteFooter(xtw);
|
|
|
|
logger.User($"'{outfile}' written!{Environment.NewLine}");
|
|
xtw.Dispose();
|
|
fs.Dispose();
|
|
}
|
|
catch (Exception ex) when (!throwOnError)
|
|
{
|
|
logger.Error(ex);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write out DAT header using the supplied StreamWriter
|
|
/// </summary>
|
|
/// <param name="xtw">XmlTextWriter to output to</param>
|
|
private void WriteHeader(XmlTextWriter xtw)
|
|
{
|
|
xtw.WriteStartDocument();
|
|
xtw.WriteDocType("softwarelist", null, "softwarelist.dtd", null);
|
|
|
|
xtw.WriteStartElement("softwarelist");
|
|
xtw.WriteRequiredAttributeString("name", Header.Name);
|
|
xtw.WriteRequiredAttributeString("description", Header.Description);
|
|
|
|
xtw.Flush();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write out Game start using the supplied StreamWriter
|
|
/// </summary>
|
|
/// <param name="xtw">XmlTextWriter to output to</param>
|
|
/// <param name="datItem">DatItem object to be output</param>
|
|
private void WriteStartGame(XmlTextWriter xtw, DatItem datItem)
|
|
{
|
|
// No game should start with a path separator
|
|
datItem.Machine.Name = datItem.Machine.Name.TrimStart(Path.DirectorySeparatorChar);
|
|
|
|
// Build the state
|
|
xtw.WriteStartElement("software");
|
|
xtw.WriteRequiredAttributeString("name", datItem.Machine.Name);
|
|
if (!string.Equals(datItem.Machine.Name, datItem.Machine.CloneOf, StringComparison.OrdinalIgnoreCase))
|
|
xtw.WriteOptionalAttributeString("cloneof", datItem.Machine.CloneOf);
|
|
xtw.WriteOptionalAttributeString("supported", datItem.Machine.Supported.FromSupported(false));
|
|
|
|
xtw.WriteOptionalElementString("description", datItem.Machine.Description);
|
|
xtw.WriteOptionalElementString("year", datItem.Machine.Year);
|
|
xtw.WriteOptionalElementString("publisher", datItem.Machine.Publisher);
|
|
|
|
xtw.Flush();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write out Game start using the supplied StreamWriter
|
|
/// </summary>
|
|
/// <param name="xtw">XmlTextWriter to output to</param>
|
|
private void WriteEndGame(XmlTextWriter xtw)
|
|
{
|
|
// End software
|
|
xtw.WriteEndElement();
|
|
|
|
xtw.Flush();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write out DatItem using the supplied StreamWriter
|
|
/// </summary>
|
|
/// <param name="xtw">XmlTextWriter to output to</param>
|
|
/// <param name="datItem">DatItem object to be output</param>
|
|
private void WriteDatItem(XmlTextWriter xtw, DatItem datItem)
|
|
{
|
|
// Pre-process the item name
|
|
ProcessItemName(datItem, true);
|
|
|
|
// Build the state
|
|
switch (datItem.ItemType)
|
|
{
|
|
case ItemType.DipSwitch:
|
|
var dipSwitch = datItem as DipSwitch;
|
|
xtw.WriteStartElement("dipswitch");
|
|
xtw.WriteRequiredAttributeString("name", dipSwitch.Name);
|
|
xtw.WriteRequiredAttributeString("tag", dipSwitch.Tag);
|
|
xtw.WriteRequiredAttributeString("mask", dipSwitch.Mask);
|
|
if (dipSwitch.ValuesSpecified)
|
|
{
|
|
foreach (Setting dipValue in dipSwitch.Values)
|
|
{
|
|
xtw.WriteStartElement("dipvalue");
|
|
xtw.WriteRequiredAttributeString("name", dipValue.Name);
|
|
xtw.WriteRequiredAttributeString("value", dipValue.Value);
|
|
xtw.WriteOptionalAttributeString("default", dipValue.Default.FromYesNo());
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Disk:
|
|
var disk = datItem as Disk;
|
|
string diskAreaName = disk.DiskArea?.Name;
|
|
if (string.IsNullOrWhiteSpace(diskAreaName))
|
|
diskAreaName = "cdrom";
|
|
|
|
xtw.WriteStartElement("part");
|
|
xtw.WriteRequiredAttributeString("name", disk.Part?.Name);
|
|
xtw.WriteRequiredAttributeString("interface", disk.Part?.Interface);
|
|
|
|
if (disk.Part?.FeaturesSpecified == true)
|
|
{
|
|
foreach (PartFeature partFeature in disk.Part.Features)
|
|
{
|
|
xtw.WriteStartElement("feature");
|
|
xtw.WriteRequiredAttributeString("name", partFeature.Name);
|
|
xtw.WriteOptionalAttributeString("value", partFeature.Value);
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
xtw.WriteStartElement("diskarea");
|
|
xtw.WriteRequiredAttributeString("name", diskAreaName);
|
|
|
|
xtw.WriteStartElement("disk");
|
|
xtw.WriteRequiredAttributeString("name", disk.Name);
|
|
xtw.WriteOptionalAttributeString("md5", disk.MD5?.ToLowerInvariant());
|
|
xtw.WriteOptionalAttributeString("sha1", disk.SHA1?.ToLowerInvariant());
|
|
if (disk.ItemStatus != ItemStatus.None)
|
|
xtw.WriteOptionalAttributeString("status", disk.ItemStatus.FromItemStatus(false));
|
|
xtw.WriteOptionalAttributeString("writable", disk.Writable.FromYesNo());
|
|
xtw.WriteEndElement();
|
|
|
|
// End diskarea
|
|
xtw.WriteEndElement();
|
|
|
|
// End part
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Info:
|
|
var info = datItem as Info;
|
|
xtw.WriteStartElement("info");
|
|
xtw.WriteRequiredAttributeString("name", info.Name);
|
|
xtw.WriteOptionalAttributeString("value", info.Value);
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.Rom:
|
|
var rom = datItem as Rom;
|
|
string dataAreaName = rom.DataArea?.Name;
|
|
if (string.IsNullOrWhiteSpace(dataAreaName))
|
|
dataAreaName = "rom";
|
|
|
|
xtw.WriteStartElement("part");
|
|
xtw.WriteRequiredAttributeString("name", rom.Part?.Name);
|
|
xtw.WriteRequiredAttributeString("interface", rom.Part?.Interface);
|
|
|
|
if (rom.Part?.FeaturesSpecified == true)
|
|
{
|
|
foreach (PartFeature kvp in rom.Part.Features)
|
|
{
|
|
xtw.WriteStartElement("feature");
|
|
xtw.WriteRequiredAttributeString("name", kvp.Name);
|
|
xtw.WriteOptionalAttributeString("value", kvp.Value);
|
|
xtw.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
xtw.WriteStartElement("dataarea");
|
|
xtw.WriteOptionalAttributeString("name", dataAreaName);
|
|
xtw.WriteOptionalAttributeString("size", rom.DataArea?.Size.ToString());
|
|
xtw.WriteOptionalAttributeString("width", rom.DataArea?.Width?.ToString());
|
|
xtw.WriteOptionalAttributeString("endianness", rom.DataArea?.Endianness.FromEndianness());
|
|
|
|
xtw.WriteStartElement("rom");
|
|
xtw.WriteRequiredAttributeString("name", rom.Name);
|
|
xtw.WriteOptionalAttributeString("size", rom.Size?.ToString());
|
|
xtw.WriteOptionalAttributeString("crc", rom.CRC?.ToLowerInvariant());
|
|
xtw.WriteOptionalAttributeString("md5", rom.MD5?.ToLowerInvariant());
|
|
xtw.WriteOptionalAttributeString("sha1", rom.SHA1?.ToLowerInvariant());
|
|
xtw.WriteOptionalAttributeString("sha256", rom.SHA256?.ToLowerInvariant());
|
|
xtw.WriteOptionalAttributeString("sha384", rom.SHA384?.ToLowerInvariant());
|
|
xtw.WriteOptionalAttributeString("sha512", rom.SHA512?.ToLowerInvariant());
|
|
xtw.WriteOptionalAttributeString("offset", rom.Offset);
|
|
xtw.WriteOptionalAttributeString("value", rom.Value);
|
|
if (rom.ItemStatus != ItemStatus.None)
|
|
xtw.WriteOptionalAttributeString("status", rom.ItemStatus.FromItemStatus(false));
|
|
xtw.WriteOptionalAttributeString("loadflag", rom.LoadFlag.FromLoadFlag());
|
|
xtw.WriteEndElement();
|
|
|
|
// End dataarea
|
|
xtw.WriteEndElement();
|
|
|
|
// End part
|
|
xtw.WriteEndElement();
|
|
break;
|
|
|
|
case ItemType.SharedFeature:
|
|
var sharedFeature = datItem as SharedFeature;
|
|
xtw.WriteStartElement("sharedfeat");
|
|
xtw.WriteRequiredAttributeString("name", sharedFeature.Name);
|
|
xtw.WriteOptionalAttributeString("value", sharedFeature.Value);
|
|
xtw.WriteEndElement();
|
|
break;
|
|
}
|
|
|
|
xtw.Flush();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write out DAT footer using the supplied StreamWriter
|
|
/// </summary>
|
|
/// <param name="xtw">XmlTextWriter to output to</param>
|
|
private void WriteFooter(XmlTextWriter xtw)
|
|
{
|
|
// End software
|
|
xtw.WriteEndElement();
|
|
|
|
// End softwarelist
|
|
xtw.WriteEndElement();
|
|
|
|
xtw.Flush();
|
|
}
|
|
}
|
|
}
|