Apple-2-Tools/ciderpress
1
0
Fork 0
mirror of https://github.com/fadden/ciderpress.git synced 2024-12-01 19:50:21 +00:00
Code Issues Projects Releases Wiki Activity
b79498da50
ciderpress/reformat/Disasm.cpp

1438 lines
44 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.
*/
/*
* Disassemble Apple II binaries.
*/
#include "StdAfx.h"
#include "Disasm.h"
/*
* ===========================================================================
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
* Common stuff for 65xxx-series CPU
initial import
2007-03-27 17:47:10 +00:00
* ===========================================================================
*/
/*
* The color scheme from Don Lancaster's "Enhancing your Apple II, Volume 1,
* Second Edition":
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
* (1) Paint all subroutine returns (RTS) green (entire line to the right
* of the 4-character address field).
* (2) Paint all subroutine calls (JSR) orange (with an extended swipe for
* out-of-range calls, e.g. JSR $FDED). Paint the target address of
* the JSR orange as well. Write the name of the target in brown felt
* tip after the orange arrow, e.g. "COUT (output char)".
* (3) Paint all absolute jumps pink. Highlight across the entire line
* (everything but the address). Paint the address field of the target
* location pink.
* (4) Show branches in blue, with lines down the left-hand side.
* (5) Paint constants green ("lda #$74") and variables pink ("sta $38"),
* highlighting only the operation (i.e. not the hex values in the
* middle of the listing).
* (6) Paint the housekeeping yellow (inx, dex, dey, txa, cld, sec, tsx).
* Draw yellow lines between pha/pla pairs.
initial import
2007-03-27 17:47:10 +00:00
*/
/*
* Return the #of bytes required by the specified addressing mode, given a
* particular CPU and values for the 'e', 'm', and 'x' flags.
*
* Width is always > 0. This guarantees that we don't loop forever even if
* we hit stuff we don't recognize.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
int ReformatDisasm65xxx::GetOpWidth(OpCode opCode, AddrMode addrMode, CPU cpu,
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 emul, bool shortM, bool shortX)
initial import
2007-03-27 17:47:10 +00:00
{
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 width = 0;
switch (addrMode) {
case kAddrAcc:
case kAddrImplied:
case kAddrStackPull:
case kAddrStackPush:
case kAddrStackRTI:
case kAddrStackRTL:
case kAddrStackRTS:
width = 1;
break;
case kAddrDP:
case kAddrDPIndexX:
case kAddrDPIndexY:
case kAddrDPIndexXInd:
case kAddrDPInd:
case kAddrDPIndLong:
case kAddrDPIndIndexY:
case kAddrDPIndIndexYLong:
case kAddrPCRel:
case kAddrStackRel:
case kAddrStackRelIndexY:
case kAddrStackDPInd:
width = 2;
break;
case kAddrAbs:
case kAddrAbsIndexX:
case kAddrAbsIndexY:
case kAddrAbsIndexXInd:
case kAddrAbsInd:
case kAddrAbsIndLong:
case kAddrBlockMove:
case kAddrPCRelLong:
case kAddrStackAbs:
case kAddrStackPCRel:
width = 3;
break;
case kAddrAbsLong:
case kAddrAbsIndexXLong:
width = 4;
break;
case kAddrStackInt: // BRK/COP
if (emul || fOneByteBrkCop)
width = 1;
else
width = 2;
break;
case kAddrImm:
width = 2;
if (!emul) {
if (opCode == kOpCPX ||
opCode == kOpCPY ||
opCode == kOpLDX ||
opCode == kOpLDY)
{
if (!shortX)
width = 3;
} else
if (opCode == kOpADC ||
opCode == kOpAND ||
opCode == kOpBIT ||
opCode == kOpCMP ||
opCode == kOpEOR ||
opCode == kOpLDA ||
opCode == kOpORA ||
opCode == kOpSBC)
{
if (!shortM)
width = 3;
} else
if (opCode == kOpREP ||
opCode == kOpSEP)
{
/* keep width = 2 */
} else {
assert(false);
}
}
break;
case kAddrWDM: // not really defined
width = 2;
break;
case kAddrModeUnknown: // unknown opcode
width = 1;
break;
default:
assert(false);
width = 1;
break;
}
assert(width > 0);
return width;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Returns "true" if it looks like we're pointing at a ProDOS 8 MLI call.
*
* The caller is expected to check to see if we're in bank 0.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
bool ReformatDisasm65xxx::IsP8Call(const uint8_t* srcBuf, long srcLen)
initial import
2007-03-27 17:47:10 +00:00
{
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 (srcLen >= 6 &&
srcBuf[0] == 0x20 && srcBuf[1] == 0x00 && srcBuf[2] == 0xbf)
{
return true;
}
return false;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Returns "true" if it looks like we're pointing at a IIgs toolbox call.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
bool ReformatDisasm65xxx::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)
initial import
2007-03-27 17:47:10 +00:00
{
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 (srcLen >= 4 && backState >= 3 &&
srcBuf[0] == 0x22 && srcBuf[1] == 0x00 && srcBuf[2] == 0x00 &&
srcBuf[3] == 0xe1 && srcBuf[-3] == 0xa2) // LDX #xxxx
{
return true;
}
return false;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Returns "true" if it looks like we're pointing at an inline GS/OS call.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
bool ReformatDisasm65xxx::IsInlineGSOS(const uint8_t* srcBuf, long srcLen)
initial import
2007-03-27 17:47:10 +00:00
{
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 (srcLen >= 10 &&
srcBuf[0] == 0x22 && srcBuf[1] == 0xa8 && srcBuf[2] == 0x00 &&
srcBuf[3] == 0xe1)
{
return true;
}
return false;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Returns "true" if it looks like we're pointing at a stack GS/OS call.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
bool ReformatDisasm65xxx::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)
initial import
2007-03-27 17:47:10 +00:00
{
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 (srcLen >= 4 && backState >= 3 &&
srcBuf[0] == 0x22 && srcBuf[1] == 0xb0 && srcBuf[2] == 0x00 &&
srcBuf[3] == 0xe1 && srcBuf[-3] == 0xf4) // PEA xxxx
{
return true;
}
return false;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Output one or more lines of text similar to what the monitor would output
* on an 8-bit Apple II.
*
* Returns the number of bytes consumed.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
int ReformatDisasm65xxx::OutputMonitor8(const uint8_t* srcBuf, 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
long backState, uint16_t addr)
initial import
2007-03-27 17:47:10 +00:00
{
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 CPU kCPU = kCPU65C02; // 6502 or 65C02
OpCode opCode;
AddrMode addrMode;
int bytesUsed;
int opAndAddr;
opAndAddr = kOpMap[*srcBuf].opAndAddr[kCPU];
opCode = (OpCode) (opAndAddr & 0xff);
assert(opCode >= kOpCodeUnknown && opCode < kOpCodeMAX);
addrMode = (AddrMode) (opAndAddr >> 8);
assert(addrMode >= kAddrModeUnknown && addrMode < kAddrModeMAX);
bytesUsed = GetOpWidth(opCode, addrMode, kCPU, true, true, true);
if (IsP8Call(srcBuf, srcLen)) {
/* print and skip P8 inline call stuff */
const char* callName;
callName = NiftyList::LookupP8MLI(srcBuf[3]);
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (callName == 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
callName = "(Unknown P8 MLI)";
PrintMonitor8Line(opCode, addrMode, addr, srcBuf, bytesUsed, callName);
BufPrintf("%04X- %02X $%02X",
addr+3, srcBuf[3], srcBuf[3]);
RTFNewPara();
BufPrintf("%04X- %02X %02X $%02X%02X",
addr+4, srcBuf[4], srcBuf[5], srcBuf[5], srcBuf[4]);
RTFNewPara();
bytesUsed += 3;
} else
if (srcLen < bytesUsed) {
assert(bytesUsed <= kMaxByteConsumption);
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 tmpBuf[kMaxByteConsumption];
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
memset(tmpBuf, 0, kMaxByteConsumption);
memcpy(tmpBuf, srcBuf, srcLen);
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
PrintMonitor8Line(opCode, addrMode, addr, tmpBuf, bytesUsed, 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
} else {
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
PrintMonitor8Line(opCode, addrMode, addr, srcBuf, bytesUsed, 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
}
return bytesUsed;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Output one line of 8-bit monitor stuff.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
void ReformatDisasm65xxx::PrintMonitor8Line(OpCode opCode, AddrMode addrMode,
uint16_t addr, const uint8_t* srcBuf, long srcLen, const char* comment)
initial import
2007-03-27 17:47:10 +00:00
{
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
char lineBuf[64]; // actual length is about 30 -- does not hold comment
char* cp;
const char* mnemonic = kOpCodeDetails[opCode].mnemonic;
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 byte0, byte1, byte2;
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
cp = lineBuf;
switch (srcLen) {
case 1:
byte0 = srcBuf[0];
byte1 = byte2 = 0xcc; // make bugs more obvious
cp += sprintf(cp, "%04X- %02X %s", addr, byte0, mnemonic);
break;
case 2:
byte0 = srcBuf[0];
byte1 = srcBuf[1];
byte2 = 0xcc;
cp += sprintf(cp, "%04X- %02X %02X %s", addr, byte0, byte1,
mnemonic);
break;
case 3:
byte0 = srcBuf[0];
byte1 = srcBuf[1];
byte2 = srcBuf[2];
cp += sprintf(cp, "%04X- %02X %02X %02X %s", addr, byte0, byte1,
byte2, mnemonic);
break;
default:
assert(false);
return;
}
switch (addrMode) {
case kAddrImplied:
case kAddrStackPull:
case kAddrStackPush:
case kAddrStackRTI:
case kAddrStackRTS:
break;
case kAddrAcc:
//cp += sprintf(cp, " A");
break;
case kAddrDP:
cp += sprintf(cp, " $%02X", byte1);
break;
case kAddrDPIndexX:
cp += sprintf(cp, " $%02X,X", byte1);
break;
case kAddrDPIndexY:
cp += sprintf(cp, " $%02X,Y", byte1);
break;
case kAddrDPIndexXInd:
cp += sprintf(cp, " ($%02X,X)", byte1);
break;
case kAddrDPInd:
cp += sprintf(cp, " ($%02X)", byte1);
break;
case kAddrDPIndIndexY:
cp += sprintf(cp, " ($%02X),Y", byte1);
break;
case kAddrImm:
cp += sprintf(cp, " #$%02X", byte1);
break;
case kAddrPCRel:
cp += sprintf(cp, " $%04X", RelOffset(addr, byte1));
break;
case kAddrAbs:
cp += sprintf(cp, " $%02X%02X", byte2, byte1);
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (comment == 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
comment = NiftyList::Lookup00Addr(byte1 | byte2 << 8);
break;
case kAddrAbsIndexX:
cp += sprintf(cp, " $%02X%02X,X", byte2, byte1);
break;
case kAddrAbsIndexY:
cp += sprintf(cp, " $%02X%02X,Y", byte2, byte1);
break;
case kAddrAbsIndexXInd:
cp += sprintf(cp, " ($%02X%02X,X)", byte2, byte1);
break;
case kAddrAbsInd:
cp += sprintf(cp, " ($%02X%02X)", byte2, byte1);
break;
case kAddrStackInt: // BRK/COP
if (srcLen != 1)
cp += sprintf(cp, " $%02X", byte1);
break;
case kAddrAbsIndLong: // JML
case kAddrAbsLong:
case kAddrAbsIndexXLong:
case kAddrBlockMove:
case kAddrDPIndLong:
case kAddrDPIndIndexYLong:
case kAddrPCRelLong: // BRL
case kAddrStackAbs: // PEA
case kAddrStackDPInd: // PEI
case kAddrStackPCRel: // PER
case kAddrStackRTL:
case kAddrStackRel:
case kAddrStackRelIndexY:
case kAddrWDM:
// not for 8-bit mode
assert(false);
break;
case kAddrModeUnknown:
assert(srcLen == 1);
break;
default:
assert(false);
break;
}
assert(strlen(cp)+1 < sizeof(lineBuf));
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (comment == 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
BufPrintf("%s", lineBuf);
else
BufPrintf("%s %s", lineBuf, comment);
RTFNewPara();
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Output one or more lines of text similar to what the monitor would output
* on an 8-bit Apple II.
*
* Returns the number of bytes consumed.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
int ReformatDisasm65xxx::OutputMonitor16(const uint8_t* srcBuf, 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
long backState, uint32_t addr, bool shortRegs)
initial import
2007-03-27 17:47:10 +00:00
{
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 CPU kCPU = kCPU65816;
OpCode opCode;
AddrMode addrMode;
int bytesUsed;
int opAndAddr;
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 char* callName;
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
opAndAddr = kOpMap[*srcBuf].opAndAddr[kCPU];
opCode = (OpCode) (opAndAddr & 0xff);
assert(opCode >= kOpCodeUnknown && opCode < kOpCodeMAX);
addrMode = (AddrMode) (opAndAddr >> 8);
assert(addrMode >= kAddrModeUnknown && addrMode < kAddrModeMAX);
bytesUsed = GetOpWidth(opCode, addrMode, kCPU, false, shortRegs, shortRegs);
if (Bank(addr) == 0 && IsP8Call(srcBuf, srcLen)) {
/* print and skip P8 inline call stuff */
callName = NiftyList::LookupP8MLI(srcBuf[3]);
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (callName == 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
callName = "(Unknown P8 MLI)";
PrintMonitor16Line(opCode, addrMode, addr, srcBuf, bytesUsed, callName);
BufPrintf("00/%04X: %02X %02X",
addr+3, srcBuf[3], srcBuf[3]);
RTFNewPara();
BufPrintf("00/%04X: %02X %02X %02X%02X",
addr+4, srcBuf[4], srcBuf[5], srcBuf[5], srcBuf[4]);
RTFNewPara();
bytesUsed += 3;
} else
if (IsToolboxCall(srcBuf, srcLen, backState)) {
callName = NiftyList::LookupToolbox(srcBuf[-2] | srcBuf[-1] << 8);
PrintMonitor16Line(opCode, addrMode, addr, srcBuf, bytesUsed, callName);
} else
if (IsInlineGSOS(srcBuf, srcLen)) {
callName = NiftyList::LookupGSOS(srcBuf[4] | srcBuf[5] << 8);
PrintMonitor16Line(opCode, addrMode, addr, srcBuf, bytesUsed, callName);
BufPrintf("%02X/%04X: %02X %02X %02X%02X",
Bank(addr), Offset(addr+4), srcBuf[4], srcBuf[5],
srcBuf[5], srcBuf[4]);
RTFNewPara();
BufPrintf("%02X/%04X: %02X %02X %02X %02X %02X%02X%02X%02X",
Bank(addr), Offset(addr+6),
srcBuf[6], srcBuf[7], srcBuf[8], srcBuf[9],
srcBuf[9], srcBuf[8], srcBuf[7], srcBuf[6]);
RTFNewPara();
bytesUsed += 6;
} else
if (IsStackGSOS(srcBuf, srcLen, backState)) {
callName = NiftyList::LookupGSOS(srcBuf[-2] | srcBuf[-1] << 8);
PrintMonitor16Line(opCode, addrMode, addr, srcBuf, bytesUsed, callName);
} else
if (srcLen < bytesUsed) {
assert(bytesUsed <= kMaxByteConsumption);
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 tmpBuf[kMaxByteConsumption];
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
memset(tmpBuf, 0, kMaxByteConsumption);
memcpy(tmpBuf, srcBuf, srcLen);
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
PrintMonitor16Line(opCode, addrMode, addr, tmpBuf, bytesUsed, 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
} else {
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
PrintMonitor16Line(opCode, addrMode, addr, srcBuf, bytesUsed, 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
}
return bytesUsed;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Output one line of 16-bit monitor stuff.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
void ReformatDisasm65xxx::PrintMonitor16Line(OpCode opCode, AddrMode addrMode,
uint32_t addr, const uint8_t* srcBuf, long srcLen, const char* comment)
initial import
2007-03-27 17:47:10 +00:00
{
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
char lineBuf[64]; // actual length is about 30 -- does not hold comment
char* cp;
const char* mnemonic = kOpCodeDetails[opCode].mnemonic;
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 byte0, byte1, byte2, byte3;
int16_t offset;
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
cp = lineBuf;
cp += sprintf(cp, "%02X/%04X: ", addr >> 16, addr & 0xffff);
switch (srcLen) {
case 1:
byte0 = srcBuf[0];
byte1 = byte2 = byte3 = 0xcc; // make bugs more obvious
cp += sprintf(cp, "%02X %s", byte0, mnemonic);
break;
case 2:
byte0 = srcBuf[0];
byte1 = srcBuf[1];
byte2 = byte3 = 0xcc;
cp += sprintf(cp, "%02X %02X %s", byte0, byte1, mnemonic);
break;
case 3:
byte0 = srcBuf[0];
byte1 = srcBuf[1];
byte2 = srcBuf[2];
byte3 = 0xcc;
cp += sprintf(cp, "%02X %02X %02X %s", byte0, byte1, byte2,
mnemonic);
break;
case 4:
byte0 = srcBuf[0];
byte1 = srcBuf[1];
byte2 = srcBuf[2];
byte3 = srcBuf[3];
cp += sprintf(cp, "%02X %02X %02X %02X %s", byte0, byte1, byte2,
byte3, mnemonic);
break;
default:
assert(false);
return;
}
switch (addrMode) {
case kAddrImplied:
case kAddrStackPull:
case kAddrStackPush:
case kAddrStackRTI:
case kAddrStackRTS:
case kAddrStackRTL:
break;
case kAddrAcc:
//cp += sprintf(cp, " A");
break;
case kAddrDP:
cp += sprintf(cp, " %02X", byte1);
break;
case kAddrDPIndexX:
cp += sprintf(cp, " %02X,X", byte1);
break;
case kAddrDPIndexY:
cp += sprintf(cp, " %02X,Y", byte1);
break;
case kAddrDPIndexXInd:
cp += sprintf(cp, " (%02X,X)", byte1);
break;
case kAddrDPInd:
cp += sprintf(cp, " (%02X)", byte1);
break;
case kAddrDPIndIndexY:
cp += sprintf(cp, " (%02X),Y", byte1);
break;
case kAddrImm:
if (srcLen == 2)
cp += sprintf(cp, " #%02X", byte1);
else
cp += sprintf(cp, " #%02X%02X", byte2, byte1);
break;
case kAddrPCRel:
offset = (char) byte1;
if (offset < 0)
cp += sprintf(cp, " %04X {-%02X}",
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
RelOffset((uint16_t) addr, byte1), -offset);
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
else
cp += sprintf(cp, " %04X {+%02X}",
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
RelOffset((uint16_t) addr, byte1), offset);
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
break;
case kAddrAbs:
cp += sprintf(cp, " %02X%02X", byte2, byte1);
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (comment == NULL && Bank(addr) == 0)
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
comment = NiftyList::Lookup00Addr(byte1 | byte2 << 8);
break;
case kAddrAbsIndexX:
cp += sprintf(cp, " %02X%02X,X", byte2, byte1);
break;
case kAddrAbsIndexY:
cp += sprintf(cp, " %02X%02X,Y", byte2, byte1);
break;
case kAddrAbsIndexXInd:
cp += sprintf(cp, " (%02X%02X,X)", byte2, byte1);
break;
case kAddrAbsInd:
cp += sprintf(cp, " (%02X%02X)", byte2, byte1);
break;
case kAddrWDM:
case kAddrStackInt: // BRK/COP
if (srcLen != 1)
cp += sprintf(cp, " %02X", byte1);
break;
case kAddrAbsIndLong: // JML
cp += sprintf(cp, " (%02X%02X)", byte2, byte1);
break;
case kAddrAbsLong:
cp += sprintf(cp, " %02X%02X%02X", byte3, byte2, byte1);
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (comment == 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
if (byte3 == 0x00)
comment = NiftyList::Lookup00Addr(byte1 | byte2 << 8);
else if (byte3 == 0x01)
comment = NiftyList::Lookup01Vector(byte1 | byte2 << 8);
else if (byte3 == 0xe0)
comment = NiftyList::LookupE0Vector(byte1 | byte2 << 8);
else if (byte3 == 0xe1)
comment = NiftyList::LookupE1Vector(byte1 | byte2 << 8);
}
break;
case kAddrAbsIndexXLong:
cp += sprintf(cp, " %02X%02X%02X,X", byte3, byte2, byte1);
break;
case kAddrBlockMove:
cp += sprintf(cp, " %02X%02X", byte2, byte1);
break;
case kAddrDPIndLong:
cp += sprintf(cp, " [%02X]", byte1);
break;
case kAddrDPIndIndexYLong:
cp += sprintf(cp, " [%02X],Y", byte1);
break;
case kAddrStackPCRel: // PER
case kAddrPCRelLong: // BRL
offset = (short) (byte1 | byte2 << 8);
if (offset < 0)
cp += sprintf(cp, " %04X {-%02X}",
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
RelLongOffset((uint16_t) addr, offset), -offset);
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
else
cp += sprintf(cp, " %04X {+%02X}",
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
RelLongOffset((uint16_t) addr, offset), offset);
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
break;
case kAddrStackAbs: // PEA
cp += sprintf(cp, " %02X%02X", byte2, byte1);
break;
case kAddrStackDPInd: // PEI
cp += sprintf(cp, " %02X", byte1);
break;
case kAddrStackRel:
cp += sprintf(cp, " %02X,S", byte1);
break;
case kAddrStackRelIndexY:
cp += sprintf(cp, " (%02X,S),Y", byte1);
break;
case kAddrModeUnknown:
assert(srcLen == 1);
break;
default:
assert(false);
break;
}
assert(strlen(cp)+1 < sizeof(lineBuf));
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (comment == 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
BufPrintf("%s", lineBuf);
else {
if (srcLen < 4)
BufPrintf("%s %s", lineBuf, comment);
else
BufPrintf("%s %s", lineBuf, comment);
}
RTFNewPara();
initial import
2007-03-27 17:47:10 +00:00
}
/*
* ===========================================================================
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
* Disassemble 8-bit code
initial import
2007-03-27 17:47:10 +00:00
* ===========================================================================
*/
/*
* For ProDOS 8 and DOS 3.3 stuff, we can't say for sure whether a "BIN"
* file is code or, say, a hi-res graphic. We use "maybe" level to put
* disassembly below other formats.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
void ReformatDisasm8::Examine(ReformatHolder* pHolder)
initial import
2007-03-27 17:47:10 +00:00
{
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
ReformatHolder::ReformatApplies applies = ReformatHolder::kApplicNot;
int fileType = pHolder->GetFileType();
if (fileType >= 0xf1 && fileType <= 0xf8) {
applies = ReformatHolder::kApplicProbablyNot;
} else if (fileType == 0x00 &&
pHolder->GetSourceFormat() != ReformatHolder::kSourceFormatCPM)
{
applies = ReformatHolder::kApplicProbablyNot;
} else if (fileType == kTypeBIN) {
applies = ReformatHolder::kApplicMaybe;
} else if (fileType == kTypeSYS || fileType == kTypeCMD ||
fileType == kType8OB || fileType == kTypeP8C)
{
applies = ReformatHolder::kApplicYes;
}
pHolder->SetApplic(ReformatHolder::kReformatMonitor8, applies,
ReformatHolder::kApplicNot, ReformatHolder::kApplicNot);
// not doing this yet
pHolder->SetApplic(ReformatHolder::kReformatDisasmMerlin8,
ReformatHolder::kApplicNot,
ReformatHolder::kApplicNot, ReformatHolder::kApplicNot);
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Create a monitor listing or disassembly of a file.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
int ReformatDisasm8::Process(const ReformatHolder* pHolder,
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
ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
ReformatOutput* pOutput)
initial import
2007-03-27 17:47:10 +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* srcBuf = pHolder->GetSourceBuf(part);
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 = pHolder->GetSourceLen(part);
long fileType = pHolder->GetFileType();
long backState = 0;
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;
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
fUseRTF = false;
if (!srcLen)
return -1;
RTFBegin();
/* pick a nice 16-bit start address */
if (fileType == kTypeSYS || fileType == kTypeP8C || fileType == kType8OB)
addr = 0x2000;
else if (fileType == kTypeBIN || fileType == kTypeCMD)
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
addr = (uint16_t) pHolder->GetAuxType();
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
else
addr = 0x0000;
while (srcLen > 0) {
int consumed;
consumed = OutputMonitor8(srcBuf, srcLen, backState, addr);
srcBuf += consumed;
srcLen -= consumed;
backState += consumed;
addr += consumed;
}
RTFEnd();
SetResultBuffer(pOutput);
return 0;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* ===========================================================================
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
* Disassemble 16-bit code
initial import
2007-03-27 17:47:10 +00:00
* ===========================================================================
*/
/*
* For 16-bit stuff, the file types are always explicit. However, there are
* instances of 65802/65816 code being written for 8-bit platforms, so we
* want to keep 16-bit disassembly available but prioritized below "raw" for
* BIN files.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
void ReformatDisasm16::Examine(ReformatHolder* pHolder)
initial import
2007-03-27 17:47:10 +00:00
{
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
ReformatHolder::ReformatApplies applies = ReformatHolder::kApplicNot;
long fileType = pHolder->GetFileType();
if (fileType == kTypeBIN || fileType == kTypeSYS || fileType == kTypeCMD ||
fileType == kType8OB || fileType == kTypeP8C)
{
applies = ReformatHolder::kApplicProbablyNot;
} else if (fileType == 0x00 &&
pHolder->GetSourceFormat() != ReformatHolder::kSourceFormatCPM)
{
applies = ReformatHolder::kApplicProbablyNot;
} else {
/*
* Interesting file types (GS/OS ref table F-1):
* $B1 OBJ Object
* $B2 LIB Library
* $B3 S16 GS/OS or ProDOS 16 app
* $B4 RTL Run-time library
* $B5 EXE Shell application
* $B6 PIF Permanent initialization
* $B7 TIF Temporary initialization
* $B8 NDA New desk accessory
* $B9 CDA Classic desk accessory
* $BA TOL Tool set file
* $BB DVR Apple IIgs device driver
* $BC LDF Generic load file (application-specific)
* $BD FST GS/OS file system translator
*
* We also handle non-OMF files:
* $F9 OS GS/OS System file
*/
if (fileType >= kTypeOBJ && fileType <= kTypeFST)
applies = ReformatHolder::kApplicYes;
else if (fileType == kTypeOS)
applies = ReformatHolder::kApplicYes;
}
pHolder->SetApplic(ReformatHolder::kReformatMonitor16Long, applies,
ReformatHolder::kApplicNot, ReformatHolder::kApplicNot);
pHolder->SetApplic(ReformatHolder::kReformatMonitor16Short, applies,
ReformatHolder::kApplicNot, ReformatHolder::kApplicNot);
pHolder->SetApplicPreferred(ReformatHolder::kReformatMonitor16Long);
// not doing this yet
pHolder->SetApplic(ReformatHolder::kReformatDisasmOrcam16,
ReformatHolder::kApplicNot,
ReformatHolder::kApplicNot, ReformatHolder::kApplicNot);
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Disassemble or show monitor listing for 16-bit code.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
int ReformatDisasm16::Process(const ReformatHolder* pHolder,
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
ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
ReformatOutput* pOutput)
initial import
2007-03-27 17:47:10 +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* srcBuf = pHolder->GetSourceBuf(part);
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 = pHolder->GetSourceLen(part);
long fileType = pHolder->GetFileType();
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 = 0;
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 shortRegs;
fUseRTF = false;
if (!srcLen)
return -1;
RTFBegin();
if (id == ReformatHolder::kReformatMonitor16Long)
shortRegs = false;
else
shortRegs = true;
fOneByteBrkCop = pHolder->GetOption(ReformatHolder::kOptOneByteBrkCop) != 0;
if (fileType >= kTypeOBJ && fileType <= kTypeFST) {
if (!OutputOMF(srcBuf, srcLen, fileType, shortRegs)) {
/* must not be OMF; do a generic list */
fExpBuf.Reset();
BufPrintf("[ Valid OMF expected but not found ]\r\n");
RTFNewPara();
OutputSection(srcBuf, srcLen, addr, shortRegs);
}
} else {
/* pick a start address in bank 0 */
if (fileType == kTypeSYS)
addr = 0x2000;
else if (fileType == kTypeBIN || fileType == kTypeCMD)
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
addr = (uint16_t) pHolder->GetAuxType();
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
OutputSection(srcBuf, srcLen, addr, shortRegs);
}
RTFEnd();
SetResultBuffer(pOutput);
return 0;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Output one section of a file.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
void ReformatDisasm16::OutputSection(const uint8_t* srcBuf, 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
uint32_t addr, bool shortRegs)
initial import
2007-03-27 17:47:10 +00:00
{
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 = 0;
initial import
2007-03-27 17:47:10 +00:00
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
while (srcLen > 0) {
int consumed;
initial import
2007-03-27 17:47:10 +00:00
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
consumed = OutputMonitor16(srcBuf, srcLen, backState, addr, shortRegs);
initial import
2007-03-27 17:47:10 +00:00
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
srcBuf += consumed;
srcLen -= consumed;
backState += consumed;
addr += consumed;
}
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Break an OMF file into sections, and output each individually.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
bool ReformatDisasm16::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)
initial import
2007-03-27 17:47:10 +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* origBuf = 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 origLen = srcLen;
OMFSegmentHeader segHdr;
int segmentNumber = 1;
BufPrintf(";\r\n");
Fix some static analyzer quibbles
2014-12-03 01:55:19 +00:00
BufPrintf("; OMF segment summary:\r\n");
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
BufPrintf(";\r\n");
/* pass #1: print a preview */
while (srcLen > 0) {
if (!segHdr.Unpack(srcBuf, srcLen, fileType)) {
if (segmentNumber == 1)
return false;
else {
BufPrintf("; (bad header found, ignoring last %ld bytes)\r\n",
srcLen);
break; // out of while; display what we have
}
}
PrintHeader(&segHdr, segmentNumber, false);
srcBuf += segHdr.GetSegmentLen();
srcLen -= segHdr.GetSegmentLen();
segmentNumber++;
}
BufPrintf(";\r\n");
RTFNewPara();
segmentNumber = 1;
srcBuf = origBuf;
srcLen = origLen;
while (srcLen > 0) {
if (!segHdr.Unpack(srcBuf, srcLen, fileType)) {
BufPrintf("!!!\r\n");
BufPrintf("!!! Found bad OMF header at offset 0x%04x (remaining len=%ld)\r\n",
srcBuf - origBuf, srcLen);
BufPrintf("!!!\r\n");
RTFNewPara();
if (segmentNumber == 1)
return false;
else
return true;
}
PrintHeader(&segHdr, segmentNumber, true);
PrintSegment(&segHdr, srcBuf, srcLen, shortRegs);
RTFNewPara();
srcBuf += segHdr.GetSegmentLen();
srcLen -= segHdr.GetSegmentLen();
segmentNumber++;
}
return true;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Print the interesting bits of the header.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
void ReformatDisasm16::PrintHeader(const OMFSegmentHeader* pSegHdr,
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 segmentNumber, bool longFmt)
initial import
2007-03-27 17:47:10 +00:00
{
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
//pSegHdr->Dump();
const char* versStr;
switch (pSegHdr->GetVersion()) {
case 0: versStr = "1.0"; break;
case 1: versStr = "2.0"; break;
case 2: versStr = "2.1"; break;
default: versStr = "(unknown)"; break;
}
const char* typeStr;
switch (pSegHdr->GetSegmentType()) {
case OMFSegmentHeader::kTypeCode: typeStr = "CODE"; break;
case OMFSegmentHeader::kTypeData: typeStr = "DATA"; break;
case OMFSegmentHeader::kTypeJumpTable: typeStr = "JumpTab"; break;
case OMFSegmentHeader::kTypePathName: typeStr = "PathName"; break;
case OMFSegmentHeader::kTypeLibraryDict: typeStr = "LibDict"; break;
case OMFSegmentHeader::kTypeInit: typeStr = "Init"; break;
case OMFSegmentHeader::kTypeAbsoluteBank: typeStr = "AbsBank"; break;
case OMFSegmentHeader::kTypeDPStack: typeStr = "DP/Stack"; break;
default: typeStr = "(unknown)"; break;
}
if (longFmt) {
BufPrintf(";\r\n");
BufPrintf("; Segment #%d (%d): loadName='%s' segName='%s': \r\n",
segmentNumber, pSegHdr->GetSegNum(),
pSegHdr->GetLoadName(), pSegHdr->GetSegName());
BufPrintf("; type=%s length=%ld OMF v%s\r\n",
typeStr, pSegHdr->GetSegmentLen(), versStr);
BufPrintf("; flags:%s%s%s%s%s%s%s%s\r\n",
pSegHdr->GetSegmentFlag(OMFSegmentHeader::kFlagBankRelative) ? " bankRel" : "",
pSegHdr->GetSegmentFlag(OMFSegmentHeader::kFlagSkip) ? " skip" : "",
pSegHdr->GetSegmentFlag(OMFSegmentHeader::kFlagReload) ? " reload" : "",
pSegHdr->GetSegmentFlag(OMFSegmentHeader::kFlagAbsoluteBank) ? " absBank" : "",
pSegHdr->GetSegmentFlag(OMFSegmentHeader::kFlagNoSpecialMem) ? " noSpecial" : "",
pSegHdr->GetSegmentFlag(OMFSegmentHeader::kFlagPositionIndep) ? " posnIndep" : "",
pSegHdr->GetSegmentFlag(OMFSegmentHeader::kFlagPrivate) ? " private" : "",
pSegHdr->GetSegmentFlag(OMFSegmentHeader::kFlagDynamic) ? " dynamic" : "");
BufPrintf(";");
RTFNewPara();
} else {
BufPrintf("; #%02d: %-8s len=0x%06x loadName='%s' segName='%s'\r\n",
segmentNumber, typeStr, pSegHdr->GetSegmentLen(),
pSegHdr->GetLoadName(), pSegHdr->GetSegName());
}
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Print the contents of the segment.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
void ReformatDisasm16::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
{
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 subLen;
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 offset = 0;
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
assert(pSegHdr != NULL);
assert(srcBuf != 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
assert(srcLen > 0);
srcBuf += pSegHdr->GetDispData();
srcLen -= pSegHdr->GetDispData();
if (srcLen < 0) {
BufPrintf("GLITCH: ran out of data\r\n");
return;
}
if (*srcBuf == 0xf2 && srcLen >= 5) {
/* handle kSegOpLCONST just for fun */
subLen = Get32LE(srcBuf+1);
BufPrintf("OMF: LCONST record (0x%04x bytes follow)\r\n", subLen);
offset = 5;
}
OutputSection(srcBuf + offset,
pSegHdr->GetSegmentLen() - pSegHdr->GetDispData() - offset,
0x000000, shortRegs);
initial import
2007-03-27 17:47:10 +00:00
#if 0
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
OMFSegment seg;
seg.Setup(pSegHdr, srcBuf, 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* 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
do {
ptr = seg.ProcessNextChunk();
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (ptr == 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
BufPrintf("!!! bogus OMF values encountered\r\n");
return;
}
switch (*ptr) {
case OMFSegment::kSegOpEND:
BufPrintf("OMF: END (bytesLeft=%d)\r\n", (ptr+1) - srcBuf);
break;
}
} while (*ptr != OMFSegment::kSegOpEND);
initial import
2007-03-27 17:47:10 +00:00
#endif
}
/*
* ===========================================================================
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
initial import
2007-03-27 17:47:10 +00:00
* ===========================================================================
*/
/*
* Unpack an OMF segment header from the current offset.
*
* Returns "true" on success, "false" on failure.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
bool OMFSegmentHeader::Unpack(const uint8_t* srcBuf, long srcLen, int fileType)
initial import
2007-03-27 17:47:10 +00:00
{
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 (srcLen < kHdrMinSize) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("OMF: Too short to be segment (%ld)", 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
return false;
}
fVersion = *(srcBuf + 0x0f);
if (fVersion > kMaxVersion) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("OMF: Wrong version number to be OMF (%d)", fVersion);
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 false;
}
if (fVersion == 0) {
/* unpack OMF v1.0 */
if (srcLen < kV0HdrMinSize)
return false;
fBlockCnt = Get32LE(srcBuf + 0x00);
fResSpc = Get32LE(srcBuf + 0x04);
fLength = Get32LE(srcBuf + 0x08);
fType = *(srcBuf + 0x0c);
fLabLen = *(srcBuf + 0x0d);
fNumLen = *(srcBuf + 0x0e);
fBankSize = Get32LE(srcBuf + 0x10);
fOrg = Get32LE(srcBuf + 0x14);
fAlign = Get32LE(srcBuf + 0x18);
fNumSex = *(srcBuf + 0x1c);
fByteCnt = fBlockCnt * 512;
fKind = 0;
fLCBank = 0;
fSegNum = 0;
fEntry = 0;
fTempOrg = 0;
fDispName = 0x24;
if (fLabLen == 0)
fDispData = fDispName + *(srcBuf + fDispName);
else
fDispData = fDispName + fLabLen;
} else if (fVersion == 1) {
/* unpack OMF v2.0 */
if (srcLen < kV1HdrMinSize)
return false;
fBlockCnt = Get32LE(srcBuf + 0x00);
fResSpc = Get32LE(srcBuf + 0x04);
fLength = Get32LE(srcBuf + 0x08);
fType = *(srcBuf + 0x0c);
fLabLen = *(srcBuf + 0x0d);
fNumLen = *(srcBuf + 0x0e);
fBankSize = Get32LE(srcBuf + 0x10);
// unused32 at 0x14
fOrg = Get32LE(srcBuf + 0x18);
fAlign = Get32LE(srcBuf + 0x1c);
fNumSex = *(srcBuf + 0x20);
fLCBank = *(srcBuf + 0x21);
fSegNum = Get16LE(srcBuf + 0x22);
fEntry = Get32LE(srcBuf + 0x24);
fDispName = Get16LE(srcBuf + 0x28);
fDispData = Get16LE(srcBuf + 0x2a);
/*
* Orca/APW libs seem to use version 1 with a byte count in the
* first field, but the "LLRE" app has version 1 with a block count.
* The spec is pretty clear, so it looks like somebody's library
* builder screwed up.
*
* Special case type=LIB ($B2).
*/
if (fileType == 0xb2) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("NOTE: switching blockCount=%ld to byte count", fBlockCnt);
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
fByteCnt = fBlockCnt;
fBlockCnt = 0;
} else {
fByteCnt = fBlockCnt * 512;
}
fKind = 0;
fTempOrg = 0;
} else {
/* unpack OMF v2.1 */
if (srcLen < kV2HdrMinSize)
return false;
fByteCnt = Get32LE(srcBuf + 0x00);
fResSpc = Get32LE(srcBuf + 0x04);
fLength = Get32LE(srcBuf + 0x08);
// unused at +0x0c
fLabLen = *(srcBuf + 0x0d);
fNumLen = *(srcBuf + 0x0e);
fBankSize = Get32LE(srcBuf + 0x10);
fKind = Get16LE(srcBuf + 0x14);
// unused at +0x16
fOrg = Get32LE(srcBuf + 0x18);
fAlign = Get32LE(srcBuf + 0x1c);
fNumSex = *(srcBuf + 0x20);
fSegNum = Get16LE(srcBuf + 0x22);
// unused at +0x23
fEntry = Get32LE(srcBuf + 0x24);
fDispName = Get16LE(srcBuf + 0x28);
fDispData = Get16LE(srcBuf + 0x2a);
fTempOrg = Get32LE(srcBuf + 0x2c);
fBlockCnt = 0;
fType = 0;
fLCBank = 0;
}
/* validate fields */
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
if (fByteCnt < kHdrMinSize || fByteCnt > (uint32_t) srcLen) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("OMF: Bad value for byteCnt (%ld, srcLen=%ld min=%d)",
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
fByteCnt, srcLen, kHdrMinSize);
return false;
}
if (fDispName < 0x24 || fDispName > (srcLen - kLoadNameLen)) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("OMF: Bad value for dispName (%d, srcLen=%ld)",
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
fDispName, srcLen);
return false;
}
if (fDispData < 0x24 || fDispData > srcLen) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("OMF: Bad value for dispData (%d, srcLen=%ld)",
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
fDispData, srcLen);
return false;
}
if (fDispData < fDispName + kLoadNameLen) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("OMF: dispData is inside label region (%d / %d)",
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
fDispData, fDispName);
return false;
}
if (fBankSize != kExpectedBankSize && fBankSize != 0) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("OMF: NOTE: bankSize=%ld", fBankSize);
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
/* allowed, just weird */
}
if (fNumLen != kExpectedNumLen || fNumSex != 0) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("OMF: WARNING: numLen=%d numSex=%d", fNumLen, fNumSex);
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
/* big endian odd-sized numbers?? keep going, I guess */
}
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* segName;
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 segLabelLen;
/* copy the label entries over */
segName = srcBuf + fDispName;
if (fVersion > 0) {
memcpy(fLoadName, srcBuf + fDispName, kLoadNameLen);
fLoadName[kLoadNameLen] = '\0';
segName += kLoadNameLen;
}
if (fLabLen == 0) {
/* pascal-style string */
segLabelLen = *segName++;
memcpy(fSegName, segName, segLabelLen);
fSegName[segLabelLen] = '\0';
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" OMF: Pascal segment label '%hs'", fSegName);
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
} else {
/* C-style or non-terminated string */
segLabelLen = fLabLen;
memcpy(fSegName, segName, segLabelLen);
fSegName[segLabelLen] = '\0';
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" OMF: Std segment label '%hs'", fSegName);
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
}
fReady = true;
return true;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Pry the segment type out of the "type" or "kind" field.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
OMFSegmentHeader::SegmentType OMFSegmentHeader::GetSegmentType(void) const
initial import
2007-03-27 17:47:10 +00:00
{
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
assert(fReady);
initial import
2007-03-27 17:47:10 +00:00
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 (fVersion < 2)
return (SegmentType) (fType & 0x1f);
else
return (SegmentType) (fKind & 0x1f);
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Return the value of one of the segment header flags.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
bool OMFSegmentHeader::GetSegmentFlag(SegmentFlag flag) const
initial import
2007-03-27 17:47:10 +00:00
{
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 (fVersion < 2) {
switch (flag) {
case kFlagPositionIndep:
return (fType & 0x20) != 0;
case kFlagPrivate:
return (fType & 0x40) != 0;
case kFlagDynamic:
return (fType & 0x80) != 0;
default:
return false;
}
} else {
switch (flag) {
case kFlagBankRelative:
return (fKind & 0x0100) != 0;
case kFlagSkip:
return (fKind & 0x0200) != 0;
case kFlagReload:
return (fKind & 0x0400) != 0;
case kFlagAbsoluteBank:
return (fKind & 0x0800) != 0;
case kFlagNoSpecialMem:
return (fKind & 0x1000) != 0;
case kFlagPositionIndep:
return (fKind & 0x2000) != 0;
case kFlagPrivate:
return (fKind & 0x4000) != 0;
case kFlagDynamic:
return (fKind & 0x8000) != 0;
default:
assert(false);
return false;
}
}
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Dump the contents of the segment header struct.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
void OMFSegmentHeader::Dump(void) const
initial import
2007-03-27 17:47:10 +00:00
{
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("OMF segment header:");
LOGI(" segNum=%d loadName='%hs' segName='%hs'",
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
fSegNum, fLoadName, fSegName);
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" blockCnt=%ld byteCnt=%ld resSpc=%ld length=%ld",
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
fBlockCnt, fByteCnt, fResSpc, fLength);
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" version=%d type=0x%02x kind=0x%04x",
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
fVersion, fType, fKind);
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" labLen=%d numLen=%d bankSize=%ld lcBank=%d",
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
fLabLen, fNumLen, fBankSize, fLCBank);
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" align=%ld numSex=%d org=%ld tempOrg=%ld",
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
fAlign, fNumSex, fOrg, fTempOrg);
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" entry=%ld dispName=%d dispData=%d",
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
fEntry, fDispName, fDispData);
initial import
2007-03-27 17:47:10 +00:00
}
#if 0
/*
* ===========================================================================
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
* OMFSegment
initial import
2007-03-27 17:47:10 +00:00
* ===========================================================================
*/
/*
* Prepare to roll through a segment.
*/
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
OMFSegment::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)
initial import
2007-03-27 17:47:10 +00:00
{
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
fSegBuf = fCurPtr = srcBuf + pSegHdr->GetDispData();
fSegLen = srcLen - pSegHdr->GetDispData();
initial import
2007-03-27 17:47:10 +00:00
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
fLabLen = pSegHdr->GetLabLen();
fNumLen = pSegHdr->GetNumLen();
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Process the next chunk from the segment.
*
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
* Returns a pointer to the start of the chunk, or "NULL" if we've encountered
initial import
2007-03-27 17:47:10 +00:00
* some bogus condition (e.g. running off the end).
*/
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*
initial import
2007-03-27 17:47:10 +00:00
OMFSegment::ProcessNextChunk(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
const uint8_t* prevPtr = 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
long remLen = fSegLen - (fCurPtr - fSegBuf);
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 subLen;
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 len = 1; // one byte at least (for the opcode)
assert(fLabLen >= 0);
assert(fNumLen > 0);
switch (*fCurPtr) {
case kSegOpEND:
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" OMF END reached, remaining len = %d",
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
fSegLen - (fCurPtr - fSegBuf));
assert(len == 1);
break;
case kSegOpALIGN:
len += fNumLen;
break;
case kSegOpORG:
len += fNumLen;
break;
case kSegOpRELOC:
len += 10;
break;
case kSegOpINTERSEG:
len += 14;
break;
case kSegOpUSING:
case kSegOpSTRONG:
len += LabelLength(fCurPtr + 1);
break;
case kSegOpGLOBAL:
len += LabelLength(fCurPtr + 1) + 4;
break;
case kSegOpGEQU:
len += LabelLength(fCurPtr + 1) + 4;
len += ExpressionLength(fCurPtr + len);
break;
case kSegOpMEM: // not used on IIgs?
len += fNumLen*2;
break;
case kSegOpEXPR:
case kSegOpZEXPR:
case kSegOpBEXPR:
len += 1;
len += ExpressionLength(fCurPtr + len);
break;
case kSegOpRELEXPR:
len += 1 + fNumLen;
len += ExpressionLength(fCurPtr + len);
break;
case kSegOpLOCAL:
len += LabelLength(fCurPtr+1) + 4;
break;
case kSegOpEQU:
len += LabelLength(fCurPtr+1) + 4;
len += ExpressionLength(fCurPtr + len);
break;
case kSegOpDS:
len += fNumLen;
break;
case kSegOpLCONST:
subLen = Get32LE(fCurPtr+1);
len += fNumLen + subLen;
break;
case kSegOpLEXPR:
len += 1;
len += ExpressionLength(fCurPtr + len);
break;
case kSegOpENTRY:
len += 6;
len += LabelLength(fCurPtr + len);
break;
case kSegOpcRELOC:
len += 6;
break;
case kSegOpcINTERSEG:
len += 7;
break;
case kSegOpSUPER:
subLen = Get32LE(fCurPtr+1);
len += 4 + subLen;
break;
case kSegOpGeneral:
case kSegOpExperimental1:
case kSegOpExperimental2:
case kSegOpExperimental3:
case kSegOpExperimental4:
subLen = Get32LE(fCurPtr+1); // assumes fNumLen==4
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" OMF found 'reserved' len=%lu (remLen=%ld)", subLen, remLen);
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
if (subLen > (uint32_t) remLen)
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
return 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
len += subLen + fNumLen;
break;
default:
assert(len == 1);
if (*fCurPtr >= kSegOpCONSTStart && *fCurPtr <= kSegOpCONSTEnd)
len += *fCurPtr;
break;
}
fCurPtr += len;
return prevPtr;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Determine the length of an OMF expression.
*
* Pass a pointer to the start of the expression.
*/
int
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
OMFSegment::ExpressionLength(const uint8_t* ptr)
initial import
2007-03-27 17:47:10 +00:00
{
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
// do this someday
return 1;
initial import
2007-03-27 17:47:10 +00:00
}
#endif
Reference in New Issue Copy Permalink