scummvm/common/formats/prodos.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef COMMON_PRODOS_H
#define COMMON_PRODOS_H

#include "common/memstream.h"
#include "common/file.h"
#include "common/debug.h"
#include "common/error.h"

/* Quick note about ProDOS:
 * This disk code handles inactive, seedling, sapling, tree, and subdirectory files.
 * It does *not* handle sparse files at the moment. If a sparse file exists, it may not
 * be read correctly. It also does not do anything with Pascal files, but those should not
 * matter for game engines anyway.
 */

namespace Common {

// These values define for ProDOS how to read the file entry, and also whether it's a keyblock (if it is a directory header, it's the keyblock of that directory)
enum FileType : char {
	kFileTypeDead    = 0,
	kFileTypeSeed    = 1,
	kFileTypeSapling = 2,
	kFileTypeTree    = 3,
	kFileTypePascal  = 4,
	kFileTypeSubDir  = 0x0D,
	kFileTypeSubHead = 0x0E,
	kFileTypeVolHead = 0x0F
};

/* File extensions for all the ProDOS supported file types
 * NOTE: ProDOS user defined files are F1-F8. If they are ever required,
 * they can be added to this enum.
 */
enum FileExt {
	kFileExtNull     = 0,
	kFileExtBad      = 1,
	kFileExtTxt      = 4,
	kFileExtBin      = 6,
	kFileExtGfx      = 8,
	kFileExtDir      = 0xF,
	kFileExtDB       = 0x19,
	kFileExtWord     = 0x1A,
	kFileExtSpread   = 0x1B,
	kFileExtSTART    = 0xB3,
	kFileExtPascal   = 0xEF,
	kFileExtPDCI     = 0xF0,
	kFileExtPDRes    = 0xF9,
	kFileExtIBProg   = 0xFA,
	kFileExtIBVar    = 0xFB,
	kFileExtAPSProg  = 0xFC,
	kFileExtAPSVar   = 0xFD,
	kFileExtEDASM    = 0xFE,
	kFileExtSYS      = 0xFF
};

/* A ProDOS file simply contains meta data about the file and the ability to
 * find and put together the data blocks that make up the file contents.
 * This implements Common::ArchiveMember so that it can be used directly in
 * the Archive methods in ProDOSDisk.
 */

class ProDOSFile : public Common::ArchiveMember {
public:
	ProDOSFile(char name[16], uint8 type, uint16 tBlk, uint32 eof, uint16 bPtr, Common::File *disk);
	~ProDOSFile() {};                                            // File does not need a destructor, because the file it reads from is a pointer to Disk, and Disk has a destructor

	// -- These are the Common::ArchiveMember related functions --
	Common::String getName() const override;                              // Returns _name
	Common::SeekableReadStream *createReadStream() const override;        // This is what the archive needs to create a file
	void getDataBlock(byte *memOffset, int offset, int size) const;       // Gets data up to the size of a single data block (512 bytes)
	int parseIndexBlock(byte *memOffset, int blockNum, int cSize) const;  // Uses getDataBlock() on every pointer in the index file, adding them to byte * memory block

	// For debugging purposes, just prints the metadata
	void printInfo();

private:
	char   _name[16];
	uint8  _type;                           // As defined by enum FileType
	uint16 _blockPtr;                       // Block index in volume of index block or data
	uint16 _totalBlocks;
	uint32 _eof;                            // End Of File, used generally as size (exception being sparse files)
	Common::File *_disk;                    // This is a pointer because it is the same _disk as in ProDosDisk, passed to the file object
};

/* This class defines the entire disk volume. Upon using the open() method,
 * it will parse the volume and add them to a hashmap where the file path
 * returns a file object. This implements Common::Archive to allow regular
 * file operations to work with it.
 */

class ProDOSDisk : public Common::Archive {
public:
	static const int kBlockSize = 512;		// A ProDOS block is always 512 bytes (should this be an enum?)

	ProDOSDisk(const Common::String filename);
	~ProDOSDisk();							// Frees the memory used in the dictionary and the volume bitmap

	// Called from the constructor, it parses the volume and fills the hashmap with files
	bool open(const Common::String filename);

