private DragonDosFile ReadLocalFile(string localFilename, IEnumerator <string> ai)
{
if (localFilename.EndsWith(".CAS", StringComparison.InvariantCultureIgnoreCase))
{
return(ReadLocalCasFile(localFilename, ai));
}
else
{
var data = File.ReadAllBytes(localFilename);
DragonDosFile file = null;
switch (filetype)
{
case FileType.Data:
file = DragonDosFile.CreateDataFile(data);
break;
case FileType.Basic:
file = DragonDosFile.CreateBasicFile(data);
break;
case FileType.Native:
file = DragonDosFile.CreateMachineCodeFile(data, LoadAddress, StartAddress);
break;
default:
throw new Exception("Invalid file type specified");
}
return(file);
}
}
/// <summary>
/// Write a DragonDos file to a Dragon virtual tape in the CAS format. If the CAS file already exists, write the
/// file to the end of the virtual tape.
/// </summary>
/// <param name="file">DragonDos file.</param>
/// <param name="tapeFilename">Name of the CAS file.</param>
/// <param name="ai">Additional arguments: Optional name of file within virtual tape container.</param>
private void SaveToCasFile(DragonDosFile file, string tapeFilename, IEnumerator <string> ai)
{
var localFilename = ai.MoveNext() ? ai.Current : file.FileInfo.Name;
IFile dragonFile;
switch (file.FileType)
{
case DragonDosFileType.MachineCode:
dragonFile = DragonFile.CreateMachineCodeFile(localFilename, file.GetData(), file.LoadAddress, file.StartAddress, false, false);
break;
case DragonDosFileType.Basic:
if (ascii)
{
var basicTokenizer = new DragonBasicTokenizer(DragonBasicDialect.DragonDos);
var basicText = basicTokenizer.DecodeToBytes(file.GetData());
dragonFile = DragonFile.CreateBasicFile(localFilename, basicText, true, true);
}
else
{
dragonFile = DragonFile.CreateBasicFile(localFilename, file.GetData(), false, false);
}
break;
default:
dragonFile = DragonFile.CreateDataFile(localFilename, file.GetData(), false, false);
break;
}
using (var tape = new DragonTape(new CasTape(new FileStream(tapeFilename, FileMode.Append))))
{
tape.WriteFile(dragonFile);
}
}
/// <summary>
/// Write a DragonDos file to a file container.
/// </summary>
/// <param name="file">DragonDos file to write to a new container.</param>
/// <param name="localFilename">Filename of new container.</param>
/// <param name="ai">Enumerator for accessing any container-specific arguments.</param>
private void SaveLocalFile(DragonDosFile file, string localFilename, IEnumerator <string> ai)
{
if (localFilename.EndsWith(".CAS", StringComparison.InvariantCultureIgnoreCase))
{
SaveToCasFile(file, localFilename, ai);
}
else
{
SaveToPlainFile(file, localFilename);
}
}
/// <summary>
/// Write a DragonDos file to a plain data file in the local file system.
/// </summary>
/// <param name="file">DragonDos file.</param>
/// <param name="localFilename">Local filename.</param>
private void SaveToPlainFile(DragonDosFile file, string localFilename)
{
if (file.FileType == DragonDosFileType.Basic && ascii)
{
var basicTokenizer = new DragonBasicTokenizer(DragonBasicDialect.DragonDos);
var basicText = basicTokenizer.Decode(file.GetData());
var output = new StreamWriter(new FileStream(localFilename, FileMode.Create), Encoding.ASCII);
output.Write(basicText);
output.Close();
}
else
{
File.WriteAllBytes(localFilename, file.GetData());
}
}
/// <summary>
/// Output information about a DragonDos file to the console.
/// </summary>
/// <param name="file">File to output information about.</param>
private static void PrintFileInformation(DragonDosFile file)
{
switch (file.FileType)
{
case DragonDosFileType.MachineCode:
Console.WriteLine("DragonDos machine code program: Load address={0} Length={1} Start address={2}", file.LoadAddress, file.Length, file.StartAddress);
break;
case DragonDosFileType.Basic:
Console.WriteLine("DragonDos BASIC program: Length={0}", file.Length);
break;
default:
Console.WriteLine("DragonDos data file: Length={0}", file.Length);
break;
}
}
/// <summary>
/// Read a file from a virtual Dragon cassette and return the corresponding DragonDosFile
/// object.
/// </summary>
/// <param name="tapeFilename">Name of the virtual Dragon tape.</param>
/// <param name="ai">Additional parameters: Filename</param>
/// <returns></returns>
private DragonDosFile ReadLocalCasFile(string tapeFilename, IEnumerator <string> ai)
{
var filename = ai.MoveNext() ? ai.Current : null;
using (var tape = new DragonTape(new CasTape(new FileStream(tapeFilename, FileMode.Open))))
{
var file = (DragonFile)tape.ReadFile(filename);
switch (file.FileType)
{
case DragonFileType.Basic:
return(DragonDosFile.CreateBasicFile(file.GetData()));
case DragonFileType.MachineCode:
return(DragonDosFile.CreateMachineCodeFile(file.GetData(), file.LoadAddress, file.StartAddress));
case DragonFileType.Data:
return(DragonDosFile.CreateDataFile(file.GetData()));
default:
throw new InvalidFileTypeException();
}
}
}
private void Run(string[] args)
{
try
{
var files = ParseOptions(args);
if (files.Count == 0)
{
ShowUsage();
return;
}
var diskFileName = files[0] + ".vdk";
if (Verbose)
{
Console.WriteLine("Writing output VDK disk image \"{0}\".", diskFileName);
}
using (var dos = DragonDos.Initialize(DiskFactory.CreateDisk(diskFileName, DiskHeads, DiskTracks, DiskSectors, DiskSectorSize)))
{
foreach (var file in files)
{
if (Verbose)
{
Console.WriteLine("Writing file \"{0}\" to disk image.", file);
}
dos.WriteFile(Path.GetFileName(file).ToUpper(), DragonDosFile.CreateDataFile(IOUtils.ReadStreamFully(new FileStream(file, FileMode.Open))));
}
}
}
catch (DirectoryFullException e)
{
Console.Error.WriteLine("ERROR: Cannot write file to filesystem. The directory is full.");
if (Debug)
{
Console.Error.WriteLine(e);
}
return;
}
catch (FileExistsException e)
{
Console.Error.WriteLine("ERROR: Cannot write the file as a file with the same name already exists.");
if (Debug)
{
Console.Error.WriteLine(e);
}
return;
}
catch (FilesystemFullException e)
{
Console.Error.WriteLine("ERROR: Cannot write file as the filesystem is full.");
if (Debug)
{
Console.Error.WriteLine(e);
}
return;
}
catch (InvalidFilenameException e)
{
Console.Error.WriteLine("ERROR: The filename {0} is invalid.", e.Filename);
if (Debug)
{
Console.Error.WriteLine(e);
}
return;
}
catch (System.IO.IOException e)
{
Console.Error.WriteLine("ERROR: Local filesystem I/O error.");
if (Debug)
{
Console.Error.WriteLine(e);
}
return;
}
catch (Exception e)
{
Console.Error.WriteLine("ERROR: Unexpected error.");
if (Debug)
{
Console.Error.WriteLine(e);
}
return;
}
}
