Apple-2-Tools/ciderpress
1
0
Fork 0
mirror of https://github.com/fadden/ciderpress.git synced 2024-11-23 11:33:58 +00:00
Code Issues Projects Releases Wiki Activity
759f0d820f
ciderpress/reformat/Disasm.h

454 lines
14 KiB
C
Raw Normal View History

initial import
2007-03-27 17:47:10 +00:00
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* 6502/65C02/65802/65816 disassembly.
*
* Lots of credit to the classic "Programming the 65816" book by David Eyes
* and Ron Lichty.
*/
Large set of changes to restore CiderPress build. CiderPress and MDC now compile, and execute far enough to open their respective "about" boxes, but I doubt they'll do much more than that. * Switch from MBCS to UNICODE APIs Microsoft switched to UTF-16 (by way of UCS-2) a long time ago, and the support for MBCS seems to be getting phased out. So it's time to switch to wide strings. This is a bit awkward for CiderPress because it works with disk and file archives with 8-bit filenames, and I want NufxLib and DiskImgLib to continue to work on Linux (which has largely taken the UTF-8 approach to Unicode). The libraries will continue to work with 8-bit filenames, with CiderPress/MDC doing the conversion at the appropriate point. There were a couple of places where strings from a structure handed back by one of the libraries were used directly in the UI, or vice-versa, which is a problem because we have nowhere to store the result of the conversion. These currently have fixed place-holder "xyzzy" strings. All UI strings are now wide. Various format strings now use "%ls" and "%hs" to explicitly specify wide and narrow. This doesn't play well with gcc, so only the Windows-specific parts use those. * Various updates to vcxproj files The project-file conversion had some cruft that is now largely gone. The build now has a common output directory for the EXEs and libraries, avoiding the old post-build copy steps. * Added zlib 1.2.8 and nufxlib 2.2.2 source snapshots The old "prebuilts" directory is now gone. The libraries are now built as part of building the apps. I added a minimal set of files for zlib, and a full set for nufxlib. The Linux-specific nufxlib goodies are included for the benefit of the Linux utilities, which are currently broken (don't build). * Replace symbols used for include guards Symbols with a leading "__" are reserved.
2014-11-10 23:32:55 +00:00
#ifndef REFORMAT_DISASM_H
#define REFORMAT_DISASM_H
initial import
2007-03-27 17:47:10 +00:00
#include "ReformatBase.h"
/*
* Disassembly base class. Common code and data for all formats.
*/
class ReformatDisasm65xxx : public ReformatText {
public:
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
ReformatDisasm65xxx(void) {
fOneByteBrkCop = false;
ValidateOpMap();
ValidateOpCodeDetails();
}
virtual ~ReformatDisasm65xxx(void) {}
/*
* OpCode enumeration, must fit in 0-255.
*/
typedef enum OpCode {
kOpCodeUnknown = 0,
kOpADC, kOpAND, kOpASL, kOpBCC,
kOpBCS, kOpBEQ, kOpBIT, kOpBMI,
kOpBNE, kOpBPL, kOpBRA, kOpBRK,
kOpBRL, kOpBVC, kOpBVS, kOpCLC,
kOpCLD, kOpCLI, kOpCLV, kOpCMP,
kOpCOP, kOpCPX, kOpCPY, kOpDEC,
kOpDEX, kOpDEY, kOpEOR, kOpINC,
kOpINX, kOpINY, kOpJML, kOpJMP,
kOpJSL, kOpJSR, kOpLDA, kOpLDX,
kOpLDY, kOpLSR, kOpMVN, kOpMVP,
kOpNOP, kOpORA, kOpPEA, kOpPEI,
kOpPER, kOpPHA, kOpPHB, kOpPHD,
kOpPHK, kOpPHP, kOpPHX, kOpPHY,
kOpPLA, kOpPLB, kOpPLD, kOpPLP,
kOpPLX, kOpPLY, kOpREP, kOpROL,
kOpROR, kOpRTI, kOpRTL, kOpRTS,
kOpSBC, kOpSEC, kOpSED, kOpSEI,
kOpSEP, kOpSTA, kOpSTP, kOpSTX,
kOpSTY, kOpSTZ, kOpTAX, kOpTAY,
kOpTCD, kOpTCS, kOpTDC, kOpTRB,
kOpTSB, kOpTSC, kOpTSX, kOpTXA,
kOpTXS, kOpTXY, kOpTYA, kOpTYX,
kOpWAI, kOpWDM, kOpXBA, kOpXCE,
kOpCodeMAX
} OpCode;
/*
* Address mode enumeration, must fit in 0-255.
*/
typedef enum AddrMode {
kAddrModeUnknown = 0,
kAddrAbs,
kAddrAbsIndexX,
kAddrAbsIndexY,
kAddrAbsIndexXInd,
kAddrAbsInd,
kAddrAbsIndLong,
kAddrAbsLong,
kAddrAbsIndexXLong,
kAddrAcc,
kAddrBlockMove,
kAddrDP,
kAddrDPIndexX,
kAddrDPIndexY,
kAddrDPIndexXInd,
kAddrDPInd,
kAddrDPIndLong,
kAddrDPIndIndexY,
kAddrDPIndIndexYLong,
kAddrImm,
kAddrImplied,
kAddrPCRel,
kAddrPCRelLong,
kAddrStackAbs,
kAddrStackDPInd,
kAddrStackInt,
kAddrStackPCRel,
kAddrStackPull,
kAddrStackPush,
kAddrStackRTI,
kAddrStackRTL,
kAddrStackRTS,
kAddrStackRel,
kAddrStackRelIndexY,
kAddrWDM,
kAddrModeMAX
} AddrMode;
/*
* Specify the CPU to emulate when disassembling.
*/
typedef enum CPU {
kCPU6502,
kCPU65C02,
kCPU65802,
kCPU65816,
kCPUCount
} CPU;
initial import
2007-03-27 17:47:10 +00:00
protected:
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
/*
* Table mapping instruction byte values to an opcode and address mode.
*
* There are 256 entries, each of which is a combination of OpCode and
* AddrMode.
*/
typedef struct OpMap {
int opAndAddr[kCPUCount];
} OpMap;
/*
* We have a table of these, with one entry in the table for each
* entry in the OpCode enum. We use a 1:1 mapping, so it's vital that
* the entries line up.
*/
typedef struct OpCodeDetails {
OpCode opCode; // sanity check
char mnemonic[4]; // 3-letter mnemonic
} OpCodeDetails;
bool fOneByteBrkCop;
/*
* Output one or more lines of code in a manner appropriate for a
* monitor listing on an 8-bit machine. Returns the #of bytes consumed.
*/
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
int OutputMonitor8(const uint8_t* srcBuf, long srcLen,
long backState, uint16_t addr);
int OutputMonitor16(const uint8_t* srcBuf, long srcLen,
long backState, uint32_t addr, bool shortRegs);
initial import
2007-03-27 17:47:10 +00:00
private:
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
bool ValidateOpMap(void);
static const OpMap kOpMap[];
bool ValidateOpCodeDetails(void);
static const OpCodeDetails kOpCodeDetails[];
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
inline uint16_t RelOffset(uint16_t addr, uint8_t off) {
int8_t shift = (int8_t) off; // offset is signed
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
return addr +2 + shift;
}
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
inline uint16_t RelLongOffset(uint16_t addr, uint16_t off) {
int16_t shift = (int16_t) off; // offset is signed
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
return addr +3 + shift;
}
enum {
kMaxByteConsumption = 4, // max #of bytes for one output
};
int GetOpWidth(OpCode opCode, AddrMode addrMode, CPU cpu,
bool emul, bool shortM, bool shortX);
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
bool IsP8Call(const uint8_t* srcBuf, long srcLen);
bool IsToolboxCall(const uint8_t* srcBuf, long srcLen,
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
long backState);
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
bool IsInlineGSOS(const uint8_t* srcBuf, long srcLen);
bool IsStackGSOS(const uint8_t* srcBuf, long srcLen,
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
long backState);
void PrintMonitor8Line(OpCode opCode, AddrMode addrMode,
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
uint16_t addr, const uint8_t* srcBuf, long srcLen,
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
const char* comment);
void PrintMonitor16Line(OpCode opCode, AddrMode addrMode,
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
uint32_t addr, const uint8_t* srcBuf, long srcLen,
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
const char* comment);
/* 24-bit address helpers */
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
inline uint8_t Bank(uint32_t addr) {
return (uint8_t) ((addr >> 16) & 0xff);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
}
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
inline uint16_t Offset(uint32_t addr) {
return (uint16_t) (addr & 0xffff);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
}
initial import
2007-03-27 17:47:10 +00:00
};
/*
* 8-bit code disassembly.
*
* Used for DOS 'B' files and ProDOS BIN/SYS.
*/
class ReformatDisasm8 : public ReformatDisasm65xxx {
public:
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
ReformatDisasm8(void) {}
virtual ~ReformatDisasm8(void) {}
initial import
2007-03-27 17:47:10 +00:00
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
virtual void Examine(ReformatHolder* pHolder) override;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
virtual int Process(const ReformatHolder* pHolder,
ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
ReformatOutput* pOutput) override;
initial import
2007-03-27 17:47:10 +00:00
};
/*
* This holds an OMF segment header, and abstracts away version
* differences.
*/
class OMFSegmentHeader {
public:
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
OMFSegmentHeader(void) : fReady(false) {}
virtual ~OMFSegmentHeader(void) {}
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
bool Unpack(const uint8_t* srcBuf, long srcLen, int fileType);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
void Dump(void) const;
typedef enum SegmentType {
kTypeCode = 0x00,
kTypeData = 0x01,
kTypeJumpTable = 0x02,
kTypePathName = 0x04,
kTypeLibraryDict = 0x08,
kTypeInit = 0x10,
kTypeAbsoluteBank = 0x11,
kTypeDPStack = 0x12,
} SegmentType;
typedef enum SegmentFlag {
kFlagBankRelative,
kFlagSkip,
kFlagReload,
kFlagAbsoluteBank,
kFlagNoSpecialMem,
kFlagPositionIndep,
kFlagPrivate,
kFlagDynamic,
} SegmentFlag;
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
uint8_t GetVersion(void) const { return fVersion; }
uint32_t GetSegmentLen(void) const { return fByteCnt; }
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
SegmentType GetSegmentType(void) const;
bool GetSegmentFlag(SegmentFlag flag) const;
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
uint16_t GetSegNum(void) const { return fSegNum; }
uint8_t GetLabLen(void) const { return fLabLen; }
uint8_t GetNumLen(void) const { return fNumLen; }
uint16_t GetDispData(void) const { return fDispData; }
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
const char* GetLoadName(void) const { return (const char*) fLoadName; }
const char* GetSegName(void) const { return (const char*) fSegName; }
// some of these must be public in VC++6.0
enum {
kMaxVersion = 2, // v0/1/2 == OMF 1.0 / 2.0 / 2.1
kLoadNameLen = 10,
kV0HdrMinSize = 0x25,
kV1HdrMinSize = 0x2c + kLoadNameLen,
kV2HdrMinSize = 0x30 + kLoadNameLen,
kHdrMinSize = kV0HdrMinSize, // smallest of the three
kExpectedNumLen = 4,
kExpectedBankSize = 65536,
kSegNameLen = 255,
};
initial import
2007-03-27 17:47:10 +00:00
private:
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
bool fReady;
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
inline uint16_t Get16LE(const uint8_t* buf) {
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
return *buf | *(buf+1) << 8;
}
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
inline uint32_t Get32LE(const uint8_t* buf) {
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
return *buf | *(buf+1) << 8 | *(buf+2) << 16 | *(buf+3) << 24;
}
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
uint32_t fBlockCnt; // v0/v1
uint32_t fByteCnt; // v2
uint32_t fResSpc;
uint32_t fLength;
uint8_t fType; // v0/v1
uint8_t fLabLen;
uint8_t fNumLen; // (always 4)
uint8_t fVersion; // (0, 1, or 2)
uint32_t fBankSize; // (always 65536)
uint16_t fKind; // v2
uint32_t fOrg;
uint32_t fAlign;
uint8_t fNumSex;
uint8_t fLCBank; // v1
uint16_t fSegNum; // v1/v2
uint32_t fEntry; // v1/v2
uint16_t fDispName; // v1/v2
uint16_t fDispData; // v1/v2
uint32_t fTempOrg; // v2
uint8_t fLoadName[kLoadNameLen + 1]; // 10 chars, space-padded
uint8_t fSegName[kSegNameLen + 1]; // 1-255 chars
initial import
2007-03-27 17:47:10 +00:00
};
#if 0
/*
* Constants and functions for manipulating an OMF segment.
*/
class OMFSegment {
public:
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
OMFSegment(void) : fSegBuf(NULL), fSegLen(-1), fCurPtr(NULL),
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
fNumLen(-1), fLabLen(-1)
{}
virtual ~OMFSegment(void) {}
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
void Setup(const OMFSegmentHeader* pSegHdr, const uint8_t* srcBuf,
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
long srcLen);
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
const uint8_t* ProcessNextChunk(void);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
/*
* Segment op codes.
*/
typedef enum SegmentOp {
kSegOpEND = 0x00, // all
kSegOpCONSTStart = 0x01, // object
kSegOpCONSTEnd = 0xdf, // object
kSegOpALIGN = 0xe0, // object
kSegOpORG = 0xe1, // org
kSegOpRELOC = 0xe2, // load
kSegOpINTERSEG = 0xe3, // load
kSegOpUSING = 0xe4, // object
kSegOpSTRONG = 0xe5, // object
kSegOpGLOBAL = 0xe6, // object
kSegOpGEQU = 0xe7, // object
kSegOpMEM = 0xe8, // object
// 0xe9, 0xea unused
kSegOpEXPR = 0xeb, // object
kSegOpZEXPR = 0xec, // object
kSegOpBEXPR = 0xed, // object
kSegOpRELEXPR = 0xee, // object
kSegOpLOCAL = 0xef, // object
kSegOpEQU = 0xf0, // object
kSegOpDS = 0xf1, // all
kSegOpLCONST = 0xf2, // all
kSegOpLEXPR = 0xf3, // object
kSegOpENTRY = 0xf4, // RTL
kSegOpcRELOC = 0xf5, // load
kSegOpcINTERSEG = 0xf6, // load
kSegOpSUPER = 0xf7, // load
kSegOpGeneral = 0xfb, // reserved
kSegOpExperimental1 = 0xfc, // reserved
kSegOpExperimental2 = 0xfd, // reserved
kSegOpExperimental3 = 0xfe, // reserved
kSegOpExperimental4 = 0xff, // reserved
} SegmentOp;
/*
* Expression operands.
*/
typedef enum ExprOp {
kExprOpEnd = 0x00,
kExprOpAddition = 0x01,
kExprOpSubtraction = 0x02,
kExprOpMultiplication = 0x03,
kExprOpDivision = 0x04,
kExprOpIntegerRemainder = 0x05,
kExprOpUnaryNegation = 0x06,
kExprOpBitShift = 0x07,
kExprOpAND = 0x08,
kExprOpOR = 0x09,
kExprOpEOR = 0x0a,
kExprOpNOT = 0x0b,
kExprOpLessThenEqualTo = 0x0c,
kExprOpGreaterThanEqualTo = 0x0d,
kExprOpNotEqual = 0x0e,
kExprOpLessThan = 0x0f,
kExprOpGreaterThan = 0x10,
kExprOpEqualTo = 0x11,
kExprOpBitAND = 0x12,
kExprOpBitOR = 0x13,
kExprOpBitEOR = 0x14,
kExprOpBitNOT = 0x15,
kExprOpPushLocation = 0x80,
kExprOpPushConstant = 0x81,
kExprOpPushLabelWeak = 0x82,
kExprOpPushLabelValue = 0x83,
kExprOpPushLabelLength = 0x84,
kExprOpPushLabelType = 0x85,
kExprOpPushLabelCount = 0x86,
kExprOpPushRelOffset = 0x87,
} ExprOp;
initial import
2007-03-27 17:47:10 +00:00
private:
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
// inline uint16_t Get16LE(const uint8_t* buf) {
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
// return *buf | *(buf+1) << 8;
// }
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
inline uint32_t Get32LE(const uint8_t* buf) {
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
return *buf | *(buf+1) << 8 | *(buf+2) << 16 | *(buf+3) << 24;
}
/*
* Given a pointer to the start of a label, return the label's len.
* The length returned includes the length byte (if present).
*/
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
int LabelLength(const uint8_t* ptr) {
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
if (fLabLen != 0)
return fLabLen;
else
return (*ptr) +1;
}
/* determine the length of an expression */
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
int ExpressionLength(const uint8_t* ptr);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
const uint8_t* fSegBuf;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
long fSegLen;
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
const uint8_t* fCurPtr;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
int fNumLen;
int fLabLen;
initial import
2007-03-27 17:47:10 +00:00
};
#endif
/*
* 16-bit code disassembly.
*
* Used for GS/OS S16, EXE, PIF, and others.
*
* OMF information comes from Appendix F of the Apple IIgs GS/OS Reference
* manual and Appendix B of the Orca/M assembler manual.
*/
class ReformatDisasm16 : public ReformatDisasm65xxx {
public:
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
ReformatDisasm16(void) {}
virtual ~ReformatDisasm16(void) {}
initial import
2007-03-27 17:47:10 +00:00
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
virtual void Examine(ReformatHolder* pHolder) override;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
virtual int Process(const ReformatHolder* pHolder,
ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
ReformatOutput* pOutput) override;
initial import
2007-03-27 17:47:10 +00:00
private:
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
void OutputSection(const uint8_t* srcBuf, long srcLen,
uint32_t addr, bool shortRegs);
bool OutputOMF(const uint8_t* srcBuf, long srcLen,
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
long fileType, bool shortRegs);
void PrintHeader(const OMFSegmentHeader* pSegHdr,
int segmentNumber, bool longFmt);
void PrintSegment(const OMFSegmentHeader* pSegHdr,
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
const uint8_t* srcBuf, long srcLen, bool shortRegs);
initial import
2007-03-27 17:47:10 +00:00
};
Large set of changes to restore CiderPress build. CiderPress and MDC now compile, and execute far enough to open their respective "about" boxes, but I doubt they'll do much more than that. * Switch from MBCS to UNICODE APIs Microsoft switched to UTF-16 (by way of UCS-2) a long time ago, and the support for MBCS seems to be getting phased out. So it's time to switch to wide strings. This is a bit awkward for CiderPress because it works with disk and file archives with 8-bit filenames, and I want NufxLib and DiskImgLib to continue to work on Linux (which has largely taken the UTF-8 approach to Unicode). The libraries will continue to work with 8-bit filenames, with CiderPress/MDC doing the conversion at the appropriate point. There were a couple of places where strings from a structure handed back by one of the libraries were used directly in the UI, or vice-versa, which is a problem because we have nowhere to store the result of the conversion. These currently have fixed place-holder "xyzzy" strings. All UI strings are now wide. Various format strings now use "%ls" and "%hs" to explicitly specify wide and narrow. This doesn't play well with gcc, so only the Windows-specific parts use those. * Various updates to vcxproj files The project-file conversion had some cruft that is now largely gone. The build now has a common output directory for the EXEs and libraries, avoiding the old post-build copy steps. * Added zlib 1.2.8 and nufxlib 2.2.2 source snapshots The old "prebuilts" directory is now gone. The libraries are now built as part of building the apps. I added a minimal set of files for zlib, and a full set for nufxlib. The Linux-specific nufxlib goodies are included for the benefit of the Linux utilities, which are currently broken (don't build). * Replace symbols used for include guards Symbols with a leading "__" are reserved.
2014-11-10 23:32:55 +00:00
#endif /*REFORMAT_DISASM_H*/
Reference in New Issue Copy Permalink