public void MergeAltFileIntoGroup(RvFile file)
{
if (HeaderFT == HeaderFileType.Nothing && FileHeaderReader.FileHeaderReader.AltHeaderFile(file.HeaderFileType))
{
HeaderFT = file.HeaderFileType;
}
if (AltSize == null && file.Size != null)
{
AltSize = file.Size;
}
if (AltCRC == null && file.CRC != null)
{
AltCRC = file.CRC.Copy();
}
if (AltSHA1 == null && file.SHA1 != null)
{
AltSHA1 = file.SHA1.Copy();
}
if (AltMD5 == null && file.MD5 != null)
{
AltMD5 = file.MD5.Copy();
}
Files.Add(file);
file.FileGroup = this;
}
// 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);
}
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 static bool LoadDirFromDat(RvDat rvDat, string rootName, HeaderFileType datFileType)
{
if (DatFileLoader.Next != "(")
{
DatUpdate.SendAndShowDat("( not found after game", DatFileLoader.Filename);
return(false);
}
DatFileLoader.Gn();
if (DatFileLoader.Next.ToLower() != "name")
{
DatUpdate.SendAndShowDat("Name not found as first object in ( )", DatFileLoader.Filename);
return(false);
}
string fullname = VarFix.CleanFullFileName(DatFileLoader.GnRest());
fullname = Path.Combine(rootName, fullname);
DatFileLoader.Gn();
while (DatFileLoader.Next != ")")
{
switch (DatFileLoader.Next.ToLower())
{
case "dir":
DatFileLoader.Gn();
if (!LoadDirFromDat(rvDat, fullname, datFileType))
{
return(false);
}
DatFileLoader.Gn();
break;
case "game":
DatFileLoader.Gn();
if (!LoadGameFromDat(rvDat, fullname, datFileType))
{
return(false);
}
DatFileLoader.Gn();
break;
case "resource":
DatFileLoader.Gn();
if (!LoadGameFromDat(rvDat, fullname, datFileType))
{
return(false);
}
DatFileLoader.Gn();
break;
default:
DatUpdate.SendAndShowDat("Error Keyword " + DatFileLoader.Next + " not know in dir", DatFileLoader.Filename);
DatFileLoader.Gn();
break;
}
}
return(true);
}
public Detector(HeaderFileType fType, int headerLength, int fileOffset, string headerId, Data data)
{
FType = fType;
HeaderLength = headerLength;
FileOffset = fileOffset;
HeaderId = headerId.ToLower();
Data = data;
}
public static bool ReadDat(string strFilename, out RvDat rvDat)
{
HeaderFileType datFileType = HeaderFileType.Nothing;
rvDat = new RvDat();
int errorCode = DatFileLoader.LoadDat(strFilename);
if (errorCode != 0)
{
DatUpdate.ShowDat(new Win32Exception(errorCode).Message, strFilename);
return(false);
}
string filename = Path.GetFileName(strFilename);
DatFileLoader.Gn();
if (DatFileLoader.EndOfStream())
{
return(false);
}
if (DatFileLoader.Next.ToLower() == "doscenter")
{
DatFileLoader.Gn();
if (!LoadHeaderFromDat(filename, rvDat, out datFileType))
{
return(false);
}
DatFileLoader.Gn();
}
while (!DatFileLoader.EndOfStream())
{
switch (DatFileLoader.Next.ToLower())
{
case "game":
DatFileLoader.Gn();
if (!LoadGameFromDat(rvDat, "", datFileType))
{
return(false);
}
DatFileLoader.Gn();
break;
default:
DatUpdate.SendAndShowDat("Error on line " + DatFileLoader.LineNumber + ": key word '" + DatFileLoader.Next + "' not known", DatFileLoader.Filename);
DatFileLoader.Gn();
break;
}
}
DatFileLoader.Close();
return(true);
}
public static bool AltHeaderFile(HeaderFileType fileType)
{
return((fileType == HeaderFileType.A7800) ||
(fileType == HeaderFileType.FDS) ||
(fileType == HeaderFileType.Lynx) ||
(fileType == HeaderFileType.NES) ||
(fileType == HeaderFileType.PCE) ||
(fileType == HeaderFileType.PSID) ||
(fileType == HeaderFileType.SNES) ||
(fileType == HeaderFileType.SPC));
}
public static int GetFileHeaderLength(HeaderFileType FType)
{
foreach (Detector d in Detectors)
{
if (d.FType == FType)
{
return(d.FileOffset);
}
}
return(0);
}
public GZip(RvFile tFile)
{
altType = tFile.AltType;
crc = tFile.CRC;
md5Hash = tFile.MD5;
sha1Hash = tFile.SHA1;
uncompressedSize = tFile.Size;
altcrc = tFile.AltCRC;
altsha1Hash = tFile.AltSHA1;
altmd5Hash = tFile.AltMD5;
uncompressedAltSize = tFile.AltSize;
}
public FileGroup(RvFile sourceFile)
{
Size = sourceFile.Size;
CRC = sourceFile.CRC.Copy();
SHA1 = sourceFile.SHA1.Copy();
MD5 = sourceFile.MD5.Copy();
HeaderFT = FileHeaderReader.FileHeaderReader.AltHeaderFile(sourceFile.HeaderFileType)
? sourceFile.HeaderFileType :
HeaderFileType.Nothing;
AltSize = sourceFile.AltSize;
AltCRC = sourceFile.AltCRC.Copy();
AltSHA1 = sourceFile.AltSHA1.Copy();
AltMD5 = sourceFile.AltMD5.Copy();
Files.Add(sourceFile);
sourceFile.FileGroup = this;
}
private static void LoadRomFromDat(RvGame rvGame, XmlNode romNode, HeaderFileType datFileType)
{
if (romNode.Attributes == null)
{
return;
}
RvRom rvRom = new RvRom
{
AltType = datFileType,
Name = VarFix.CleanFullFileName(romNode.Attributes.GetNamedItem("name")),
Size = VarFix.ULong(romNode.Attributes.GetNamedItem("size")),
CRC = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("crc"), 8),
SHA1 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("sha1"), 40),
MD5 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("md5"), 32),
Merge = VarFix.CleanFullFileName(romNode.Attributes.GetNamedItem("merge")),
Status = VarFix.ToLower(romNode.Attributes.GetNamedItem("status"))
};
rvGame.AddRom(rvRom);
}
private static bool LoadRomFromDat(string rootName, HeaderFileType datFileType, out RvRom rvRom, out string game, out string description, out string romof, out string cloneof)
{
// Set the current out vars to blank for the time being
rvRom = new RvRom();
game = "";
description = "";
romof = "";
cloneof = "";
if (!DatFileLoader.Next.Contains("¬"))
{
DatUpdate.SendAndShowDat("¬ not found in the rom definition on line " + DatFileLoader.LineNumber, DatFileLoader.Filename);
return(false);
}
// Some old RC DATs have this behavior
if (DatFileLoader.Next.Contains("¬N¬O"))
{
DatFileLoader.Next = DatFileLoader.Next.Replace("¬N¬O", "") + "¬¬";
}
string[] split = DatFileLoader.Next.Split('¬');
game = split[3];
description = split[4];
romof = split[1];
cloneof = split[1];
rvRom = new RvRom
{
Name = split[5],
CRC = VarFix.CleanMD5SHA1(split[6], 8),
Size = Int64.TryParse(split[7], out var temp) ? VarFix.FixLong(split[7]) : null,
Merge = split[9],
};
return(true);
}
private static bool LoadHeaderFromDat(XmlDocument doc, RvDat rvDat, string filename, out HeaderFileType datFileType)
{
datFileType = HeaderFileType.Nothing;
if (doc.DocumentElement == null)
{
return(false);
}
XmlNode head = doc.DocumentElement.SelectSingleNode("header");
rvDat.Filename = filename;
if (head == null)
{
return(false);
}
rvDat.Name = VarFix.CleanFileName(head.SelectSingleNode("name"));
rvDat.RootDir = VarFix.CleanFileName(head.SelectSingleNode("rootdir"));
rvDat.Description = VarFix.String(head.SelectSingleNode("description"));
rvDat.Category = VarFix.String(head.SelectSingleNode("category"));
rvDat.Version = VarFix.String(head.SelectSingleNode("version"));
rvDat.Date = VarFix.String(head.SelectSingleNode("date"));
rvDat.Author = VarFix.String(head.SelectSingleNode("author"));
rvDat.Email = VarFix.String(head.SelectSingleNode("email"));
rvDat.Homepage = VarFix.String(head.SelectSingleNode("homepage"));
rvDat.URL = VarFix.String(head.SelectSingleNode("url"));
rvDat.Comment = VarFix.String(head.SelectSingleNode("comment"));
XmlNode packingNode = head.SelectSingleNode("romvault") ?? head.SelectSingleNode("clrmamepro");
if (packingNode?.Attributes != null)
{
// dat Header XML filename
datFileType = FileHeaderReader.FileHeaderReader.GetFileTypeFromHeader(VarFix.String(packingNode.Attributes.GetNamedItem("header")));
rvDat.MergeType = VarFix.String(packingNode.Attributes.GetNamedItem("forcemerging")).ToLower();
}
return(true);
}
private ZipReturn ReadBody(bool deepScan)
{
using (BinaryReader zipBr = new BinaryReader(_zipFs, Encoding.UTF8, true))
{
byte ID1 = zipBr.ReadByte();
byte ID2 = zipBr.ReadByte();
if ((ID1 != 0x1f) || (ID2 != 0x8b))
{
_zipFs.Close();
return(ZipReturn.ZipSignatureError);
}
byte CM = zipBr.ReadByte();
if (CM != 8)
{
_zipFs.Close();
return(ZipReturn.ZipUnsupportedCompression);
}
byte FLG = zipBr.ReadByte();
uint MTime = zipBr.ReadUInt32();
byte XFL = zipBr.ReadByte();
byte OS = zipBr.ReadByte();
//if FLG.FEXTRA set
if ((FLG & 0x4) == 0x4)
{
int XLen = zipBr.ReadInt16();
byte[] bytes = zipBr.ReadBytes(XLen);
if (XLen == 28)
{
md5Hash = new byte[16];
Array.Copy(bytes, 0, md5Hash, 0, 16);
crc = new byte[4];
Array.Copy(bytes, 16, crc, 0, 4);
uncompressedSize = BitConverter.ToUInt64(bytes, 20);
}
if (XLen == 77)
{
md5Hash = new byte[16];
Array.Copy(bytes, 0, md5Hash, 0, 16);
crc = new byte[4];
Array.Copy(bytes, 16, crc, 0, 4);
uncompressedSize = BitConverter.ToUInt64(bytes, 20);
altType = (HeaderFileType)bytes[28];
altmd5Hash = new byte[16];
Array.Copy(bytes, 29, altmd5Hash, 0, 16);
altsha1Hash = new byte[20];
Array.Copy(bytes, 45, altsha1Hash, 0, 20);
altcrc = new byte[4];
Array.Copy(bytes, 65, altcrc, 0, 4);
uncompressedAltSize = BitConverter.ToUInt64(bytes, 69);
}
}
//if FLG.FNAME set
if ((FLG & 0x8) == 0x8)
{
int XLen = zipBr.ReadInt16();
byte[] bytes = zipBr.ReadBytes(XLen);
}
//if FLG.FComment set
if ((FLG & 0x10) == 0x10)
{
int XLen = zipBr.ReadInt16();
byte[] bytes = zipBr.ReadBytes(XLen);
}
//if FLG.FHCRC set
if ((FLG & 0x2) == 0x2)
{
uint crc16 = zipBr.ReadUInt16();
}
}
compressedSize = (ulong)(_zipFs.Length - _zipFs.Position) - 8;
datapos = _zipFs.Position;
if (deepScan)
{
if (Buffer0 == null)
{
Buffer0 = new byte[Buffersize];
}
if (Buffer1 == null)
{
Buffer1 = new byte[Buffersize];
}
Stream ds = new ZlibBaseStream(_zipFs, CompressionMode.Decompress, CompressionLevel.Default, ZlibStreamFlavor.DEFLATE, true);
ThreadLoadBuffer lbuffer = new ThreadLoadBuffer(ds);
ThreadCRC crc32 = new ThreadCRC();
ThreadMD5 md5 = new ThreadMD5();
ThreadSHA1 sha1 = new ThreadSHA1();
ulong uncompressedRead = 0;
int bufferRead = ds.Read(Buffer0, 0, Buffersize);
uncompressedRead += (ulong)bufferRead;
bool whichBuffer = true;
while (bufferRead > 0)
{
// trigger the buffer loading worker
lbuffer.Trigger(whichBuffer ? Buffer1 : Buffer0, Buffersize);
byte[] buffer = whichBuffer ? Buffer0 : Buffer1;
// trigger the hashing workers
crc32.Trigger(buffer, bufferRead);
md5.Trigger(buffer, bufferRead);
sha1.Trigger(buffer, bufferRead);
lbuffer.Wait();
crc32.Wait();
md5.Wait();
sha1.Wait();
// setup next loop around
bufferRead = lbuffer.SizeRead;
uncompressedRead += (ulong)bufferRead;
whichBuffer = !whichBuffer;
}
// tell all the workers we are finished
lbuffer.Finish();
crc32.Finish();
md5.Finish();
sha1.Finish();
// get the results
byte[] testcrc = crc32.Hash;
byte[] testmd5 = md5.Hash;
byte[] testsha1 = sha1.Hash;
// cleanup
lbuffer.Dispose();
crc32.Dispose();
md5.Dispose();
sha1.Dispose();
ds.Close();
ds.Dispose();
if (uncompressedSize != 0)
{
if (uncompressedSize != uncompressedRead)
{
_zipFs.Close();
return(ZipReturn.ZipDecodeError);
}
}
else
{
uncompressedSize = uncompressedRead;
}
if (crc != null)
{
for (int i = 0; i < 4; i++)
{
if (crc[i] == testcrc[i])
{
continue;
}
_zipFs.Close();
return(ZipReturn.ZipDecodeError);
}
}
else
{
crc = testcrc;
}
if (md5Hash != null)
{
for (int i = 0; i < 16; i++)
{
if (md5Hash[i] == testmd5[i])
{
continue;
}
_zipFs.Close();
return(ZipReturn.ZipDecodeError);
}
}
else
{
md5Hash = testmd5;
}
if (sha1Hash != null)
{
for (int i = 0; i < 20; i++)
{
if (sha1Hash[i] == testsha1[i])
{
continue;
}
_zipFs.Close();
return(ZipReturn.ZipDecodeError);
}
}
else
{
sha1Hash = testsha1;
}
}
_zipFs.Position = _zipFs.Length - 8;
byte[] gzcrc;
uint gzLength;
using (BinaryReader zipBr = new BinaryReader(_zipFs, Encoding.UTF8, true))
{
gzcrc = zipBr.ReadBytes(4);
gzLength = zipBr.ReadUInt32();
}
if (crc != null)
{
for (int i = 0; i < 4; i++)
{
if (gzcrc[3 - i] == crc[i])
{
continue;
}
_zipFs.Close();
return(ZipReturn.ZipDecodeError);
}
}
else
{
crc = new[] { gzcrc[3], gzcrc[2], gzcrc[1], gzcrc[0] };
}
if (uncompressedSize != 0)
{
if (gzLength != (uncompressedSize & 0xffffffff))
{
_zipFs.Close();
return(ZipReturn.ZipDecodeError);
}
}
return(ZipReturn.ZipGood);
}
private static bool ScanAFile(string realFilename, Stream memzip, string displayFilename)
{
Compress.File.File fStream = new Compress.File.File();
if (string.IsNullOrEmpty(realFilename) && memzip != null)
{
fStream.ZipFileOpen(memzip);
}
else
{
ZipReturn zRet = fStream.ZipFileOpen(realFilename, -1, true);
if (zRet != ZipReturn.ZipGood)
{
return(false);
}
}
bool ret = false;
FileScan fScan = new FileScan();
List <FileScan.FileResults> resScan = fScan.Scan(fStream, true, true);
HeaderFileType foundFileType = resScan[0].HeaderFileType;
if (foundFileType == HeaderFileType.CHD)
{
// read altheader values from CHD file.
}
RvFile tFile = new RvFile
{
Size = resScan[0].Size,
CRC = resScan[0].CRC,
MD5 = resScan[0].MD5,
SHA1 = resScan[0].SHA1,
AltType = resScan[0].HeaderFileType,
AltSize = resScan[0].AltSize,
AltCRC = resScan[0].AltCRC,
AltMD5 = resScan[0].AltMD5,
AltSHA1 = resScan[0].AltSHA1
};
// test if needed.
FindStatus res = RvRomFileMatchup.FileneededTest(tFile);
if (res == FindStatus.FileNeededInArchive)
{
_bgw?.ReportProgress(0, new bgwShowError(displayFilename, "found"));
Debug.WriteLine("Reading file as " + tFile.SHA1);
string outfile = RomRootDir.Getfilename(tFile.SHA1);
gZip gz1 = new gZip();
gz1.ZipFileCreate(outfile);
gz1.ExtraData = tFile.SetExtraData();
gz1.ZipFileOpenWriteStream(false, true, "", tFile.Size, 8, out Stream write, null);
fStream.ZipFileOpenReadStream(0, out Stream s, out ulong _);
// do copy
StreamCopier.StreamCopy(s, write, tFile.Size);
fStream.ZipFileCloseReadStream();
fStream.ZipFileClose();
gz1.ZipFileCloseWriteStream(tFile.CRC);
tFile.CompressedSize = gz1.CompressedSize;
gz1.ZipFileClose();
tFile.DBWrite();
ret = true;
}
else if (res == FindStatus.FoundFileInArchive)
{
ret = true;
}
fStream.ZipFileClose();
if (foundFileType == HeaderFileType.ZIP || foundFileType == HeaderFileType.SevenZip || foundFileType == HeaderFileType.GZ)
{
ICompress fz;
switch (foundFileType)
{
case HeaderFileType.SevenZip:
fz = new SevenZ();
break;
case HeaderFileType.GZ:
fz = new gZip();
break;
//case HeaderFileType.ZIP:
default:
fz = new Zip();
break;
}
ZipReturn zp;
if (string.IsNullOrEmpty(realFilename) && memzip != null)
{
memzip.Position = 0;
zp = fz.ZipFileOpen(memzip);
}
else
{
zp = fz.ZipFileOpen(realFilename);
}
if (zp == ZipReturn.ZipGood)
{
bool allZipFound = true;
for (int i = 0; i < fz.LocalFilesCount(); i++)
{
LocalFile lf = fz.GetLocalFile(i);
ZipReturn openFile = fz.ZipFileOpenReadStream(i, out Stream stream, out ulong streamSize);
if (streamSize <= _inMemorySize)
{
if (openFile == ZipReturn.ZipTryingToAccessADirectory)
{
continue;
}
byte[] tmpFile = new byte[streamSize];
stream.Read(tmpFile, 0, (int)streamSize);
using (Stream memStream = new MemoryStream(tmpFile, false))
{
allZipFound &= ScanAFile(null, memStream, lf.Filename);
}
}
else
{
string file = Path.Combine(_tmpDir, Guid.NewGuid().ToString());
FileStream.OpenFileWrite(file, out Stream fs);
ulong sizetogo = streamSize;
while (sizetogo > 0)
{
int sizenow = sizetogo > (ulong)Buffersize ? Buffersize : (int)sizetogo;
stream.Read(Buffer, 0, sizenow);
fs.Write(Buffer, 0, sizenow);
sizetogo -= (ulong)sizenow;
}
fs.Close();
allZipFound &= ScanAFile(file, null, lf.Filename);
File.Delete(file);
}
//fz.ZipFileCloseReadStream();
}
fz.ZipFileClose();
ret |= allZipFound;
}
else
{
ret = false;
}
}
return(ret);
}
public static bool ReadDat(string strFilename, out RvDat rvDat)
{
HeaderFileType datFileType = HeaderFileType.Nothing;
rvDat = new RvDat();
int errorCode = DatFileLoader.LoadDat(strFilename);
if (errorCode != 0)
{
DatUpdate.ShowDat(new Win32Exception(errorCode).Message, strFilename);
return(false);
}
string filename = Path.GetFileName(strFilename);
DatFileLoader.Gn();
if (DatFileLoader.EndOfStream())
{
return(false);
}
if (DatFileLoader.Next.ToLower() == "[credits]")
{
if (!LoadHeaderFromDat(filename, rvDat, out datFileType, DatFileLoader.Next.ToLower()))
{
return(false);
}
DatFileLoader.Gn();
}
else if (DatFileLoader.Next.ToLower() == "[dat]")
{
if (!LoadHeaderFromDat(filename, rvDat, out datFileType, DatFileLoader.Next.ToLower()))
{
return(false);
}
DatFileLoader.Gn();
}
else if (DatFileLoader.Next.ToLower() == "[emulator]")
{
if (!LoadHeaderFromDat(filename, rvDat, out datFileType, DatFileLoader.Next.ToLower()))
{
return(false);
}
DatFileLoader.Gn();
}
// Everything else if a rom/game
string lastgame = "";
bool foundgame = false;
RvGame rvGame = new RvGame();
while (!DatFileLoader.EndOfStream())
{
// Set loop variables
foundgame = true;
string game = "", description = "", romof = "", cloneof = "";
RvRom rvRom = new RvRom();
if (!LoadRomFromDat("", datFileType, out rvRom, out game, out description, out romof, out cloneof))
{
return(false);
}
DatFileLoader.Gn();
// If we have a new game finally, add the last one
if (lastgame != game && lastgame != "")
{
rvDat.AddGame(rvGame);
foundgame = false;
rvGame = new RvGame();
}
// For everything else, add to the new rvGame
rvGame.Name = (String.IsNullOrEmpty(rvGame.Name) ? game : rvGame.Name);
rvGame.Description = (String.IsNullOrEmpty(rvGame.Description) ? description : rvGame.Description);
rvGame.CloneOf = (String.IsNullOrEmpty(rvGame.CloneOf) ? cloneof : rvGame.CloneOf);
rvGame.RomOf = (String.IsNullOrEmpty(rvGame.RomOf) ? romof : rvGame.RomOf);
rvGame.AddRom(rvRom);
lastgame = game;
}
// If we had a lingering game, add it
if (foundgame)
{
rvDat.AddGame(rvGame);
}
DatFileLoader.Close();
return(true);
}
private static void CopyDir(DatDir datD, RvFile rvD, RvDat rvDat, HeaderFileType headerFileType, bool gameFile)
{
DatBase[] datB = datD.ToArray();
if (datB == null)
{
return;
}
foreach (DatBase b in datB)
{
switch (b)
{
case DatDir nDir:
RvFile nd = new RvFile(ConvE(nDir.DatFileType))
{
Name = nDir.Name + GetExt(nDir.DatFileType),
Dat = rvDat,
DatStatus = ConvE(nDir.DatStatus)
};
if (nDir.DGame == null && !gameFile)
{
nd.Tree = new RvTreeRow();
}
rvD.ChildAdd(nd);
if (nDir.DGame != null)
{
DatGame dGame = nDir.DGame;
RvGame cGame = new RvGame();
CheckAttribute(cGame, dGame.Description, RvGame.GameData.Description);
CheckAttribute(cGame, dGame.RomOf, RvGame.GameData.RomOf);
CheckAttribute(cGame, dGame.IsBios, RvGame.GameData.IsBios);
CheckAttribute(cGame, dGame.SourceFile, RvGame.GameData.Sourcefile);
CheckAttribute(cGame, dGame.CloneOf, RvGame.GameData.CloneOf);
CheckAttribute(cGame, dGame.SampleOf, RvGame.GameData.SampleOf);
CheckAttribute(cGame, dGame.Board, RvGame.GameData.Board);
CheckAttribute(cGame, dGame.Year, RvGame.GameData.Year);
CheckAttribute(cGame, dGame.Manufacturer, RvGame.GameData.Manufacturer);
if (nDir.DGame.IsEmuArc)
{
cGame.AddData(RvGame.GameData.EmuArc, "yes");
CheckAttribute(cGame, dGame.TitleId, RvGame.GameData.TitleId);
CheckAttribute(cGame, dGame.Publisher, RvGame.GameData.Publisher);
CheckAttribute(cGame, dGame.Developer, RvGame.GameData.Developer);
CheckAttribute(cGame, dGame.Genre, RvGame.GameData.Genre);
CheckAttribute(cGame, dGame.SubGenre, RvGame.GameData.SubGenre);
CheckAttribute(cGame, dGame.Ratings, RvGame.GameData.Ratings);
CheckAttribute(cGame, dGame.Score, RvGame.GameData.Score);
CheckAttribute(cGame, dGame.Players, RvGame.GameData.Players);
CheckAttribute(cGame, dGame.Enabled, RvGame.GameData.Enabled);
CheckAttribute(cGame, dGame.CRC, RvGame.GameData.CRC);
CheckAttribute(cGame, dGame.RelatedTo, RvGame.GameData.RelatedTo);
CheckAttribute(cGame, dGame.Source, RvGame.GameData.Source);
}
nd.Game = cGame;
}
CopyDir(nDir, nd, rvDat, headerFileType, gameFile || nDir.DGame != null);
break;
case DatFile nFile:
RvFile nf = new RvFile(ConvE(nFile.DatFileType))
{
Name = nFile.Name,
Size = nFile.Size,
CRC = nFile.CRC,
SHA1 = nFile.SHA1,
MD5 = nFile.MD5,
Merge = nFile.Merge,
Status = nFile.Status,
Dat = rvDat,
DatStatus = ConvE(nFile.DatStatus),
HeaderFileType = headerFileType
};
#if dt
DateTime dt;
if (!string.IsNullOrEmpty(nFile.DateModified) && DateTime.TryParseExact(nFile.DateModified, "yyyy/MM/dd HH:mm:ss", enUS, DateTimeStyles.None, out dt))
{
nf.DatModTimeStamp = dt.Ticks;
}
#endif
if (nFile.isDisk)
{
nf.HeaderFileType = HeaderFileType.CHD;
}
if (nf.HeaderFileType != HeaderFileType.Nothing)
{
nf.FileStatusSet(FileStatus.HeaderFileTypeFromDAT);
}
if (nf.Size != null)
{
nf.FileStatusSet(FileStatus.SizeFromDAT);
}
if (nf.CRC != null)
{
nf.FileStatusSet(FileStatus.CRCFromDAT);
}
if (nf.SHA1 != null)
{
nf.FileStatusSet(FileStatus.SHA1FromDAT);
}
if (nf.MD5 != null)
{
nf.FileStatusSet(FileStatus.MD5FromDAT);
}
rvD.ChildAdd(nf);
break;
}
}
}
private static void LoadDirFromDat(RvDat rvDat, XmlNode dirNode, string rootDir, HeaderFileType datFileType)
{
if (dirNode.Attributes == null)
{
return;
}
string fullname = VarFix.CleanFullFileName(dirNode.Attributes.GetNamedItem("name"));
XmlNodeList dirNodeList = dirNode.SelectNodes("dir");
if (dirNodeList != null)
{
for (int i = 0; i < dirNodeList.Count; i++)
{
LoadDirFromDat(rvDat, dirNodeList[i], Path.Combine(rootDir, fullname), datFileType);
}
}
XmlNodeList gameNodeList = dirNode.SelectNodes("game");
if (gameNodeList != null)
{
for (int i = 0; i < gameNodeList.Count; i++)
{
LoadGameFromDat(rvDat, gameNodeList[i], Path.Combine(rootDir, fullname), datFileType);
}
}
}
private static bool ScanAFile(string realFilename, Stream memzip, string displayFilename)
{
Stream fStream;
if (string.IsNullOrEmpty(realFilename) && memzip != null)
{
fStream = memzip;
}
else
{
int errorCode = FileStream.OpenFileRead(realFilename, out fStream);
if (errorCode != 0)
{
return(false);
}
}
bool ret = false;
HeaderFileType foundFileType = FileHeaderReader.FileHeaderReader.GetType(fStream, out int offset);
fStream.Position = 0;
RvFile tFile = UnCompFiles.CheckSumRead(fStream, offset);
tFile.AltType = foundFileType;
if (foundFileType == HeaderFileType.CHD)
{
// read altheader values from CHD file.
}
// test if needed.
FindStatus res = RvRomFileMatchup.FileneededTest(tFile);
if (res == FindStatus.FileNeededInArchive)
{
_bgw?.ReportProgress(0, new bgwShowError(displayFilename, "found"));
Debug.WriteLine("Reading file as " + tFile.SHA1);
GZip gz = new GZip(tFile);
string outfile = RomRootDir.Getfilename(tFile.SHA1);
fStream.Position = 0;
gz.WriteGZip(outfile, fStream, false);
tFile.CompressedSize = gz.compressedSize;
tFile.DBWrite();
ret = true;
}
else if (res == FindStatus.FoundFileInArchive)
{
ret = true;
}
if (foundFileType == HeaderFileType.ZIP || foundFileType == HeaderFileType.SevenZip || foundFileType == HeaderFileType.GZ)
{
ICompress fz;
switch (foundFileType)
{
case HeaderFileType.SevenZip:
fz = new SevenZ();
break;
case HeaderFileType.GZ:
fz = new gZip();
break;
//case HeaderFileType.ZIP:
default:
fz = new Zip();
break;
}
fStream.Position = 0;
ZipReturn zp;
if (string.IsNullOrEmpty(realFilename) && memzip != null)
{
zp = fz.ZipFileOpen(memzip);
}
else
{
zp = fz.ZipFileOpen(realFilename);
}
if (zp == ZipReturn.ZipGood)
{
bool allZipFound = true;
for (int i = 0; i < fz.LocalFilesCount(); i++)
{
ZipReturn openFile = fz.ZipFileOpenReadStream(i, out Stream stream, out ulong streamSize);
if (streamSize <= _inMemorySize)
{
if (openFile == ZipReturn.ZipTryingToAccessADirectory)
{
continue;
}
byte[] tmpFile = new byte[streamSize];
stream.Read(tmpFile, 0, (int)streamSize);
using (Stream memStream = new MemoryStream(tmpFile, false))
{
allZipFound &= ScanAFile(null, memStream, fz.Filename(i));
}
}
else
{
string file = Path.Combine(_tmpDir, Guid.NewGuid().ToString());
FileStream.OpenFileWrite(file, out Stream fs);
ulong sizetogo = streamSize;
while (sizetogo > 0)
{
int sizenow = sizetogo > (ulong)Buffersize ? Buffersize : (int)sizetogo;
stream.Read(Buffer, 0, sizenow);
fs.Write(Buffer, 0, sizenow);
sizetogo -= (ulong)sizenow;
}
fs.Close();
allZipFound &= ScanAFile(file, null, fz.Filename(i));
File.Delete(file);
}
//fz.ZipFileCloseReadStream();
}
fz.ZipFileClose();
ret |= allZipFound;
}
else
{
ret = false;
}
}
if (!string.IsNullOrEmpty(realFilename) || memzip == null)
{
fStream.Close();
fStream.Dispose();
}
return(ret);
}
private static bool LoadRomFromDat(RvGame rvGame, HeaderFileType datFileType)
{
if (DatFileLoader.Next != "(")
{
DatUpdate.SendAndShowDat("( not found after rom on line " + DatFileLoader.LineNumber, DatFileLoader.Filename);
return(false);
}
DatFileLoader.Gn();
if (DatFileLoader.Next.ToLower() != "name")
{
DatUpdate.SendAndShowDat("Name not found as first object in ( ) on line " + DatFileLoader.LineNumber, DatFileLoader.Filename);
return(false);
}
RvRom rvRom = new RvRom
{
Name = VarFix.CleanFullFileName(DatFileLoader.Gn()),
AltType = datFileType
};
DatFileLoader.Gn();
while (rvRom.CRC == null || rvRom.Size == null || DatFileLoader.Next != ")")
{
switch (DatFileLoader.Next.ToLower())
{
case "size":
rvRom.Size = VarFix.ULong(DatFileLoader.Gn());
DatFileLoader.Gn();
break;
case "crc":
rvRom.CRC = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 8);
DatFileLoader.Gn();
break;
case "md5":
rvRom.MD5 = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 32);
DatFileLoader.Gn();
break;
case "sha1":
rvRom.SHA1 = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 40);
DatFileLoader.Gn();
break;
case "sha256":
// No-op until larger hashes are supported
DatFileLoader.Gn();
DatFileLoader.Gn();
break;
case "sha384":
// No-op until larger hashes are supported
DatFileLoader.Gn();
DatFileLoader.Gn();
break;
case "sha512":
// No-op until larger hashes are supported
DatFileLoader.Gn();
DatFileLoader.Gn();
break;
case "date":
rvRom.Date = DatFileLoader.Gn();
rvRom.Date += " " + DatFileLoader.Gn();
DatFileLoader.Gn();
break;
default:
rvRom.Name += " " + DatFileLoader.Next;
DatFileLoader.Gn();
break;
}
}
rvGame.AddRom(rvRom);
return(true);
}
private static bool LoadGameFromDat(RvDat rvDat, string rootName, HeaderFileType datFileType)
{
if (DatFileLoader.Next != "(")
{
DatUpdate.SendAndShowDat("( not found after game", DatFileLoader.Filename);
return(false);
}
DatFileLoader.Gn();
string snext = DatFileLoader.Next.ToLower();
string pathextra = "";
if (snext == "rebuildto")
{
pathextra = VarFix.CleanFullFileName(DatFileLoader.Gn());
DatFileLoader.Gn();
snext = DatFileLoader.Next.ToLower();
}
if (snext != "name")
{
DatUpdate.SendAndShowDat("Name not found as first object in ( )", DatFileLoader.Filename);
return(false);
}
string name = VarFix.CleanFullFileName(DatFileLoader.GnRest());
name = Path.Combine(pathextra, name);
name = Path.Combine(rootName, name);
DatFileLoader.Gn();
RvGame rvGame = new RvGame {
Name = name
};
while (DatFileLoader.Next != ")")
{
switch (DatFileLoader.Next.ToLower())
{
case "romof":
rvGame.RomOf = VarFix.CleanFileName(DatFileLoader.GnRest());
DatFileLoader.Gn();
break;
case "description":
rvGame.Description = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "sourcefile":
rvGame.SourceFile = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "cloneof":
rvGame.CloneOf = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "sampleof":
rvGame.SampleOf = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "board":
rvGame.Board = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "year":
rvGame.Year = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "manufacturer":
rvGame.Manufacturer = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "serial":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "rebuildto":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "sample":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "biosset":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "chip":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "video":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "sound":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "input":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "dipswitch":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "driver":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "rom":
DatFileLoader.Gn();
if (!LoadRomFromDat(rvGame, datFileType))
{
return(false);
}
DatFileLoader.Gn();
break;
case "disk":
DatFileLoader.Gn();
if (!LoadDiskFromDat(rvGame))
{
return(false);
}
DatFileLoader.Gn();
break;
case "archive":
DatFileLoader.Gn();
if (!LoadArchiveFromDat())
{
return(false);
}
DatFileLoader.Gn();
break;
default:
DatUpdate.SendAndShowDat("Error: key word '" + DatFileLoader.Next + "' not known in game", DatFileLoader.Filename);
DatFileLoader.Gn();
break;
}
}
rvDat.AddGame(rvGame);
return(true);
}
private static void LoadGameFromDat(RvDat rvDat, XmlNode gameNode, string rootDir, HeaderFileType datFileType)
{
if (gameNode.Attributes == null)
{
return;
}
RvGame rvGame = new RvGame
{
Name = VarFix.CleanFullFileName(gameNode.Attributes.GetNamedItem("name")),
RomOf = VarFix.CleanFileName(gameNode.Attributes.GetNamedItem("romof")),
CloneOf = VarFix.CleanFileName(gameNode.Attributes.GetNamedItem("cloneof")),
SampleOf = VarFix.CleanFileName(gameNode.Attributes.GetNamedItem("sampleof")),
Description = VarFix.String(gameNode.SelectSingleNode("description")),
SourceFile = VarFix.String(gameNode.Attributes.GetNamedItem("sourcefile")),
IsBios = VarFix.String(gameNode.Attributes.GetNamedItem("isbios")),
Board = VarFix.String(gameNode.Attributes.GetNamedItem("board")),
Year = VarFix.String(gameNode.SelectSingleNode("year")),
Manufacturer = VarFix.String(gameNode.SelectSingleNode("manufacturer"))
};
XmlNode trurip = gameNode.SelectSingleNode("trurip");
if (trurip != null)
{
rvGame.IsTrurip = true;
rvGame.Publisher = VarFix.String(trurip.SelectSingleNode("publisher"));
rvGame.Developer = VarFix.String(trurip.SelectSingleNode("developer"));
rvGame.Edition = VarFix.String(trurip.SelectSingleNode("edition"));
rvGame.Version = VarFix.String(trurip.SelectSingleNode("version"));
rvGame.Type = VarFix.String(trurip.SelectSingleNode("type"));
rvGame.Media = VarFix.String(trurip.SelectSingleNode("media"));
rvGame.Language = VarFix.String(trurip.SelectSingleNode("language"));
rvGame.Players = VarFix.String(trurip.SelectSingleNode("players"));
rvGame.Ratings = VarFix.String(trurip.SelectSingleNode("ratings"));
rvGame.Peripheral = VarFix.String(trurip.SelectSingleNode("peripheral"));
rvGame.Genre = VarFix.String(trurip.SelectSingleNode("genre"));
rvGame.MediaCatalogNumber = VarFix.String(trurip.SelectSingleNode("mediacatalognumber"));
rvGame.BarCode = VarFix.String(trurip.SelectSingleNode("barcode"));
}
rvGame.Name = Path.Combine(rootDir, rvGame.Name);
rvDat.AddGame(rvGame);
XmlNodeList romNodeList = gameNode.SelectNodes("rom");
if (romNodeList != null)
{
for (int i = 0; i < romNodeList.Count; i++)
{
LoadRomFromDat(rvGame, romNodeList[i], datFileType);
}
}
XmlNodeList diskNodeList = gameNode.SelectNodes("disk");
if (diskNodeList != null)
{
for (int i = 0; i < diskNodeList.Count; i++)
{
LoadDiskFromDat(rvGame, diskNodeList[i]);
}
}
}
private static bool LoadHeaderFromDat(string filename, RvDat rvDat, out HeaderFileType datFileType)
{
datFileType = HeaderFileType.Nothing;
if (DatFileLoader.Next != "(")
{
DatUpdate.SendAndShowDat("( not found after clrmamepro", DatFileLoader.Filename);
return(false);
}
DatFileLoader.Gn();
rvDat.Filename = filename;
while (DatFileLoader.Next != ")")
{
switch (DatFileLoader.Next.ToLower())
{
case "name":
rvDat.Name = VarFix.CleanFileName(DatFileLoader.GnRest());
DatFileLoader.Gn();
break;
case "description":
rvDat.Description = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "category":
rvDat.Category = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "version":
rvDat.Version = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "date":
rvDat.Date = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "author":
rvDat.Author = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "email":
rvDat.Email = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "homepage":
rvDat.Homepage = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "url":
rvDat.URL = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "comment":
rvDat.Comment = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "header":
datFileType = FileHeaderReader.FileHeaderReader.GetFileTypeFromHeader(DatFileLoader.GnRest());
DatFileLoader.Gn();
break;
case "forcezipping":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "forcepacking":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break; // incorrect usage
case "forcemerging":
rvDat.MergeType = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "forcenodump":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "dir":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
default:
DatUpdate.SendAndShowDat("Error: key word '" + DatFileLoader.Next + "' not known in clrmamepro", DatFileLoader.Filename);
DatFileLoader.Gn();
break;
}
}
return(true);
}
private static void CopyDir(DatDir datD, HeaderFileType headerFileType, RvDat retDat = null, RvGame retGame = null)
{
DatBase[] datB = datD.ToArray();
if (datB == null)
{
return;
}
foreach (DatBase b in datB)
{
switch (b)
{
case DatDir nDir:
if (nDir.DGame == null)
{
break;
}
DatGame dGame = nDir.DGame;
RvGame cGame = new RvGame();
cGame.Name = b.Name;
cGame.Description = dGame.Description;
cGame.Manufacturer = dGame.Manufacturer;
cGame.CloneOf = dGame.CloneOf;
cGame.RomOf = dGame.RomOf;
cGame.SampleOf = dGame.SampleOf;
cGame.SourceFile = dGame.SourceFile;
cGame.IsBios = dGame.IsBios;
cGame.Board = dGame.Board;
cGame.Year = dGame.Year;
if (dGame.IsEmuArc)
{
cGame.IsTrurip = true;
cGame.Publisher = dGame.Publisher;
cGame.Developer = dGame.Developer;
//cGame.Edition
//cGame.Version
//cGame.Type
//cGame.Media
//cGame.Language
cGame.Players = dGame.Players;
cGame.Ratings = dGame.Ratings;
cGame.Genre = dGame.Genre;
//cGame.Peripheral
//cGame.BarCode
//cGame.MediaCatalogNumber
}
retDat?.AddGame(cGame);
CopyDir(nDir, headerFileType, null, cGame);
break;
case DatFile nFile:
if (nFile.isDisk)
{
break;
}
RvRom nf = new RvRom()
{
Name = nFile.Name,
Size = nFile.Size,
CRC = nFile.CRC,
SHA1 = nFile.SHA1,
MD5 = nFile.MD5,
Merge = nFile.Merge,
Status = nFile.Status,
AltType = headerFileType
};
retGame?.AddRom(nf);
break;
}
}
}
private static bool LoadRomFromDat(RvGame rvGame, HeaderFileType datFileType)
{
if (DatFileLoader.Next != "(")
{
DatUpdate.SendAndShowDat("( not found after rom", DatFileLoader.Filename);
return(false);
}
DatFileLoader.Gn();
if (DatFileLoader.Next.ToLower() != "name")
{
DatUpdate.SendAndShowDat("Name not found as first object in ( )", DatFileLoader.Filename);
return(false);
}
RvRom rvRom = new RvRom
{
Name = VarFix.CleanFullFileName(DatFileLoader.Gn()),
AltType = datFileType
};
DatFileLoader.Gn();
while (DatFileLoader.Next != ")")
{
switch (DatFileLoader.Next.ToLower())
{
case "size":
rvRom.Size = VarFix.ULong(DatFileLoader.Gn());
DatFileLoader.Gn();
break;
case "crc":
rvRom.CRC = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 8);
DatFileLoader.Gn();
break;
case "sha1":
rvRom.SHA1 = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 40);
DatFileLoader.Gn();
break;
case "md5":
rvRom.MD5 = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 32);
DatFileLoader.Gn();
break;
case "merge":
rvRom.Merge = VarFix.CleanFullFileName(DatFileLoader.Gn());
DatFileLoader.Gn();
break;
case "flags":
rvRom.Status = VarFix.ToLower(DatFileLoader.Gn());
DatFileLoader.Gn();
break;
case "date":
DatFileLoader.Gn();
DatFileLoader.Gn();
break;
case "bios":
DatFileLoader.Gn();
DatFileLoader.Gn();
break;
case "region":
DatFileLoader.Gn();
DatFileLoader.Gn();
break;
case "offs":
DatFileLoader.Gn();
DatFileLoader.Gn();
break;
case "nodump":
rvRom.Status = "nodump";
DatFileLoader.Gn();
break;
default:
DatUpdate.SendAndShowDat("Error: key word '" + DatFileLoader.Next + "' not known in rom", DatFileLoader.Filename);
DatFileLoader.Gn();
break;
}
}
rvGame.AddRom(rvRom);
return(true);
}
private static bool LoadHeaderFromDat(string filename, RvDat rvDat, out HeaderFileType datFileType, string blockstart)
{
datFileType = HeaderFileType.Nothing;
rvDat.Filename = filename;
while (DatFileLoader.Next.ToLower() != "[games]")
{
// Split the line by '='
string key = DatFileLoader.Next.Split('=')[0];
string value = DatFileLoader.Next.Remove(0, key.Length + (DatFileLoader.Next.Contains("=") ? 1 : 0));
string block = blockstart;
switch (key.ToLower())
{
// CREDITS block
case "[credits]":
block = key;
DatFileLoader.Gn();
break;
case "author":
rvDat.Author = value;
DatFileLoader.Gn();
break;
case "version":
if (block == "[credits]")
{
rvDat.Date = value;
}
else if (block == "[dat]")
{
rvDat.Version = value;
}
DatFileLoader.Gn();
break;
case "comment":
rvDat.Name = value;
rvDat.Description = value;
rvDat.Comment = value;
DatFileLoader.Gn();
break;
case "url":
rvDat.URL = value;
DatFileLoader.Gn();
break;
// DAT block
case "[dat]":
block = key;
DatFileLoader.Gn();
break;
case "plugin":
DatFileLoader.Gn();
break;
case "split":
switch (value)
{
case "0":
rvDat.MergeType = (String.IsNullOrEmpty(rvDat.MergeType) ? "" : rvDat.MergeType);
break;
case "1":
rvDat.MergeType = (String.IsNullOrEmpty(rvDat.MergeType) ? "split" : rvDat.MergeType);
break;
}
DatFileLoader.Gn();
break;
case "merge":
switch (value)
{
case "0":
rvDat.MergeType = (String.IsNullOrEmpty(rvDat.MergeType) ? "" : rvDat.MergeType);
break;
case "1":
rvDat.MergeType = (String.IsNullOrEmpty(rvDat.MergeType) ? "merge" : rvDat.MergeType);
break;
}
DatFileLoader.Gn();
break;
// EMULATOR block
case "[emulator]":
block = key;
DatFileLoader.Gn();
break;
case "refname":
DatFileLoader.Gn();
break;
default:
DatUpdate.SendAndShowDat("Error on line " + DatFileLoader.LineNumber + ": key word '" + key + "' not known in romcenter", DatFileLoader.Filename);
DatFileLoader.Gn();
break;
}
}
return(true);
}
