#include "prefix.h"

#include "core.h"

#include "globdefs.h"

#include "objdefs.h"

#include "parsedef.h"

#include "filedefs.h"

#include "execpt.h"

#include "handler.h"

#include "scriptpt.h"

#include "variable.h"

#include "statemnt.h"

#include "deploy.h"

#if 0

// A Mac OS X device image has the following structure:

// DeviceHeader

// DevicePartion*

// <partition data>

//

enum

{

kDeviceHeaderSignature = 0x4552,

kDevicePartitionSignature = 0x504D

};

struct DeviceHeader

};

struct DevicePartition

};

// A HFS+ Volume has the following structure:

// Reserved (1024 bytes)

// Volume Header

// ...

// Allocation File

// ...

// Extents Overflow File

// ...

// Catalog File

// ...

// Attributes File

// ...

// Startup File

// ...

// Alternate Volume Header

// Reserved (512 bytes)

// HFS+ Dates are stored as the number of seconds since '1904-01-01 00:00 +0000'.

struct HFSUniStr255

};

struct HFSPlusBSDInfo

};

struct HFSPlusExtentDescriptor

};

struct HFSPlusForkData

};

typedef uint32_t HFSCatalogNodeID;

struct HFSPlusVolumeHeader

};

#pragma pack(push)

#pragma pack(1)

struct HFSPlusCatalogKey

};

#pragma pack(pop)

// Volume Attributes

// The attributes field of a volume header is treated as a set of one-bit flags.

// The definition of the bits is given by the constants listed below.

enum

{

/* Bits 0-6 are reserved */

kHFSVolumeHardwareLockBit = 7,

kHFSVolumeUnmountedBit = 8,

kHFSVolumeSparedBlocksBit = 9,

kHFSVolumeNoCacheRequiredBit = 10,

kHFSBootVolumeInconsistentBit = 11,

kHFSCatalogNodeIDsReusedBit = 12,

kHFSVolumeJournaledBit = 13,

/* Bit 14 is reserved */

kHFSVolumeSoftwareLockBit = 15

/* Bits 16-31 are reserved */

};

enum {

kHFSPlusFolderRecord = 0x0001,

kHFSPlusFileRecord = 0x0002,

kHFSPlusFolderThreadRecord = 0x0003,

kHFSPlusFileThreadRecord = 0x0004

};

struct HFSFinderPoint {

int16_t v;

int16_t h;

};

struct HFSFinderRect {

};

/* OSType is a 32-bit value made by packing four 1-byte characters

together. */

typedef uint32_t HFSFinderFourCharCode;

typedef HFSFinderFourCharCode HFSFinderOSType;

/* Finder flags (finderFlags, fdFlags and frFlags) */

enum {

kIsOnDesk = 0x0001, /* Files and folders (System 6) */

kColor = 0x000E, /* Files and folders */

kIsShared = 0x0040, /* Files only (Applications only) If */

/* clear, the application needs */

/* to write to its resource fork, */

/* and therefore cannot be shared */

/* on a server */

kHasNoINITs = 0x0080, /* Files only (Extensions/Control */

/* Panels only) */

/* This file contains no INIT resource */

kHasBeenInited = 0x0100, /* Files only. Clear if the file */

/* contains desktop database resources */

/* ('BNDL', 'FREF', 'open', 'kind'...) */

/* that have not been added yet. Set */

/* only by the Finder. */

/* Reserved for folders */

kHasCustomIcon = 0x0400, /* Files and folders */

kIsStationery = 0x0800, /* Files only */

kNameLocked = 0x1000, /* Files and folders */

kHasBundle = 0x2000, /* Files only */

kIsInvisible = 0x4000, /* Files and folders */

kIsAlias = 0x8000 /* Files only */

};

/* Extended flags (extendedFinderFlags, fdXFlags and frXFlags) */

enum {

kExtendedFlagsAreInvalid = 0x8000, /* The other extended flags */

/* should be ignored */

kExtendedFlagHasCustomBadge = 0x0100, /* The file or folder has a */

/* badge resource */

kExtendedFlagHasRoutingInfo = 0x0004 /* The file contains routing */

/* info resource */

};