	// These are the Common::Archive related methods
	bool hasFile(const Common::Path &path) const override;
	int listMembers(Common::ArchiveMemberList &list) const override;
	const Common::ArchiveMemberPtr getMember(const Common::Path &path) const override;
	Common::SeekableReadStream *createReadStreamForMember(const Common::Path &path) const override;

private:
	byte _loader1[kBlockSize];				// There's not much reason for these to be needed, but I included them just in case
	byte _loader2[kBlockSize];
	Common::String _name;					// Name of volume
	Common::File _disk;						// The volume file itself
	int _volBlocks;							// Total blocks in volume
	byte *_volBitmap;						// This can determine if the volume is corrupt as it contains a bit for every block, where 0 = unused, 1 = used
	Common::HashMap<Common::String, Common::SharedPtr<ProDOSFile>> _files; // Hashmap of files in the volume, where key=Path, Value=ProDOSFile

	struct Date {
		uint8 _day;
		uint8 _month;
		uint8 _year;
	};

	struct Time {
		uint8 _hour;
		uint8 _minute;
	};

	struct VolHeader {
		uint8 _type;						// Not really important for a volume header, as this will always be F
		uint8 _nameLen;
		char _name[16];
		byte _reserved[8];					// Extra space reserved for possible future uses, not important
		Date _date;
		Time _time;
		uint8 _ver;
		uint8 _minVer;						// Should pretty much always be 0 as far as I know
		uint8 _access;						// If this ends up useful, there should be an enum for the access values
		uint8 _entryLen;					// Always 27 in ProDOS 1.0
		uint8 _entriesPerBlock;				// Always 0D in ProDOS 1.0
		uint16 _fileCount;                  // Number of files across all data blocks in this directory
		uint16 _bitmapPtr;                  // Block pointer to the keyblock of the bitmap for the entire volume
		uint16 _volBlocks;                  // Blocks in entire volume
	};

	struct DirHeader {
		uint8 _type;
		uint8 _nameLen;
		char _name[16];
		byte _reserved[8];
		Date _date;
		Time _time;
		uint8 _ver;
		uint8 _minVer;
		uint8 _access;
		uint8 _entryLen;
		uint8 _entriesPerBlock;
		uint16 _fileCount;
		uint16 _parentBlockPtr;             // These values allow ProDOS to navigate back out of a directory, but they aren't really needed by the class to navigate
		uint8 _parentEntryIndex;			// Index in the current directory
		uint8 _parentEntryLen;				// This is always 27 in ProDOS 1.0
	};

	struct FileEntry {
		uint8 _type;						// 0 = inactive, 1-3 = file, 4 = pascal area, 14 = subdirectory, 15 = volume directory
		uint8 _nameLen;
		char _name[16];
		uint8 _ext;							// File extension, uses the enum FileExt
		uint16 _blockPtr;                   // Block pointer to data for seedling, index block for sapling, or master block for tree
		uint16 _totalBlocks;                // Really important to remember this is the total *including* the index block
		uint32 _eof;                        // This is a long (3 bytes, read low to high) value representing the total readable data in a file (unless it's a sparse file, be careful!)
		Date _date;
		Time _time;
		uint8 _ver;
		uint8 _minVer;
		uint8 _access;
		uint16 _varUse;
		Date _modDate;
		Time _modTime;
		uint16 _dirHeadPtr;                 // Pointer to the key block of the directory that contains this file entry
	};

	void getDate(Date *d, uint16 date);     // Decompresses the date into a struct
	void getTime(Time *t, uint16 time);     // Decompresses the time into a struct
	void getHeader(DirHeader *h);           // Adds the main header values to the struct
	void getDirectoryHeader(DirHeader *h);  // Uses getHeader and then fills in the values for the parent directory
	void getVolumeHeader(VolHeader *dir);   // Uses getHeader and then fills in the volume related information (there is no parent directory to this one)
	void getFileEntry(FileEntry *f);        // Adds all of the file entry information to the struct
	void searchDirectory(DirHeader *h, uint16 p, uint16 n, Common::String path);  // Recursively searches all files within a directory, by calling itself for subdirectories
	void getVolumeBitmap(VolHeader *h);     // Puts together the volume bitmap
};


} // Namespace Common

#endif