public static RvFile ConvertFromExternalDat(DatHeader datHeaderExternal, RvDat datFile)
{
RvFile newDirFromExternal = new RvFile(FileType.Dir);
RvDat newDatFromExternal = new RvDat();
newDatFromExternal.SetData(RvDat.DatData.DatRootFullName, datFile.GetData(RvDat.DatData.DatRootFullName));
newDatFromExternal.TimeStamp = datFile.TimeStamp;
newDatFromExternal.Status = DatUpdateStatus.Correct;
newDatFromExternal.SetData(RvDat.DatData.DatName, datHeaderExternal.Name);
newDatFromExternal.SetData(RvDat.DatData.RootDir, datHeaderExternal.RootDir);
newDatFromExternal.SetData(RvDat.DatData.Description, datHeaderExternal.Description);
newDatFromExternal.SetData(RvDat.DatData.Category, datHeaderExternal.Category);
newDatFromExternal.SetData(RvDat.DatData.Version, datHeaderExternal.Version);
newDatFromExternal.SetData(RvDat.DatData.Date, datHeaderExternal.Date);
newDatFromExternal.SetData(RvDat.DatData.Author, datHeaderExternal.Author);
newDatFromExternal.SetData(RvDat.DatData.Email, datHeaderExternal.Email);
newDatFromExternal.SetData(RvDat.DatData.HomePage, datHeaderExternal.Homepage);
newDatFromExternal.SetData(RvDat.DatData.URL, datHeaderExternal.URL);
newDatFromExternal.SetData(RvDat.DatData.DirSetup, datHeaderExternal.Dir);
newDatFromExternal.SetData(RvDat.DatData.Header, datHeaderExternal.Header);
newDatFromExternal.MultiDatsInDirectory = datFile.MultiDatsInDirectory;
newDatFromExternal.MultiDatOverride = datFile.MultiDatOverride;
newDirFromExternal.Dat = newDatFromExternal;
HeaderFileType headerFileType = FileHeaderReader.FileHeaderReader.GetFileTypeFromHeader(datHeaderExternal.Header);
CopyDir(datHeaderExternal.BaseDir, newDirFromExternal, newDatFromExternal, headerFileType, false);
return(newDirFromExternal);
}
private bool LoadHeaderFromDat(XmlDocument doc, DatHeader datHeader)
{
XmlNodeList head = doc.SelectNodes("softwarelist");
if (head == null)
{
return(false);
}
if (head.Count == 0)
{
return(false);
}
if (head[0].Attributes == null)
{
return(false);
}
datHeader.Filename = _filename;
datHeader.Name = VarFix.String(head[0].Attributes.GetNamedItem("name"));
datHeader.Description = VarFix.String(head[0].Attributes.GetNamedItem("description"));
return(true);
}
public static void WriteDat(System.IO.Stream strOut, DatHeader datHeader, bool newStyle = false)
{
using (DatStreamWriter sw = new DatStreamWriter(strOut))
{
WriteToStream(sw, datHeader, newStyle);
}
}
private static bool LoadCredits(DatFileLoader dfl, DatHeader datHeader, ReportError errorReport)
{
if (dfl.Next.ToLower() != "[credits]")
{
errorReport?.Invoke(dfl.Filename, "Looking for [CREDITS] but found " + dfl.Next + " , " + dfl.LineNumber);
return(false);
}
while (!dfl.EndOfStream())
{
string line = dfl.Gn();
if (line.Substring(0, 1) == "[")
{
return(true);
}
string element;
string value;
if (!splitLine(line, out element, out value))
{
return(false);
}
switch (element.ToLower())
{
case "author":
datHeader.Author = value;
break;
case "email":
datHeader.Email = value;
break;
case "homepage":
datHeader.URL = value;
break;
case "url":
datHeader.URL = value;
break;
case "version":
datHeader.Version = value;
break;
case "date":
datHeader.Date = value;
break;
case "comment":
datHeader.Comment = value;
break;
default:
errorReport?.Invoke(dfl.Filename, "Unknown Line " + dfl.Next + " found in [CREDITS], " + dfl.LineNumber);
return(false);
}
}
return(true);
}
private static void WriteToStream(DatStreamWriter sw, DatHeader datHeader, bool newStyle)
{
sw.WriteLine("<?xml version=\"1.0\"?>");
if (newStyle)
{
sw.WriteLine("<RVDatFile>", 1);
}
else
{
sw.WriteLine("<DatFile>", 1);
}
WriteHeader(sw, datHeader);
writeBase(sw, datHeader.BaseDir, newStyle);
if (newStyle)
{
sw.WriteLine("</RVDatFile>", -1);
}
else
{
sw.WriteLine("</DatFile>", -1);
}
}
// private static CultureInfo enUS = new CultureInfo("en-US");
public static RvDat ConvertFromExternalDat(string strFilename, DatHeader datHeaderExternal)
{
RvDat retDat = new RvDat
{
Filename = Path.GetFileName(strFilename),
Name = datHeaderExternal.Name,
RootDir = datHeaderExternal.RootDir,
Description = datHeaderExternal.Description,
Category = datHeaderExternal.Category,
Version = datHeaderExternal.Version,
Date = datHeaderExternal.Date,
Author = datHeaderExternal.Author,
Email = datHeaderExternal.Email,
Homepage = datHeaderExternal.Homepage,
URL = datHeaderExternal.URL,
Comment = datHeaderExternal.Comment,
MergeType = datHeaderExternal.MergeType
};
HeaderFileType headerFileType = FileHeaderReader.FileHeaderReader.GetFileTypeFromHeader(datHeaderExternal.Header);
CopyDir(datHeaderExternal.BaseDir, headerFileType, retDat);
return(retDat);
}
private static void SetMergeType(MergeType mt, DatHeader dh)
{
bool hasRom = DatHasRomOf.HasRomOf(dh.BaseDir);
if (hasRom)
{
switch (mt)
{
case MergeType.Merge:
DatClean.DatSetMakeMergeSet(dh.BaseDir);
break;
case MergeType.NonMerged:
DatClean.DatSetMakeNonMergeSet(dh.BaseDir);
break;
case MergeType.Split:
DatClean.DatSetMakeSplitSet(dh.BaseDir);
//DatClean.RemoveNotCollected(dh.BaseDir);
break;
case MergeType.CHDsMerge:
DatClean.DatSetMakeMergeSet(dh.BaseDir, false);
break;
}
DatClean.RemoveDupes(dh.BaseDir);
DatClean.RemoveEmptySets(dh.BaseDir);
}
}
public static void MakeDatSingleLevel(DatHeader tDatHeader)
{
DatBase[] db = tDatHeader.BaseDir.ToArray();
tDatHeader.Dir = "noautodir";
tDatHeader.BaseDir.ChildrenClear();
DatDir root = new DatDir(DatFileType.UnSet)
{
Name = tDatHeader.Name,
DGame = new DatGame {
Description = tDatHeader.Description
}
};
tDatHeader.BaseDir.ChildAdd(root);
foreach (DatBase set in db)
{
string dirName = set.Name;
if (!(set is DatDir romSet))
{
continue;
}
DatBase[] dbr = romSet.ToArray();
foreach (DatBase rom in dbr)
{
rom.Name = dirName + "\\" + rom.Name;
root.ChildAdd(rom);
}
}
}
public static bool ReadDat(string strFilename, ReportError errorReport, out DatHeader datHeader)
{
using (DatFileLoader dfl = new DatFileLoader())
{
datHeader = new DatHeader {
BaseDir = new DatDir(DatFileType.UnSet)
};
int errorCode = dfl.LoadDat(strFilename, DatRead.Enc);
if (errorCode != 0)
{
errorReport?.Invoke(strFilename, new Win32Exception(errorCode).Message);
return(false);
}
dfl.Gn();
if (dfl.EndOfStream())
{
return(false);
}
if (dfl.Next.ToLower() == "clrmamepro" || dfl.Next.ToLower() == "clrmame")
{
if (!LoadHeaderFromDat(dfl, strFilename, datHeader, errorReport))
{
return(false);
}
dfl.Gn();
}
if (dfl.Next.ToLower() == "raine")
{
while (dfl.Next.ToLower() != "emulator")
{
dfl.Gn();
}
if (!LoadHeaderFromDat(dfl, strFilename, datHeader, errorReport))
{
return(false);
}
dfl.Gn();
}
if (dfl.Next.ToLower() == "romvault")
{
if (!LoadHeaderFromDat(dfl, strFilename, datHeader, errorReport))
{
return(false);
}
dfl.Gn();
}
while (!dfl.EndOfStream())
{
bool res = ReadNextBlock(dfl, datHeader.BaseDir, errorReport);
if (!res)
{
return(false);
}
}
}
return(true);
}
private static bool ReadXMLDat(string fullname, ReportError ErrorReport, out DatHeader rvDat)
{
rvDat = null;
int errorCode = FileStream.OpenFileRead(fullname, out Stream fs);
if (errorCode != 0)
{
ErrorReport?.Invoke(fullname, errorCode + ": " + new Win32Exception(errorCode).Message);
return(false);
}
bool retVal = false;
try
{
retVal = ReadXMLDatFromStream(fs, fullname, ErrorReport, out rvDat);
}
catch (Exception e)
{
fs.Close();
fs.Dispose();
ErrorReport?.Invoke(fullname, $"Error Occured Reading Dat:\r\n{e.Message}\r\n");
return(false);
}
fs.Close();
fs.Dispose();
return(retVal);
}
public bool ReadDat(string fullname, out DatHeader rvDat)
{
rvDat = null;
System.Diagnostics.Debug.WriteLine("Reading : " + fullname);
StreamReader myfile = File.OpenText(fullname, Enc);
string strLine = null;
while (string.IsNullOrWhiteSpace(strLine) && !myfile.EndOfStream)
{
strLine = myfile.ReadLine();
}
myfile.Close();
if (strLine == null)
{
return(false);
}
if (strLine.ToLower().IndexOf("xml", StringComparison.Ordinal) >= 0)
{
if (!ReadXMLDat(fullname, out rvDat))
{
return(false);
}
}
else if ((strLine.ToLower().IndexOf("clrmamepro", StringComparison.Ordinal) >= 0) || (strLine.ToLower().IndexOf("clrmame", StringComparison.Ordinal) >= 0) || (strLine.ToLower().IndexOf("romvault", StringComparison.Ordinal) >= 0) || (strLine.ToLower().IndexOf("game", StringComparison.Ordinal) >= 0) || (strLine.ToLower().IndexOf("machine", StringComparison.Ordinal) >= 0))
{
DatCmpReader dcr = new DatCmpReader(ErrorReport);
if (!dcr.ReadDat(fullname, out rvDat))
{
return(false);
}
}
else if (strLine.ToLower().IndexOf("doscenter", StringComparison.Ordinal) >= 0)
{
DatDOSReader ddr = new DatDOSReader(ErrorReport);
if (!ddr.ReadDat(fullname, out rvDat))
{
return(false);
}
}
else if (strLine.ToLower().IndexOf("[credits]", StringComparison.Ordinal) >= 0)
{
DatROMCenterReader drcr = new DatROMCenterReader(ErrorReport);
if (!drcr.ReadDat(fullname, out rvDat))
{
return(false);
}
}
else
{
ErrorReport?.Invoke(fullname, "Invalid DAT File");
return(false);
}
return(true);
}
public void WriteDat(string strFilename, DatHeader datHeader, bool newStyle = false)
{
string dir = Path.GetDirectoryName(strFilename);
if (!string.IsNullOrWhiteSpace(dir) && !Directory.Exists(dir))
{
System.IO.Directory.CreateDirectory(dir);
}
using (dsw sw = new dsw(strFilename))
{
sw.WriteLine("<?xml version=\"1.0\"?>");
if (newStyle)
{
sw.WriteLine("<RVDatFile>", 1);
}
else
{
sw.WriteLine("<DatFile>", 1);
}
WriteHeader(sw, datHeader);
writeBase(sw, datHeader.BaseDir, newStyle);
if (newStyle)
{
sw.WriteLine("</RVDatFile>", -1);
}
else
{
sw.WriteLine("</DatFile>", -1);
}
}
}
protected DatFile BuildGenericDatFile(DatFileAttribute attribute)
{
DatHeader header = new DatHeader(Convert.ToUInt32(attribute.Translations.Count));
List <IndexTableRecord> indexTableRecords = new List <IndexTableRecord>();
List <ValueTableRecord> valueTableRecords = new List <ValueTableRecord>();
List <KeyTableRecord> keyTableRecords = new List <KeyTableRecord>();
foreach (Translation translation in attribute.Translations)
{
ValueTableRecord valueTableRecord = new ValueTableRecord(translation.Value);
valueTableRecords.Add(valueTableRecord);
KeyTableRecord keyTableRecord = new KeyTableRecord(translation.Key);
keyTableRecords.Add(keyTableRecord);
IndexTableRecord indexTableRecord = new IndexTableRecord(
translation.Crc32,
Convert.ToUInt32(keyTableRecord.Key.Length),
Convert.ToUInt32(valueTableRecord.Value.Length));
indexTableRecords.Add(indexTableRecord);
}
IndexTable indexTable = new IndexTable(indexTableRecords);
ValueTable valueTable = new ValueTable(valueTableRecords);
KeyTable keyTable = new KeyTable(keyTableRecords);
return(new DatFile(header, indexTable, valueTable, keyTable));
}
private static bool isFile(DatRule datRule, DatHeader dh)
{
FileType ft = datRule.Compression;
if (!datRule.CompressionOverrideDAT)
{
switch (dh.Compression?.ToLower())
{
case "unzip":
case "file":
ft = FileType.Dir;
break;
case "7zip":
case "7z":
ft = FileType.SevenZip;
break;
case "zip":
ft = FileType.Zip;
break;
}
}
if (Settings.rvSettings.FilesOnly)
{
ft = FileType.Dir;
}
return(ft == FileType.Dir);
}
public static void WriteDat(System.IO.Stream strOut, DatHeader datHeader)
{
using (DatStreamWriter sw = new DatStreamWriter(strOut))
{
WriteToStream(sw, datHeader);
}
}
/// <inheritdoc/>
public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
{
// Open a file reader
Encoding enc = filename.GetEncoding();
SeparatedValueReader svr = new SeparatedValueReader(File.OpenRead(filename), enc)
{
Header = true,
Quotes = true,
Separator = _delim,
VerifyFieldCount = true,
};
// If we're somehow at the end of the stream already, we can't do anything
if (svr.EndOfStream)
{
return;
}
// Read in the header
svr.ReadHeader();
// Loop through all of the data lines
while (!svr.EndOfStream)
{
try
{
// Get the current line, split and parse
svr.ReadNextLine();
// Create mapping dictionaries
Setter setter = new Setter();
setter.PopulateSettersFromList(svr.HeaderValues, svr.Line);
// Set DatHeader fields
DatHeader datHeader = new DatHeader();
setter.SetFields(datHeader);
Header.ConditionalCopy(datHeader);
// Set Machine and DatItem fields
if (setter.DatItemMappings.ContainsKey(DatItemField.Type))
{
DatItem datItem = DatItem.Create(setter.DatItemMappings[DatItemField.Type].AsItemType());
setter.SetFields(datItem);
datItem.Machine = new Machine();
setter.SetFields(datItem.Machine);
datItem.Source = new Source(indexId, filename);
ParseAddHelper(datItem, statsOnly);
}
}
catch (Exception ex) when(!throwOnError)
{
string message = $"'{filename}' - There was an error parsing line {svr.LineNumber} '{svr.CurrentLine}'";
logger.Error(ex, message);
}
}
svr.Dispose();
}
protected virtual bool ParseDat(BinaryReader stream)
{
stream.BaseStream.Seek(0x04, SeekOrigin.Begin);
header = new DatHeader {
fileSize = XorTools.ReadXorInt32(stream),
dataSize = XorTools.ReadXorInt32(stream) + 16,
};
return((stream.BaseStream.Length - header.fileSize) == 32);
}
public DatFile Build(byte[] bytes)
{
DatHeader header = BuildDatHeader(bytes);
IndexTable indexTable = BuildIndexTable(bytes, header.KeyCount);
ValueTable valueTable = BuildValueTable(bytes, indexTable, header.KeyCount);
KeyTable keyTable = BuildKeyTable(bytes, indexTable, header.KeyCount);
return(new DatFile(header, indexTable, valueTable, keyTable));
}
protected DatFile FromBytesInternal([NotNull] byte[] bytes)
{
DatHeader header = BuildDatHeaderFromBytesInternal(bytes);
IndexTable indexTable = BuildIndexTableFromBytesInternal(bytes, header.KeyCount);
ValueTable valueTable = BuildValueTableFromBytesInternal(bytes, indexTable, header.KeyCount);
KeyTable keyTable = BuildKeyTableFromBytesInternal(bytes, indexTable, header.KeyCount);
return(new DatFile(header, indexTable, valueTable, keyTable));
}
private static bool ReadXMLDat(string fullname, ReportError ErrorReport, out DatHeader rvDat)
{
rvDat = null;
int errorCode = FileStream.OpenFileRead(fullname, out Stream fs);
if (errorCode != 0)
{
ErrorReport?.Invoke(fullname, errorCode + ": " + new Win32Exception(errorCode).Message);
return(false);
}
XmlDocument doc = new XmlDocument {
XmlResolver = null
};
try
{
doc.Load(fs);
}
catch (Exception e)
{
fs.Close();
fs.Dispose();
ErrorReport?.Invoke(fullname, $"Error Occured Reading Dat:\r\n{e.Message}\r\n");
return(false);
}
fs.Close();
fs.Dispose();
if (doc.DocumentElement == null)
{
return(false);
}
XmlNode mame = doc.SelectSingleNode("mame");
if (mame != null)
{
return(DatXmlReader.ReadMameDat(doc, fullname, out rvDat));
}
XmlNode head = doc.DocumentElement?.SelectSingleNode("header");
if (head != null)
{
return(DatXmlReader.ReadDat(doc, fullname, out rvDat));
}
XmlNodeList headList = doc.SelectNodes("softwarelist");
if (headList != null)
{
return(DatMessXmlReader.ReadDat(doc, fullname, out rvDat));
}
return(false);
}
/// <summary>
/// Wrap creating a DAT file from files or a directory in parallel
/// </summary>
/// <param name="inputs">List of input filenames</param>
/// /* Normal DAT header info */
/// <param name="datHeader">All DatHeader info to be used</param>
/// /* Standard DFD info */
/// <param name="omitFromScan">Hash flag saying what hashes should not be calculated</param>
/// <param name="removeDateFromAutomaticName">True if the date should be omitted from the DAT, false otherwise</param>
/// <param name="archivesAsFiles">True if archives should be treated as files, false otherwise</param>
/// <param name="chdsAsFiles">True if CHDs should be treated like regular files, false otherwise</param>
/// <param name="skipFileType">Type of files that should be skipped on scan</param>
/// <param name="addBlankFilesForEmptyFolder">True if blank items should be created for empty folders, false otherwise</param>
/// <param name="addFileDates">True if dates should be archived for all files, false otherwise</param>
/// <param name="filter">Filter object to be passed to the DatItem level</param>
/// /* Output DAT info */
/// <param name="tempDir">Name of the directory to create a temp folder in (blank is default temp directory)</param>
/// <param name="outDir">Name of the directory to output the DAT to (blank is the current directory)</param>
/// <param name="copyFiles">True if files should be copied to the temp directory before hashing, false otherwise</param>
/// /* Filtering info */
/// <param name="filter">Filter object to be passed to the DatItem level</param>
private static void InitDatFromDir(List <string> inputs,
/* Normal DAT header info */
DatHeader datHeader,
/* Standard DFD info */
Hash omitFromScan,
bool removeDateFromAutomaticName,
bool archivesAsFiles,
bool chdsAsFiles,
SkipFileType skipFileType,
bool addBlankFilesForEmptyFolder,
bool addFileDates,
/* Output DAT info */
string tempDir,
string outDir,
bool copyFiles,
/* Filtering info */
Filter filter)
{
// Create a new DATFromDir object and process the inputs
DatFile basedat = new DatFile(datHeader)
{
Date = DateTime.Now.ToString("yyyy-MM-dd"),
};
// For each input directory, create a DAT
foreach (string path in inputs)
{
if (Directory.Exists(path) || File.Exists(path))
{
// Clone the base Dat for information
DatFile datdata = new DatFile(basedat);
string basePath = Path.GetFullPath(path);
bool success = datdata.PopulateFromDir(basePath, omitFromScan, removeDateFromAutomaticName, archivesAsFiles,
skipFileType, addBlankFilesForEmptyFolder, addFileDates, tempDir, copyFiles, datHeader.Header, chdsAsFiles, filter);
// If it was a success, write the DAT out
if (success)
{
datdata.Write(outDir);
}
// Otherwise, show the help
else
{
Console.WriteLine();
_help.OutputIndividualFeature("DATFromDir");
}
}
}
}
protected DatItem Next()
{
DatHeader header = new DatHeader();
if (Dat_next(_dat, ref header) == 1)
{
return(new DatItem(header, this, _index));
}
FuryException.Throw();
return(null);
}
public bool ReadDat(string strFilename, out DatHeader datHeader)
{
_filename = strFilename;
using (DatFileLoader dfl = new DatFileLoader())
{
datHeader = new DatHeader {
BaseDir = new DatDir(DatFileType.UnSet)
};
int errorCode = dfl.LoadDat(strFilename, System.Text.Encoding.UTF8);
if (errorCode != 0)
{
_errorReport?.Invoke(strFilename, new Win32Exception(errorCode).Message);
return(false);
}
dfl.Gn();
if (dfl.EndOfStream())
{
return(false);
}
if (dfl.Next.ToLower() == "doscenter")
{
dfl.Gn();
if (!LoadHeaderFromDat(dfl, datHeader))
{
return(false);
}
dfl.Gn();
}
while (!dfl.EndOfStream())
{
switch (dfl.Next.ToLower())
{
case "game":
dfl.Gn();
if (!LoadGameFromDat(dfl, datHeader.BaseDir))
{
return(false);
}
dfl.Gn();
break;
default:
_errorReport?.Invoke(dfl.Filename, "Error: key word '" + dfl.Next + "' not known, on line " + dfl.LineNumber);
dfl.Gn();
break;
}
}
}
return(true);
}
public DatItem Item(int index)
{
CheckDisposed();
DatHeader header = new DatHeader();
if (Dat_header(_dat, (UInt32)index, ref header) == 1)
{
return(new DatItem(header, this, (UInt32)index));
}
FuryException.Throw();
return(null);
}
private static bool LoadEmulator(DatFileLoader dfl, DatHeader datHeader, ReportError errorReport)
{
if (dfl.Next.ToLower() != "[emulator]")
{
errorReport?.Invoke(dfl.Filename, "Looking for [EMULATOR] but found " + dfl.Next + " , " + dfl.LineNumber);
return(false);
}
while (!dfl.EndOfStream())
{
string line = dfl.Gn();
if (line.Substring(0, 1) == "[")
{
return(true);
}
string element;
string value;
if (!splitLine(line, out element, out value))
{
return(false);
}
switch (element.ToLower())
{
case "refname":
datHeader.Name = value;
break;
case "version":
datHeader.Description = value;
break;
case "category":
datHeader.Category = value;
break;
case "exe":
break;
case "runcmd":
break;
case "romspaths":
break;
default:
errorReport?.Invoke(dfl.Filename, "Unknown Line " + dfl.Next + " found in [EMULATOR], " + dfl.LineNumber);
return(false);
}
}
return(true);
}
private bool LoadHeaderFromDat(XmlDocument doc, DatHeader datHeader)
{
if (doc.DocumentElement == null)
{
return(false);
}
XmlNode head = doc.DocumentElement.SelectSingleNode("header");
datHeader.Filename = _filename;
if (head == null)
{
return(false);
}
datHeader.Name = VarFix.String(head.SelectSingleNode("name"));
datHeader.Type = VarFix.String(head.SelectSingleNode("type"));
datHeader.RootDir = VarFix.String(head.SelectSingleNode("rootdir"));
datHeader.Description = VarFix.String(head.SelectSingleNode("description"));
datHeader.Category = VarFix.String(head.SelectSingleNode("category"));
datHeader.Version = VarFix.String(head.SelectSingleNode("version"));
datHeader.Date = VarFix.String(head.SelectSingleNode("date"));
datHeader.Author = VarFix.String(head.SelectSingleNode("author"));
datHeader.Email = VarFix.String(head.SelectSingleNode("email"));
datHeader.Homepage = VarFix.String(head.SelectSingleNode("homepage"));
datHeader.URL = VarFix.String(head.SelectSingleNode("url"));
datHeader.Comment = VarFix.String(head.SelectSingleNode("comment"));
datHeader.IsSuperDat = (datHeader.Type.ToLower() == "superdat") || (datHeader.Type.ToLower() == "gigadat");
XmlNode packingNode = head.SelectSingleNode("romvault") ?? head.SelectSingleNode("clrmamepro");
if (packingNode?.Attributes != null)
{
// dat Header XML filename
datHeader.Header = VarFix.String(packingNode.Attributes.GetNamedItem("header"));
// zip, unzip, file
datHeader.Compression = VarFix.String(packingNode.Attributes.GetNamedItem("forcepacking")).ToLower();
// split, full
datHeader.MergeType = VarFix.String(packingNode.Attributes.GetNamedItem("forcemerging")).ToLower();
// noautodir, nogame
datHeader.Dir = VarFix.String(packingNode.Attributes.GetNamedItem("dir")).ToLower();
}
// Look for: <notzipped>true</notzipped>
string notzipped = VarFix.String(head.SelectSingleNode("notzipped"));
datHeader.NotZipped = ((notzipped.ToLower() == "true") || (notzipped.ToLower() == "yes"));
return(true);
}
public bool ReadDat(string strFilename, out DatHeader datHeader)
{
_filename = strFilename;
using (DatFileLoader dfl = new DatFileLoader())
{
datHeader = new DatHeader {
BaseDir = new DatDir(DatFileType.UnSet)
};
int errorCode = dfl.LoadDat(strFilename);
if (errorCode != 0)
{
_errorReport?.Invoke(strFilename, new Win32Exception(errorCode).Message);
return(false);
}
dfl.Gn();
if (dfl.EndOfStream())
{
return(false);
}
if (dfl.Next.ToLower() == "clrmamepro" || dfl.Next.ToLower() == "clrmame")
{
dfl.Gn();
if (!LoadHeaderFromDat(dfl, datHeader))
{
return(false);
}
dfl.Gn();
}
if (dfl.Next.ToLower() == "romvault")
{
dfl.Gn();
if (!LoadHeaderFromDat(dfl, datHeader))
{
return(false);
}
dfl.Gn();
}
while (!dfl.EndOfStream())
{
bool res = ReadNextBlock(dfl, datHeader.BaseDir);
if (!res)
{
return(false);
}
}
}
return(true);
}
public static void WriteDat(string strFilename, DatHeader datHeader, bool newStyle = false)
{
string dir = Path.GetDirectoryName(strFilename);
if (!string.IsNullOrWhiteSpace(dir) && !Directory.Exists(dir))
{
System.IO.Directory.CreateDirectory(dir);
}
using (DatStreamWriter sw = new DatStreamWriter(strFilename))
{
WriteToStream(sw, datHeader, newStyle);
}
}
public bool ReadMameDat(XmlDocument doc, string strFilename, out DatHeader datHeader)
{
datHeader = new DatHeader {
BaseDir = new DatDir(DatFileType.UnSet)
};
_filename = strFilename;
if (!LoadMameHeaderFromDat(doc, datHeader))
{
return(false);
}
if (doc.DocumentElement == null)
{
return(false);
}
XmlNodeList dirNodeList = doc.DocumentElement.SelectNodes("dir");
if (dirNodeList != null)
{
for (int i = 0; i < dirNodeList.Count; i++)
{
LoadDirFromDat(datHeader.BaseDir, dirNodeList[i]);
}
}
XmlNodeList gameNodeList = doc.DocumentElement.SelectNodes("game");
if (gameNodeList != null)
{
for (int i = 0; i < gameNodeList.Count; i++)
{
LoadGameFromDat(datHeader.BaseDir, gameNodeList[i]);
}
}
XmlNodeList machineNodeList = doc.DocumentElement.SelectNodes("machine");
if (machineNodeList != null)
{
for (int i = 0; i < machineNodeList.Count; i++)
{
LoadGameFromDat(datHeader.BaseDir, machineNodeList[i]);
}
}
return(true);
}
private static void WriteToStream(DatStreamWriter sw, DatHeader datHeader)
{
sw.WriteLine("<?xml version=\"1.0\"?>");
sw.WriteLine(
@"<!DOCTYPE mame [
<!ELEMENT mame (machine+)>
<!ATTLIST mame build CDATA #IMPLIED>
<!ATTLIST mame debug (yes|no) ""no"">
<!ELEMENT machine (description, year?, manufacturer?, biosset*, rom*, disk*, device_ref*, sample*, chip*, display*, sound?, input?, dipswitch*, configuration*, port*, adjuster*, driver?, feature*, device*, slot*, softwarelist*, ramoption*)>
<!ATTLIST machine name CDATA #REQUIRED>
<!ATTLIST machine isbios (yes|no) ""no"">
<!ATTLIST machine isdevice (yes|no) ""no"">
<!ATTLIST machine runnable (yes|no) ""yes"">
<!ATTLIST machine cloneof CDATA #IMPLIED>
<!ATTLIST machine romof CDATA #IMPLIED>
<!ELEMENT description (#PCDATA)>
<!ELEMENT year (#PCDATA)>
<!ELEMENT manufacturer (#PCDATA)>
<!ELEMENT rom EMPTY>
<!ATTLIST rom name CDATA #REQUIRED>
<!ATTLIST rom bios CDATA #IMPLIED>
<!ATTLIST rom size CDATA #REQUIRED>
<!ATTLIST rom crc CDATA #IMPLIED>
<!ATTLIST rom sha1 CDATA #IMPLIED>
<!ATTLIST rom merge CDATA #IMPLIED>
<!ATTLIST rom region CDATA #IMPLIED>
<!ATTLIST rom offset CDATA #IMPLIED>
<!ATTLIST rom status (baddump|nodump|good) ""good"">
<!ATTLIST rom optional (yes|no) ""no"">
<!ELEMENT disk EMPTY>
<!ATTLIST disk name CDATA #REQUIRED>
<!ATTLIST disk sha1 CDATA #IMPLIED>
<!ATTLIST disk merge CDATA #IMPLIED>
<!ATTLIST disk region CDATA #IMPLIED>
<!ATTLIST disk index CDATA #IMPLIED>
<!ATTLIST disk writable (yes|no) ""no"">
<!ATTLIST disk status (baddump|nodump|good) ""good"">
<!ATTLIST disk optional (yes|no) ""no"">
<!ELEMENT device_ref EMPTY>
<!ATTLIST device_ref name CDATA #REQUIRED>
]>
");
sw.WriteLine($@"<mame build=""{datHeader.Name}"">");
writeBase(sw, datHeader.BaseDir);
sw.WriteLine("</mame>", -1);
}
protected override void WriteDatHeader()
{
DatHeader datHeader = new DatHeader();
DatFile.Write(FileTools.StructureToByteArray(datHeader), 0, Marshal.SizeOf(datHeader));
}