struct HFSFinderFileInfo {

};

struct HFSFinderExtendedFileInfo {

};

struct HFSFinderFolderInfo {

};

struct HFSFinderExtendedFolderInfo {

};

struct HFSPlusCatalogFolder {

};

struct HFSPlusCatalogFile {

};

struct HFSPlusCatalogThread

};

//////////

#pragma pack(push)

#pragma pack(1)

struct BTNodeDescriptor

};

enum

{

kBTLeafNode = -1,

kBTIndexNode = 0,

kBTHeaderNode = 1,

kBTMapNode = 2

};

struct BTHeaderRec

} /*__attribute__((__packed__))*/;

#pragma pack(pop)

enum BTreeTypes

};

enum

{

kBTBadCloseMask = 0x00000001,

kBTBigKeysMask = 0x00000002,

kBTVariableIndexKeysMask = 0x00000004

};

enum

{

kHFSCaseFolding = 0xCF,

kHFSBinaryCompare = 0xBC

};

////////////////////////////////////////////////////////////////////////////////

static void swap_device_header(DeviceHeader& x)

{

MCDeployByteSwapRecord(true, "sslsslslss", &x, sizeof(x));

}

static void swap_device_partition(DevicePartition& x)

}

static void swap_hfsplus_volume_header(HFSPlusVolumeHeader& x)

}

static void swap_bt_node_descriptor(BTNodeDescriptor& x)

{

MCDeployByteSwapRecord(true, "llbbss", &x, sizeof(x));

}

static void swap_bt_header_rec(BTHeaderRec& x)

{

MCDeployByteSwapRecord(true, "sllllssllslbbll", &x, sizeof(x));

}

static void swap_hfs_unistr(HFSUniStr255& dst, const HFSUniStr255& src)

}

static void swap_hfsplus_catalog_folder(HFSPlusCatalogFolder& x)

{

MCDeployByteSwapRecord(true, "sslllllll llbbsl ssssssss sslssl ll", &x, sizeof(x));

}

static void swap_hfsplus_catalog_file(HFSPlusCatalogFile& x)

{

MCDeployByteSwapRecord(true, "sslllllll llbbsl llssss ssssssl ll qllllllllllllllllll qllllllllllllllllll", &x, sizeof(x));

}

////////////////////////////////////////////////////////////////////////////////

// Constructing a DMG consists of a multi-step process.

//

// The first step is to take the list of files and folders that are required

// and to construct a linear list of 'Catalog' entries that will be present in

// the filesystem. Each item generates two catalog entries - the data entry and

// the thread entry. The data entries contain the actual file/folder info while

// the thread entries generate mappings from catalog ids to items.

//

// After the list of entries is built, it is sorted and a list of data records

// built. These records are the records that get encoded into the B-Tree. This

// list of records is then turned into a B-Tree structure level-by-level, until

// a level is generated that has only one entry.

//

//

//

// A single sector is either a reference to a 512 byte block of a file, or is

// a reference to a 512-byte block of memory. If 'data' is nil, then it is an

// empty sector.

struct DmgSector

};

// A single leaf node in the Catalog BTree.

struct DmgBTreeCatalogLeaf

};

struct DmgBTreeRecord

};

struct DmgBTree

};

static void dmg_compute_ids(uint32_t p_index, uint32_t p_parent_index, uint32_t p_parent_parent_index, uint32_t& r_id, uint32_t& r_parent_id)

}

// Split the given records up into new nodes, at the given level. The leading

// records for each node are returned in the provided buffer.

static bool dmg_btree_build_level(DmgBTree *self, uint32_t p_level, DmgBTreeRecord *p_records, uint32_t p_record_count, uint32_t *r_leaders, uint32_t& r_leader_count)

}

// Sort the leaves (thread and non-thread) items in order. The key for the

// thread items is (id, ''), the key for the non-thread items is (parent id, name).

static int dmg_btree_sort_leaves(void *p_context, const void *p_a, const void *p_b)

}

static uint32_t unix_date_to_hfs_date(uint32_t p_date)

{

return p_date;

}

#endif

Exec_stat MCDeployDmgBuild(MCDeployDmgParameters& p_params)