/*
* Reformat an Integer BASIC program into a text format that mimics the
* output of the "LIST" command.
*/
int ReformatInteger::Process(const ReformatHolder* pHolder,
ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
ReformatOutput* pOutput)
{
const uint8_t* srcPtr = pHolder->GetSourceBuf(part);
long srcLen = pHolder->GetSourceLen(part);
long length = srcLen;
int retval = -1;
//srcPtr += 0xff0; //0x228e;
//srcLen -= 0xff0; //0x228e;
if (srcLen > 65536)
fUseRTF = false;
if (fUseRTF) {
if (id != ReformatHolder::kReformatInteger_Hilite)
fUseRTF = false;
}
RTFBegin(kRTFFlagColorTable);
/*
* Make sure there's enough here to get started. We want to return an
* "okay" result because we want this treated like a reformatted empty
* BASIC program rather than a non-Integer file.
*/
if (length < 2) {
LOGI(" INT truncated?");
BufPrintf("\r\n");
goto done;
}
while (length > 0) {
uint8_t lineLen;
uint16_t lineNum;
bool trailingSpace;
bool newTrailingSpace = false;
/* pull the length byte, which we sanity-check */
lineLen = *srcPtr++;
length--;
if (lineLen == 0) {
LOGI(" INT found zero-length line?");
break;
}
/* line number */
RTFSetColor(kLineNumColor);
lineNum = Read16(&srcPtr, &length);
BufPrintf("%5u ", lineNum);
RTFSetColor(kDefaultColor);
trailingSpace = true;
while (*srcPtr != 0x01 && length > 0) {
if (*srcPtr == 0x28) {
/* start of quoted text */
RTFSetColor(kStringColor);
BufPrintf("\"");
length--;
while (*++srcPtr != 0x29 && length > 0) {
/* escape chars, but let Ctrl-D and Ctrl-G through */
if (fUseRTF && *srcPtr != 0x84 && *srcPtr != 0x87)
RTFPrintChar(*srcPtr & 0x7f);
else
BufPrintf("%c", *srcPtr & 0x7f);
length--;
}
if (*srcPtr != 0x29) {
LOGI(" INT ended while in a string constant");
break;
}
BufPrintf("\"");
RTFSetColor(kDefaultColor);
srcPtr++;
length--;
} else if (*srcPtr == 0x5d) {
/* start of REM statement, run to EOL */
//RTFBoldOn();
RTFSetColor(kKeywordColor);
BufPrintf("%sREM ", trailingSpace ? "" : " ");
//RTFBoldOff();
RTFSetColor(kCommentColor);
length--;
while (*++srcPtr != 0x01) {
if (fUseRTF)
RTFPrintChar(*srcPtr & 0x7f);
else
BufPrintf("%c", *srcPtr & 0x7f);
length--;
}
RTFSetColor(kDefaultColor);
if (*srcPtr != 0x01) {
LOGI(" INT ended while in a REM statement");
break;
}
} else if (*srcPtr >= 0xb0 && *srcPtr <= 0xb9) {
/* start of integer constant */
srcPtr++;
length--;
if (length < 2) {
LOGI(" INT ended while in an integer constant");
break;
}
int val;
val = Read16(&srcPtr, &length);
BufPrintf("%d", val);
} else if (*srcPtr >= 0xc1 && *srcPtr <= 0xda) {
/* start of variable name */
while ((*srcPtr >= 0xc1 && *srcPtr <= 0xda) ||
(*srcPtr >= 0xb0 && *srcPtr <= 0xb9))
{
/* note no RTF-escaped chars in this range */
BufPrintf("%c", *srcPtr & 0x7f);
srcPtr++;
length--;
}
} else if (*srcPtr < 0x80) {
/* found a token; try to get the whitespace right */
/* (maybe should've left whitespace on the ends of tokens
that are always followed by whitespace...?) */
const char* token;
token = gIntegerTokens[*srcPtr];
//RTFBoldOn();
if (*srcPtr == 0x03) // colon
RTFSetColor(kColonColor);
else
RTFSetColor(kKeywordColor);
if (token[0] >= 0x21 && token[0] <= 0x3f || *srcPtr < 0x12) {
/* does not need leading space */
BufPrintf("%s", token);
} else {
/* needs leading space; combine with prev if it exists */
if (trailingSpace)
BufPrintf("%s", token);
else
BufPrintf(" %s", token);
}
if (token[strlen(token)-1] == ' ')
newTrailingSpace = true;
//RTFBoldOff();
RTFSetColor(kDefaultColor);
srcPtr++;
length--;
} else {
/* should not happen */
LOGI(" INT unexpected value 0x%02x at byte %d",
*srcPtr, srcPtr - pHolder->GetSourceBuf(part));
/* skip past it and keep trying */
srcPtr++;
length--;
}
trailingSpace = newTrailingSpace;
newTrailingSpace = false;
} /*while line*/
/* skip past EOL token */
if (*srcPtr != 0x01 && length > 0) {
LOGI("bailing"); // must've failed during processing
goto bail;
}
srcPtr++;
length--;
RTFNewPara();
}
done:
RTFEnd();
SetResultBuffer(pOutput);
retval = 0;
bail:
return retval;
}
/*
* Reformat an Apple /// Business BASIC program into a text format that
* mimics the output of the "LIST" command.
*/
int ReformatBusiness::Process(const ReformatHolder* pHolder,
ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
ReformatOutput* pOutput)
{
const uint8_t* srcPtr = pHolder->GetSourceBuf(part);
long srcLen = pHolder->GetSourceLen(part);
long length = srcLen;
int retval = -1;
int nestLevels = 0;
if (srcLen > 65536)
fUseRTF = false;
if (fUseRTF) {
if (id != ReformatHolder::kReformatBusiness_Hilite)
fUseRTF = false;
}
RTFBegin(kRTFFlagColorTable);
/*
* Make sure there's enough here to get started. We want to return an
* "okay" result because we want this treated like a reformatted empty
* BASIC program rather than a non-BASIC file.
*/
if (length < 2) {
LOGI(" BA3 truncated?");
//fExpBuf.CreateWorkBuf();
BufPrintf("\r\n");
goto done;
}
uint16_t fileLength;
fileLength = Read16(&srcPtr, &length);
LOGI(" BA3 internal file length is: %d", fileLength);
while (length > 0) {
uint16_t increment;
uint16_t extendedToken;
uint16_t lineNum;
bool inQuote = false;
bool inRem = false;
bool firstData = true;
bool literalYet = false;
increment = Read8(&srcPtr, &length);
LOGI(" BA3 increment to next line is: %d", increment);
if (increment == 0) {
/* ProDOS sticks an extra byte on the end? */
if (length > 1) {
LOGI(" BA3 ended early; len is %d", length);
}
break;
}
/* print line number */
RTFSetColor(kLineNumColor);
lineNum = Read16(&srcPtr, &length);
LOGI(" BA3 line number: %d", lineNum);
BufPrintf(" %u ", lineNum);
RTFSetColor(kDefaultColor);
if (nestLevels > 0) {
for (int i =0; i < nestLevels; i++)
BufPrintf(" ");
}
/* print a line */
while (*srcPtr != 0 && length > 0) {
if (*srcPtr & 0x80) {
/* token */
//RTFBoldOn();
literalYet = false;
RTFSetColor(kKeywordColor);
if (*srcPtr == 0x81) {
// Token is FOR - indent
nestLevels ++;
}
else if (*srcPtr == 0x82) {
// Token is NEXT - outdent
nestLevels --;
}
if (!firstData)
BufPrintf(" ");
if (((*srcPtr) & 0x7f) == 0x7f)
{
extendedToken = Read8(&srcPtr, &length);
BufPrintf("%s", &gExtendedBusinessTokens[((*srcPtr) & 0x7f) * 10]);
// We need to have some tokens NOT add a space after them.
if ((*srcPtr == 0x80) || // TAB(
(*srcPtr == 0x82) || // SPC(
(*srcPtr == 0x9d) || // SGN(
(*srcPtr == 0x9e) || // INT(
(*srcPtr == 0x9f) || // ABS(
(*srcPtr == 0xa1) || // TYP(
(*srcPtr == 0xa2) || // REC(
(*srcPtr == 0xad) || // PDL(
(*srcPtr == 0xae) || // BUTTON(
(*srcPtr == 0xaf) || // SQR(
(*srcPtr == 0xb0) || // RND(
(*srcPtr == 0xb1) || // LOG(
(*srcPtr == 0xb2) || // EXP(
(*srcPtr == 0xb3) || // COS(
(*srcPtr == 0xb4) || // SIN(
(*srcPtr == 0xb5) || // TAN(
(*srcPtr == 0xb6) || // ATN(
(*srcPtr == 0xc3) || // STR$(
(*srcPtr == 0xc4) || // HEX$(
(*srcPtr == 0xc5) || // CHR$(
(*srcPtr == 0xc6) || // LEN(
(*srcPtr == 0xc7) || // VAL(
(*srcPtr == 0xc8) || // ASC(
(*srcPtr == 0xc9) || // TEN(
(*srcPtr == 0xcc) || // CONV(
(*srcPtr == 0xcd) || // CONV&(
(*srcPtr == 0xce) || // CONV$(
(*srcPtr == 0xcf) || // CONV%(
(*srcPtr == 0xd0) || // LEFT$(
(*srcPtr == 0xd1) || // RIGHT$(
(*srcPtr == 0xd2) || // MID$(
(*srcPtr == 0xd3)) // INSTR$(
firstData = true;
else
firstData = false;
}
else {
BufPrintf("%s", &gBusinessTokens[((*srcPtr) & 0x7f) * 10]);
// We need to have some tokens NOT add a space after them.
if ((*srcPtr == 0x99) || // HPOS
(*srcPtr == 0x9a) || // VPOS
(*srcPtr == 0x9f) || // TIME$
(*srcPtr == 0xa0) || // DATE$
(*srcPtr == 0xa1) || // PREFIX$
(*srcPtr == 0xa2) || // EXFN.
(*srcPtr == 0xa3) || // EXFN%.
(*srcPtr == 0xb0) || // SUB$(.
(*srcPtr == 0xb6) || // SCALE(
(*srcPtr == 0xc0) || // REM
(*srcPtr == 0xe3)) // SPC(
firstData = true;
else
firstData = false;
}
//RTFBoldOff();
RTFSetColor(kDefaultColor);
if (*srcPtr == 0xc0) {
// REM -- do rest of line in green
RTFSetColor(kCommentColor);
inRem = true;
}
} else {
/* simple chracter */
if (*srcPtr == ':') // Reset line if we have a colon
firstData = true;
if (!firstData) {
if (!literalYet) {
BufPrintf(" ");
literalYet = true;
}
}
if (fUseRTF) {
if (*srcPtr == '"' && !inRem) {
if (!inQuote) {
RTFSetColor(kStringColor);
RTFPrintChar(*srcPtr);
} else {
RTFPrintChar(*srcPtr);
RTFSetColor(kDefaultColor);
}
inQuote = !inQuote;
} else if (*srcPtr == ':' && !inRem && !inQuote) {
RTFSetColor(kColonColor);
RTFPrintChar(*srcPtr);
RTFSetColor(kDefaultColor);
} else {
RTFPrintChar(*srcPtr);
}
} else {
BufPrintf("%c", *srcPtr);
}
}
srcPtr++;
length--;
}
if (inQuote || inRem)
RTFSetColor(kDefaultColor);
inQuote = inRem = false;
srcPtr++;
length--;
if (!length) {
LOGI(" BA3 truncated in mid-line");
break;
}
RTFNewPara();
}
done:
RTFEnd();
SetResultBuffer(pOutput);
retval = 0;
//bail:
return retval;
}
/*
* Reformat an Applesoft BASIC program into a text format that mimics the
* output of the "LIST" command (with POKE 33,73 to suppress CRs).
*/
int ReformatApplesoft::Process(const ReformatHolder* pHolder,
ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
ReformatOutput* pOutput)
{
const uint8_t* srcPtr = pHolder->GetSourceBuf(part);
long srcLen = pHolder->GetSourceLen(part);
long length = srcLen;
int retval = -1;
if (srcLen > 65536)
fUseRTF = false;
if (fUseRTF) {
if (id != ReformatHolder::kReformatApplesoft_Hilite)
fUseRTF = false;
}
RTFBegin(kRTFFlagColorTable);
/*
* Make sure there's enough here to get started. We want to return an
* "okay" result because we want this treated like a reformatted empty
* BASIC program rather than a non-Applesoft file.
*/
if (length < 2) {
LOGI(" BAS truncated?");
//fExpBuf.CreateWorkBuf();
BufPrintf("\r\n");
goto done;
}
while (length > 0) {
uint16_t nextAddr;
uint16_t lineNum;
bool inQuote = false;
bool inRem = false;
nextAddr = Read16(&srcPtr, &length);
if (nextAddr == 0) {
/* ProDOS sticks an extra byte on the end? */
if (length > 1) {
LOGI(" BAS ended early; len is %d", length);
}
break;
}
/* print line number */
RTFSetColor(kLineNumColor);
lineNum = Read16(&srcPtr, &length);
BufPrintf(" %u ", lineNum);
RTFSetColor(kDefaultColor);
assert(kTokenLen == 8); // we do "<< 3" below, so this must hold
/* print a line */
while (*srcPtr != 0 && length > 0) {
if (*srcPtr & 0x80) {
/* token */
//RTFBoldOn();
RTFSetColor(kKeywordColor);
BufPrintf(" %s ", &gApplesoftTokens[((*srcPtr) & 0x7f) << 3]);
//RTFBoldOff();
RTFSetColor(kDefaultColor);
if (*srcPtr == 0xb2) {
// REM -- do rest of line in green
RTFSetColor(kCommentColor);
inRem = true;
}
} else {
/* simple character */
if (fUseRTF) {
if (*srcPtr == '"' && !inRem) {
if (!inQuote) {
RTFSetColor(kStringColor);
RTFPrintChar(*srcPtr);
} else {
RTFPrintChar(*srcPtr);
RTFSetColor(kDefaultColor);
}
inQuote = !inQuote;
} else if (*srcPtr == ':' && !inRem && !inQuote) {
RTFSetColor(kColonColor);
RTFPrintChar(*srcPtr);
RTFSetColor(kDefaultColor);
} else if (inRem && *srcPtr == '\r') {
RTFNewPara();
} else {
RTFPrintChar(*srcPtr);
}
} else {
if (inRem && *srcPtr == '\r') {
BufPrintf("\r\n");
} else {
BufPrintf("%c", *srcPtr);
}
}
}
srcPtr++;
length--;
}
if (inQuote || inRem)
RTFSetColor(kDefaultColor);
inQuote = inRem = false;
srcPtr++;
length--;
if (!length) {
LOGI(" BAS truncated in mid-line");
break;
}
RTFNewPara();
}
done:
RTFEnd();
SetResultBuffer(pOutput);
retval = 0;
//bail:
return retval;
}
/*
* Convert Teach Text into formatted text.
*
* The text is in the data fork and the formatting is in the resource fork.
*/
int
ReformatTeach::Process(const ReformatHolder* pHolder,
ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
ReformatOutput* pOutput)
{
const uint8_t* dataBuf;
const uint8_t* rsrcBuf;
long dataLen, rsrcLen;
const uint8_t* styleBlock;
long styleLen;
if (part != ReformatHolder::kPartData)
return -1;
dataBuf = pHolder->GetSourceBuf(ReformatHolder::kPartData);
dataLen = pHolder->GetSourceLen(ReformatHolder::kPartData);
rsrcBuf = pHolder->GetSourceBuf(ReformatHolder::kPartRsrc);
rsrcLen = pHolder->GetSourceLen(ReformatHolder::kPartRsrc);
if (dataBuf == NULL || rsrcBuf == NULL || dataLen <= 0 || rsrcLen <= 0) {
LOGI("Teach reformatter missing one fork of the file");
return -1;
}
CheckGSCharConv();
/* find the rStyleBlock */
if (!ReformatResourceFork::GetResource(rsrcBuf, rsrcLen, 0x8012, 0x0001,
&styleBlock, &styleLen))
{
LOGI("Resource fork of Teach Text file not found");
return -1;
}
RStyleBlock rStyleBlock;
if (!rStyleBlock.Create(styleBlock, styleLen)) {
LOGI("Unable to unpack rStyleBlock");
return -1;
}
fUseRTF = true;
RTFBegin();
/*
* Configure ruler options. The format allows us to have more than one
* ruler, but doesn't provide a way to select between them, so we have
* to assume that the first ruler is global.
*
* In practice, the Teach application doesn't provide a way to set
* margins or tab stops, so there's really not much to do. It seems to
* create tab stops with 64-pixel widths, which translates to 10 tab
* stops per page. WordPad seems to default to 12, so I figure there's
* not much point in futzing with it since the fonts are all different
* anyway.
*/
RStyleBlock::TERuler* pRuler = rStyleBlock.GetRuler(0);
assert(pRuler != NULL);
if (pRuler->GetJustification() != RStyleBlock::TERuler::kJustLeft) {
LOGI("WARNING: not using left justified Teach text");
/* ignore it */
}
for (int style = 0; style < rStyleBlock.GetNumStyleItems(); style++) {
RStyleBlock::StyleItem* pStyleItem;
RStyleBlock::TEStyle* pStyle;
int numBytes;
/* set up the style */
pStyleItem = rStyleBlock.GetStyleItem(style);
assert(pStyleItem != NULL);
if (pStyleItem->GetLength() == RStyleBlock::StyleItem::kUnusedItem)
continue;
numBytes = pStyleItem->GetLength();
pStyle = rStyleBlock.GetStyle(pStyleItem->GetStyleIndex());
/*
* Set the font first; that defines the point size multiplier. Set
* the size second, because the point size determines whether we
* show underline. Set the style last.
*/
RTFSetGSFont(pStyle->GetFontFamily());
RTFSetGSFontSize(pStyle->GetFontSize());
RTFSetGSFontStyle(pStyle->GetTextStyle());
/*
* The Teach app doesn't let you set text colors, but it appears
* there's a way to do it, since the SpyHunterGS Read.Me file has
* a bit of red in it.
*/
if (pStyle->GetTextColor() != 0) {
// do something with color, someday
}
/* output the characters */
uint8_t uch;
while (numBytes--) {
if (!dataLen) {
LOGI("WARNING: Teach underrun (%ld wanted)", numBytes);
break;
}
uch = *dataBuf;
if (uch == '\r') {
RTFNewPara();
} else if (uch == '\t') {
RTFTab();
} else {
RTFPrintExtChar(ConvertGSChar(uch));
}
dataBuf++;
dataLen--;
}
}
if (dataLen) {
LOGI("WARNING: Teach overrun (%ld remain)", dataLen);
/* no big deal */
}
RTFEnd();
SetResultBuffer(pOutput, true);
return 0;
}
/*
* Print one paragraph.
*
* Stop when we hit '\r'. We watch "maxLen" just to be safe.
*
* Returns the #of bytes consumed.
*/
int ReformatAWGS_WP::PrintParagraph(const uint8_t* ptr, long maxLen)
{
const uint8_t* startPtr = ptr;
uint16_t firstFont;
uint8_t firstStyle, firstSize, firstColor;
uint8_t uch;
if (maxLen < 7) {
LOGI("AWGS_WP GLITCH: not enough storage for para header (%d)",
maxLen);
return 1; // don't return zero or we might loop forever
}
/* pull out the paragraph header */
firstFont = Get16LE(ptr);
firstStyle = *(ptr + 2);
firstSize = *(ptr + 3);
firstColor = *(ptr + 4);
ptr += 7;
maxLen -= 7;
/*
* Set the font first; that defines the point size multiplier. Set
* the size second, because the point size determines whether we
* show underline. Set the style last.
*/
//LOGI("+++ Para start: font=0x%04x size=%d style=0x%02x",
// firstFont, firstSize, firstStyle);
RTFSetGSFont(firstFont);
RTFSetGSFontSize(firstSize);
RTFSetGSFontStyle(firstStyle);
while (maxLen > 0) {
uch = *ptr++;
maxLen--;
switch (uch) {
case 0x01: // font change - two bytes follow
if (maxLen >= 2) {
RTFSetGSFont(Get16LE(ptr));
ptr += 2;
maxLen -= 2;
}
break;
case 0x02: // text style change
if (maxLen >= 1) {
RTFSetGSFontStyle(*ptr++);
maxLen--;
}
break;
case 0x03: // text size change
if (maxLen >= 1) {
RTFSetGSFontSize(*ptr++);
maxLen--;
}
break;
case 0x04: // color change (0-15)
if (maxLen >= 1) {
ptr++;
maxLen--;
}
break;
case 0x05: // page token (replace with page #)
case 0x06: // date token (replace with date)
case 0x07: // time token (replace with time)
RTFSetColor(kColorMediumBlue);
if (uch == 0x05)
BufPrintf("<page>");
else if (uch == 0x06)
BufPrintf("<date>");
else
BufPrintf("<time>");
RTFSetColor(kColorNone);
break;
case '\r':
RTFNewPara();
return ptr - startPtr;
case '\t':
RTFTab();
break;
default:
RTFPrintUTF16Char(Charset::ConvertMacRomanToUTF16(uch));
break;
}
}
LOGI("AWGS_WP: WARNING: ran out of data before hitting '\r'");
return ptr - startPtr;
}
/*
* Convert AWGS into formatted text.
*/
int ReformatAWGS_WP::Process(const ReformatHolder* pHolder,
ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
ReformatOutput* pOutput)
{
const uint8_t* srcBuf = pHolder->GetSourceBuf(part);
long srcLen = pHolder->GetSourceLen(part);
fUseRTF = true;
Chunk doc, header, footer;
uint16_t val;
Charset::CheckGSCharConv();
/* must at least have the doc header and globals */
if (srcLen < kMinExpectedLen) {
LOGI("Too short to be AWGS");
return -1;
}
RTFBegin(kRTFFlagColorTable);
/*
* Pull interesting values out of the document header.
*/
val = Get16LE(srcBuf + 0);
if (val != kExpectedVersion1 && val != kExpectedVersion2) {
LOGI("AWGS_WP: unexpected version number (got 0x%04x, wanted 0x%04x)",
val, kExpectedVersion1);
DebugBreak();
}
val = Get16LE(srcBuf + 2);
if (val != kDocHeaderLen) {
LOGI("Unexpected doc header len (got 0x%04x, wanted 0x%04x)",
val, kDocHeaderLen);
return -1;
}
/* the color table is 32 bytes at +56, should we be interested */
srcBuf += kDocHeaderLen;
srcLen -= kDocHeaderLen;
/*
* Pull interesting values out of the WP global variables section.
*/
val = Get16LE(srcBuf + 0);
if (val > kExpectedIntVersion) {
LOGI("Unexpected internal version number (got %d, expected %d)",
val, kExpectedIntVersion);
return -1;
}
/* date/time are pascal strings */
LOGI("File saved at '%.26hs' '%.10s'", srcBuf + 6, srcBuf + 32);
srcBuf += kWPGlobalsLen;
srcLen -= kWPGlobalsLen;
/*
* Now come the three chunks, in order: main document, header, footer.
*/
LOGI("AWGS_WP: scanning doc");
if (!ReadChunk(&srcBuf, &srcLen, &doc))
return -1;
LOGI("AWGS_WP: scanning header");
if (!ReadChunk(&srcBuf, &srcLen, &header))
return -1;
LOGI("AWGS_WP: scanning footer");
if (!ReadChunk(&srcBuf, &srcLen, &footer))
return -1;
if (srcLen != 0) {
LOGI("AWGS NOTE: %ld bytes left in file", srcLen);
}
/*
* Dump the chunks, starting with header and footer.
*/
RTFSetColor(kColorMediumBlue);
RTFSetFont(kFontCourierNew);
RTFSetFontSize(10);
BufPrintf("<header>");
RTFSetColor(kColorNone);
RTFNewPara();
PrintChunk(&header);
RTFSetColor(kColorMediumBlue);
RTFSetFont(kFontCourierNew);
RTFSetFontSize(10);
BufPrintf("</header>");
RTFSetColor(kColorNone);
RTFNewPara();
RTFSetColor(kColorMediumBlue);
RTFSetFont(kFontCourierNew);
RTFSetFontSize(10);
BufPrintf("<footer>");
RTFSetColor(kColorNone);
RTFNewPara();
PrintChunk(&footer);
RTFSetColor(kColorMediumBlue);
RTFSetFont(kFontCourierNew);
RTFSetFontSize(10);
BufPrintf("</footer>");
RTFSetColor(kColorNone);
RTFNewPara();
LOGI("AWGS_WP: rendering document");
PrintChunk(&doc);
RTFEnd();
SetResultBuffer(pOutput, true);
return 0;
}
/*
* Output a single chunk. We do this by walking down the saveArray.
*/
void ReformatAWGS_WP::PrintChunk(const Chunk* pChunk)
{
const int kDefaultStatusBits = kAWGSJustifyLeft | kAWGSSingleSpace;
SaveArrayEntry sae;
const uint8_t* saveArray;
int saCount;
const uint8_t* blockPtr;
long blockLen;
const uint8_t* pRuler;
uint16_t rulerStatusBits;
saveArray = pChunk->saveArray;
saCount = pChunk->saveArrayCount;
for ( ; saCount > 0; saCount--, saveArray += kSaveArrayEntryLen) {
UnpackSaveArrayEntry(saveArray, &sae);
/*
* Page-break paragraphs have no real data and an invalid value
* in the "rulerNum" field. So we just throw out a page break
* here and call it a day.
*/
if (sae.attributes == 0x0001) {
/* this is a page-break paragraph */
RTFSetColor(kColorMediumBlue);
RTFSetFont(kFontCourierNew);
RTFSetFontSize(10);
BufPrintf("<page-break>");
RTFSetColor(kColorNone);
RTFNewPara();
RTFPageBreak(); // only supported by Word
continue;
}
if (sae.rulerNum < pChunk->numRulers) {
pRuler = pChunk->rulers + sae.rulerNum * kRulerEntryLen;
rulerStatusBits = Get16LE(pRuler + 2);
} else {
LOGI("AWGS_WP GLITCH: invalid ruler index %d", sae.rulerNum);
rulerStatusBits = kDefaultStatusBits;
}
if (rulerStatusBits & kAWGSJustifyFull)
RTFParaJustify();
else if (rulerStatusBits & kAWGSJustifyRight)
RTFParaRight();
else if (rulerStatusBits & kAWGSJustifyCenter)
RTFParaCenter();
else if (rulerStatusBits & kAWGSJustifyLeft)
RTFParaLeft();
RTFSetPara();
/*
* Find the text block that holds this paragraph. We could speed
* this up by creating an array of entries rather than walking the
* list every time. However, the block count tends to be fairly
* small (e.g. 7 for a 16K doc).
*/
blockPtr = FindTextBlock(pChunk, sae.textBlock);
if (blockPtr == NULL) {
LOGI("AWGS_WP bad textBlock %d", sae.textBlock);
return;
}
blockLen = (long) Get32LE(blockPtr);
if (blockLen <= 0 || blockLen > 65535) {
LOGI("AWGS_WP invalid block len %d", blockLen);
return;
}
blockPtr += 4;
if (sae.offset >= blockLen) {
LOGI("AWGS_WP bad offset: %d, blockLen=%ld",
sae.offset, blockLen);
return;
}
PrintParagraph(blockPtr + sae.offset, blockLen - sae.offset);
}
}
