/*
 * CiderPress
 * Copyright (C) 2007 by faddenSoft, LLC.  All Rights Reserved.
 * See the file LICENSE for distribution terms.
 */
/*
 * Convert AppleWorks 3.0 documents.
 */
#include "StdAfx.h"
#include "AppleWorks.h"

/*
 * ===========================================================================
 *      AppleWorks WP
 * ===========================================================================
 */

/*
 * AppleWorks word processor file format, from FTN.1A.xxxx.
 *
 * The overall file format is:
 *
 *  file header
 *  array of line records
 *  $ff $ff
 *  optional tags
 *
 * AppleWorks 5.0 introduced inverse and MouseText characters.
 * These just use previously-unused byte ranges.  The full set
 * of values is thus:
 *  00-1f special
 *  20-7f plain ASCII
 *  80-9f inverse upper (map to 40-5f)
 *  a0-bf inverse symbols/numbers (map to 20-3f)
 *  c0-df MouseText
 *  e0-ff inverse lower (map to 60-7f)
 *
 * We can output MouseText as Unicode symbols.  Inverse text can use the Rich
 * Text "highlight" feature; the "background color" feature doesn't seem to
 * have any effect.
 */

/*
 * Decide whether or not we want to handle this file.
 */
void ReformatAWP::Examine(ReformatHolder* pHolder)
{
    ReformatHolder::ReformatApplies applies = ReformatHolder::kApplicNot;

    if (pHolder->GetFileType() == kTypeAWP)
        applies = ReformatHolder::kApplicProbably;

    pHolder->SetApplic(ReformatHolder::kReformatAWP, applies,
        ReformatHolder::kApplicNot, ReformatHolder::kApplicNot);
}

/*
 * Reformat an AppleWorks WP document.
 */
int ReformatAWP::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;

    bool skipRecord;
    uint8_t lineRecCode, lineRecData;

    fMouseTextToASCII = pHolder->GetOption(ReformatHolder::kOptMouseTextToASCII) != 0;

    if (srcLen > 65536)
        fUseRTF = false;

    //fUseRTF = false;
    //fShowEmbeds = false;

    /* expect header plus EOF bytes at least */
    if (srcLen <= kFileHeaderSize) {
        LOGI("  AWP truncated?");
        goto bail;
    }

    RTFBegin(kRTFFlagColorTable);

    /*
     * Grab the file header.
     */
    assert(sizeof(fFileHeader) == kFileHeaderSize);

    memcpy(&fFileHeader, srcPtr, sizeof(fFileHeader));
    srcPtr += sizeof(fFileHeader);
    length -= sizeof(fFileHeader);

    /* do some quick sanity checks */
    if (fFileHeader.seventyNine != kSeventyNine) {
        LOGI("ERROR: expected %d in signature byte, found %d",
            kSeventyNine, fFileHeader.seventyNine);
        goto bail;
    }
    if (fFileHeader.sfMinVers && fFileHeader.sfMinVers != kSFMinVers30) {
        LOGI("WARNING: unexpected value %d for sfMinVers",
            fFileHeader.sfMinVers);
        /* keep going */
    }

    InitDocState();

    /* if first line record is invalid, skip it */
    skipRecord = false;
    if (fFileHeader.sfMinVers == kSFMinVers30)
        skipRecord = true;

    /* set margins to 1.0 inches at 10cpi */
    RTFLeftMargin(10);
    RTFRightMargin(10);

    /*
     * Read the line records.
     */
    while (1) {
        if (length < 0) {
            LOGI(" AWP truncated file");
            goto bail;
        }
        lineRecData = Read8(&srcPtr, &length);
        if (length < 0) {
            LOGI(" AWP truncated file");
            goto bail;
        }
        lineRecCode = Read8(&srcPtr, &length);

        if (length < 0) {
            LOGI(" AWP truncated file");
            goto bail;
        }

        if (skipRecord) {
            skipRecord = false;
            continue;
        }

        /* end of data reached? */
        if (lineRecData == kEOFMarker && lineRecCode == kEOFMarker)
            break;

        if (ProcessLineRecord(lineRecData, lineRecCode, &srcPtr, &length) != 0)
        {
            LOGI("ProcessLineRecord failed, bailing");
            goto bail;
        }
    }


    /* 
     * Read the optional tags.
     */
    /* (nah) */

    RTFEnd();

    SetResultBuffer(pOutput);
    retval = 0;

bail:
    return retval;
}

/*
 * Initialize the DocState structure.
 */
void ReformatAWP::InitDocState(void)
{
    memset(&fDocState, 0, sizeof(fDocState));
    fDocState.line = 1;
}

/*
 * Process a line record.
 */
int ReformatAWP::ProcessLineRecord(uint8_t lineRecData, uint8_t lineRecCode,
    const uint8_t** pSrcPtr, long* pLength)
{
    int err = 0;

    //LOGI(" AWP line rec <0x%02x><0x%02x>", lineRecCode, lineRecData);

    if (lineRecCode == kLineRecordCarriageReturn) {
        /* ignore the horizontal offset for now */
        RTFNewPara();
    } else if (lineRecCode == kLineRecordText) {
        if (pLength > 0)
            err = HandleTextRecord(lineRecData, pSrcPtr, pLength);
        else 
            err = -1;
    } else if (lineRecCode >= kLineRecordCommandMin &&
               lineRecCode <= kLineRecordCommandMax)
    {
        switch (lineRecCode) {
        case kLineRecordCommandCenter:
            RTFParaCenter();
            break;
        case kLineRecordCommandRightJustify:
            RTFParaRight();
            break;
        case kLineRecordCommandUnjustify:
            RTFParaLeft();
            break;
        case kLineRecordCommandJustify:
            RTFParaJustify();
            break;
        case kLineRecordCommandLeftMargin:
            RTFLeftMargin(lineRecData);
            break;
        case kLineRecordCommandRightMargin:
            RTFRightMargin(lineRecData);
            break;

        /* we handle these by showing them in the text */
        case kLineRecordCommandPageNumber:
            if (fShowEmbeds) {
                RTFSetColor(kColorBlue);
                BufPrintf("<set-page-number %d>", lineRecData);
                RTFSetColor(kColorNone);
                RTFNewPara();
            }
            break;
        case kLineRecordCommandPageHeader:
            if (fShowEmbeds) {
                RTFSetColor(kColorBlue);
                BufPrintf("<page-header>");
                RTFSetColor(kColorNone);
                RTFNewPara();
            }
            break;
        case kLineRecordCommandPageHeaderEnd:
            if (fShowEmbeds) {
                RTFSetColor(kColorBlue);
                BufPrintf("</page-header>");
                RTFSetColor(kColorNone);
                RTFNewPara();
            }
            break;
        case kLineRecordCommandPageFooter:
            if (fShowEmbeds) {
                RTFSetColor(kColorBlue);
                BufPrintf("<page-footer>");
                RTFSetColor(kColorNone);
                RTFNewPara();
            }
            break;
        case kLineRecordCommandPageFooterEnd:
            if (fShowEmbeds) {
                RTFSetColor(kColorBlue);
                BufPrintf("</page-footer>");
                RTFSetColor(kColorNone);
                RTFNewPara();
            }
            break;
        case kLineRecordCommandNewPage:
            if (fUseRTF)
                RTFPageBreak();
            else if (fShowEmbeds) {
                RTFSetColor(kColorBlue);    // won't do anything
                BufPrintf("<page-break>");
                RTFSetColor(kColorNone);
            }
            break;

        case kLineRecordCommandPlatenWidth:
        case kLineRecordCommandCharsPerInch:
        case kLineRecordCommandProportional1:
        case kLineRecordCommandProportional2:
        case kLineRecordCommandIndent:
        case kLineRecordCommandPaperLength:
        case kLineRecordCommandTopMargin:
        case kLineRecordCommandBottomMargin:
        case kLineRecordCommandLinesPerInch:
        case kLineRecordCommandSingleSpace:
        case kLineRecordCommandDoubleSpace:
        case kLineRecordCommandTripleSpace:
        case kLineRecordCommandGroupBegin:
        case kLineRecordCommandGroupEnd:
        case kLineRecordCommandSkipLines:
        case kLineRecordCommandPauseEachPage:
        case kLineRecordCommandPauseHere:
        case kLineRecordCommandSetMarker:
        case kLineRecordCommandSetPageNumber:
        case kLineRecordCommandPageBreak:
        case kLineRecordCommandPageBreak256:
        case kLineRecordCommandPageBreakPara:
        case kLineRecordCommandPageBreakPara256:
        default:
            LOGD(" AWP cmd <0x%02x><0x%02x>", lineRecCode, lineRecData);
            break;
        }
    } else {
        /* bad command */
        LOGW("WARNING: unrecognized code 0x%02x at 0x%p", lineRecCode,
            *pSrcPtr);
        fDocState.softFailures++;
        if (fDocState.softFailures > kMaxSoftFailures) {
            LOGE("ERROR: too many failures, giving up");
            err = -1;
        }
    }

    return err;
}

/*
 * Handle a text record.  The first two bytes are flags, the rest is
 * either the text or a ruler.  Special codes may be embedded in the text.
 *
 * "lineRecData" has the number of bytes of input that we have yet to read.
 */
int ReformatAWP::HandleTextRecord(uint8_t lineRecData,
    const uint8_t** pSrcPtr, long* pLength)
{
    int err = 0;
    uint8_t tabFlags;
    uint8_t byteCountPlusCR;
    int byteCount = lineRecData;
    bool noOutput = false;
    bool inverse = false;
    int ic;

    tabFlags = Read8(pSrcPtr, pLength);
    byteCount--;
    byteCountPlusCR = Read8(pSrcPtr, pLength);
    byteCount--;
    if (*pLength < 0) {
        err = -1;
        goto bail;
    }

    if (byteCount <= 0) {
        LOGI("WARNING: line %ld: short line (%d)",
            fDocState.line, byteCount);
        /* this is bad, but keep going anyway */
    }

    if ((byteCountPlusCR & ~kCRatEOL) != byteCount) {
        LOGI("WARNING: line %ld: byteCount now %d, offset 3 count %d",
            fDocState.line, byteCount, byteCountPlusCR & ~kCRatEOL);
        /* not sure why this would legally happen */
    }

    if (tabFlags == kTabFlagsIsRuler)
        noOutput = true;

    while ((*pLength > 0) && (byteCount--)) {
        ic = Read8(pSrcPtr, pLength);
        if (*pLength < 0) {
            err = -1;
            goto bail;
        }

        if (noOutput)
            continue;

        if (ic < kMinTextChar) {
            switch (ic) {
            case kSpecialCharBoldBegin:
                RTFBoldOn();
                break;
            case kSpecialCharBoldEnd:
                RTFBoldOff();
                break;
            case kSpecialCharSuperscriptBegin:
                RTFSuperscriptOn();
                break;
            case kSpecialCharSuperscriptEnd:
                RTFSuperscriptOff();
                break;
            case kSpecialCharSubscriptBegin:
                RTFSubscriptOn();
                break;
            case kSpecialCharSubscriptEnd:
                RTFSubscriptOff();
                break;
            case kSpecialCharUnderlineBegin:
                RTFUnderlineOn();
                break;
            case kSpecialCharUnderlineEnd:
                RTFUnderlineOff();
                break;
            case kSpecialCharEnterKeyboard:
                if (fShowEmbeds) {
                    TextColor oldColor = RTFSetColor(kColorBlue);
                    BufPrintf("<kdb-entry>");
                    RTFSetColor(oldColor);
                }
                break;
            case kSpecialCharPrintPageNumber:
                if (fShowEmbeds) {
                    TextColor oldColor = RTFSetColor(kColorBlue);
                    BufPrintf("<page#>");
                    RTFSetColor(oldColor);
                }
                break;
            case kSpecialCharStickySpace:
                /* MSWord uses "\~", but RichEdit ignores that */
                BufPrintf("\u00a0");    // Unicode NO-BREAK SPACE
                break;
            case kSpecialCharMailMerge:
                if (fShowEmbeds) {
                    TextColor oldColor = RTFSetColor(kColorBlue);
                    BufPrintf("<mail-merge>");
                    RTFSetColor(oldColor);
                }
            case kSpecialCharPrintDate:
                if (fShowEmbeds) {
                    TextColor oldColor = RTFSetColor(kColorBlue);
                    BufPrintf("<date>");
                    RTFSetColor(oldColor);
                }
                break;
            case kSpecialCharPrintTime:
                if (fShowEmbeds) {
                    TextColor oldColor = RTFSetColor(kColorBlue);
                    BufPrintf("<time>");
                    RTFSetColor(oldColor);
                }
                break;
            case kSpecialCharTab:
                if (fUseRTF)
                    RTFTab();
                else
                    BufPrintf("\t");
                break;
            case kSpecialCharTabFill:
                /* tab fill char, not vis in doc */
                BufPrintf(" ");
                break;
            default:
                LOGI(" AWP unhandled special char 0x%02x", ic);
                if (fShowEmbeds) {
                    TextColor oldColor = RTFSetColor(kColorBlue);
                    BufPrintf("^");
                    RTFSetColor(oldColor);
                }
            }
        } else {
            // Character.
            bool wantInverse = false;
            uint16_t mtLow = 0, mtHigh = 0;

            if (ic >= 0x80 && ic <= 0x9f) {
                // inverse upper; map 100x xxxx --> 010x xxxx
                ic ^= 0xc0;
                wantInverse = true;
            } else if (ic >= 0xa0 && ic <= 0xbf || ic >= 0xe0 && ic <= 0xff) {
                // inverse symbols; map 101x xxxx --> 001x xxxx
                // inverse lower; map 111x xxxx --> 011x xxxx
                ic ^= 0x80;
                wantInverse = true;
            } else if (ic >= 0xc0 && ic <= 0xdf) {
                // MouseText characters
                if (fMouseTextToASCII) {
                    ic = MouseTextToASCII(ic & 0x1f);
                } else {
                    MouseTextToUTF16(ic & 0x1f, &mtLow, &mtHigh);
                    ic = '?';
                }
            } else {
                // plain ASCII
            }

            if (wantInverse && !inverse) {
                inverse = true;
                RTFInverseOn();
            } else if (!wantInverse && inverse) {
                inverse = false;
                RTFInverseOff();
            }

            if (fUseRTF) {
                if (mtLow != 0) {
                    if (mtHigh != 0) {
                        RTFPrintUTF16Char(mtHigh);
                    }
                    RTFPrintUTF16Char(mtLow);
                } else {
                    RTFPrintChar(ic);
                }
            } else {
                // Plain text output.
                BufPrintf("%c", PrintableChar(ic));
            }
        }
    }

    if (inverse) {
        RTFInverseOff();
    }

    /* if there's a carriage return at the end of the line, output it now */
    if (byteCountPlusCR & kCRatEOL) {
        RTFNewPara();
    }

    /* another line processed, advance the line counter */
    fDocState.line++;

bail:
    return err;
}


/*
 * ===========================================================================
 *      AppleWorks DB
 * ===========================================================================
 */

/*
 * AppleWorks database file format, from FTN.19.xxxx.
 *
 * The overall file format is:
 *
 *  variable-sized file header
 *  0 to 8 (0 to 30 in 3.0) report records, 600 bytes each
 *  variable-sized data records
 *  $ff $ff
 *  optional tags
 */

/*
 * Decide whether or not we want to handle this file.
 */
void ReformatADB::Examine(ReformatHolder* pHolder)
{
    ReformatHolder::ReformatApplies applies = ReformatHolder::kApplicNot;

    if (pHolder->GetFileType() == kTypeADB)
        applies = ReformatHolder::kApplicProbably;

    pHolder->SetApplic(ReformatHolder::kReformatADB, applies,
        ReformatHolder::kApplicNot, ReformatHolder::kApplicNot);
}

/*
 * Reformat an AppleWorks DB document.
 */
int ReformatADB::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 headerLen, numCats, numRecs, numReports;

    fUseRTF = false;

    /* expect header plus EOF bytes at least */
    if (srcLen <= kMinHeaderLen) {
        LOGI("  ADB truncated?");
        goto bail;
    }

    headerLen = Get16LE(srcPtr);
    if (headerLen < kMinHeaderLen || headerLen > length) {
        LOGI("  ADB bad headerLen %d, file len is %d", headerLen,
            srcLen);
        goto bail;
    }

    RTFBegin();

    /* offset +035: #of categories in file */
    numCats = *(srcPtr + 35);
    if (numCats < 1 || numCats > 0x1e) {
        LOGI("  ADB GLITCH: unexpected numCats %d", numCats);
        /* keep going... */
    }
    LOGI("  ADB should be %d categories", numCats);

    /* offset +036-037: #of records in file */
    numRecs = Get16LE(srcPtr + 36) & 0x7fff;
    LOGI("  ADB should be %d records", numRecs);

    /* offset +038: #of reports in file */
    numReports = *(srcPtr + 38);
    LOGI("  ADB should be %d reports", numReports);

    /* dump category names as first record */
    const uint8_t* catPtr;
    int catCount;
    catPtr = srcPtr + 357;
    catCount = numCats;
    while (catCount--) {
        if (catCount == numCats-1)
            BufPrintf("\"");
        else
            BufPrintf(",\"");

        int nameLen = *catPtr;
        const uint8_t* namePtr = catPtr + 1;
        while (nameLen--) {
            if (*namePtr == '"')
                BufPrintf("\"\"");
            else
                BufPrintf("%c", *namePtr);
            namePtr++;
        }

        BufPrintf("\"");

        catPtr += kCatNameLen+2;
    }
    BufPrintf("\r\n");

    /*
     * Advance pointer to first data record.  The first record contains
     * "standard values".
     *
     * Each record looks like this:
     *  $00-$01: count of bytes in remainder of record
     *  $02    : control byte, one of:
     *           $01-$7f: number of following bytes for this category
     *           $81-$9e: this (minus $80) is #of categories to skip
     *           $ff    : end of record
     *
     * The data within the categories may have special meanings, e.g. if it
     * starts with $c0 it's a date record and $d4 is a time record.
     */
    int offsetToData;
    offsetToData = kOffsetToFirstCatHeader +
                numCats*kCatHeaderLen + numReports*kReportRecordLen;
    LOGI("  ADB data records begin at offset 0x%08lx", offsetToData);
    if (offsetToData >= length) {
        LOGI("  ADB GLITCH: offset >= length %ld", length);
        goto bail;
    }

    srcPtr += offsetToData;
    length -= offsetToData;

    int rr;
    for (rr = 0; rr < numRecs && length > 0; rr++) {
        int recordRem = Read16(&srcPtr, &length);
        if (rr == 0) {
            /* skip first record */
            srcPtr += recordRem;
            length -= recordRem;
            if (*(srcPtr-1) != 0xff) {
                LOGI("  ADB GLITCH: first record skipped past 0x%02x",
                    *(srcPtr-1));
                /* keep going, I guess */
            }
            continue;
        }

        int catNum = 0;

        /* scan through all categories in this record */
        int ctrl = Read8(&srcPtr, &length);
        while (ctrl != 0xff && length > 0) {
            if (ctrl >= 0x01 && ctrl <= 0x7f) {
                /* just data */
                if (catNum == 0)
                    BufPrintf("\"");
                else
                    BufPrintf(",\"");
                if (*srcPtr == 0xc0) {
                    static const char kMonths[12][4] = {
                        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
                        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
                    };
                    /* date entry */
                    Read8(&srcPtr, &length);    // throw out the 0xc0
                    char year[2], month, day[2];
                    year[0] = Read8(&srcPtr, &length);
                    year[1] = Read8(&srcPtr, &length);
                    month = Read8(&srcPtr, &length);
                    day[0] = Read8(&srcPtr, &length);
                    day[1] = Read8(&srcPtr, &length);
                    if (day[0] == ' ')
                        day[0] = '0';
                    BufPrintf("%c%c-%s-%s%c%c",
                        day[0], day[1],
                        month >= 'A' && month <= 'L' ? kMonths[month-'A'] : "???",
                        year[0] < '7' ? "20" : "19", year[0], year[1]);
                } else if (*srcPtr == 0xd4) {
                    /* time entry */
                    Read8(&srcPtr, &length);    // throw out the 0xd4
                    char hour, minute[2];
                    hour = Read8(&srcPtr, &length);
                    minute[0] = Read8(&srcPtr, &length);
                    minute[1] = Read8(&srcPtr, &length);
                    if (hour >= 'A' && hour < 'M') {
                        if (hour == 'A')        // don't show 00:00
                            hour = 'A' + 12;
                        BufPrintf("%02d:%c%c AM",
                            hour - 'A', minute[0], minute[1]);
                    } else if (hour >= 'M' && hour <= 'X') {
                        if (hour == 'M')        // don't show 00:00
                            hour = 'M' + 12;
                        BufPrintf("%02d:%c%c PM",
                            hour - 'M', minute[0], minute[1]);
                    }
                } else {
                    while (ctrl--) {
                        uint8_t ch = Read8(&srcPtr, &length);
                        BufPrintf("%c", ch);
                        if (ch == '"')
                            BufPrintf("%c", ch);
                    }
                }
                BufPrintf("\"");
            } else if (ctrl >= 0x81 && ctrl <= 0x9e) {
                /* skip over empty categories */
                ctrl -= 0x80;
                while (ctrl--) {
                    BufPrintf(",");
                    catNum++;
                }
                catNum--;   // don't double-count this category
            } else {
                LOGI("  ADB GLITCH: invalid ctrl byte 0x%02x", ctrl);
                break;
                /* keep going anyway? */
            }

            catNum++;
            ctrl = Read8(&srcPtr, &length);
        }
        while (catNum < numCats) {
            BufPrintf(",");
            catNum++;
        }

        /* end of record */
        RTFNewPara();
    }
    LOGI("  ADB at exit rr=%d numRecs=%d", rr, numRecs);

    int checkEnd;
    checkEnd = Read16(&srcPtr, &length);
    if (checkEnd != 0xffff) {
        LOGI("  ADB GLITCH: last read returned 0x%04x", checkEnd);
    } else {
        LOGI("  ADB found EOF; success");
    }

    /* 
     * Read the optional tags.
     */
    /* (nah) */

    RTFEnd();

    SetResultBuffer(pOutput);
    pOutput->SetOutputKind(ReformatOutput::kOutputCSV);
    retval = 0;

bail:
    return retval;
}


/*
 * ===========================================================================
 *      AppleWorks SS
 * ===========================================================================
 */

/*
 * AppleWorks spreadsheet file format, from FTN.1b.xxxx.
 *
 * The overall file format is:
 *
 *  fixed-sized file header
 *  series of variable-length row records
 *      collection of cell data
 *  $ff $ff
 *  optional tags
 *
 * The cell data can take several different forms.
 */

/*
 * Decide whether or not we want to handle this file.
 */
void ReformatASP::Examine(ReformatHolder* pHolder)
{
    ReformatHolder::ReformatApplies applies = ReformatHolder::kApplicNot;

    if (pHolder->GetFileType() == kTypeASP)
        applies = ReformatHolder::kApplicProbably;

    pHolder->SetApplic(ReformatHolder::kReformatASP, applies,
        ReformatHolder::kApplicNot, ReformatHolder::kApplicNot);
}

/*
 * Reformat an AppleWorks SS document.
 */
int ReformatASP::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;
    const FileHeader* pFileHeader;
    bool aw30flag;

    ASSERT(sizeof(FileHeader) == kFileHeaderSize);

    fUseRTF = false;

    /* must at least have the header */
    if (length < kFileHeaderSize) {
        LOGI("  ADB truncated?");
        goto bail;
    }

    RTFBegin();

    pFileHeader = (const FileHeader*) srcPtr;
    aw30flag = false;
    if (pFileHeader->ssMinVers != 0)
        aw30flag = true;
    LOGI("  ASP ssMinVers=0x%02x, aw30flag=%d",
        pFileHeader->ssMinVers, aw30flag);

    /*
     * Advance pointer past file header.  v3.0 adds a couple of extra bytes
     * right after the end of the header that the FTN says we should just
     * ignore.
     */
    srcPtr += kFileHeaderSize;
    length -= kFileHeaderSize;
    if (aw30flag) {
        srcPtr += 2;
        length -= 2;
    }

    /*
     * Loop through the file, reading one row at a time.  There is no row
     * count because spreadsheets are sparse.
     *
     * We assume that rows are stored from top to bottom.  The count begins
     * with 1, not zero.
     */
    fCurrentRow = 1;
    while (length > 0) {
        uint16_t rowLen;
        int rowNum;

        /* row length or EOF marker */
        rowLen = Read16(&srcPtr, &length);
        if (rowLen == 0xffff) {
            LOGI("  ASP found EOF marker, we're done");
            break;
        }

        rowNum = Read16(&srcPtr, &length);
        //LOGI("  ASP  process row %d (cur=%d)", rowNum, currentRow);

        /* fill out empty rows */
        ASSERT(fCurrentRow <= rowNum);
        while (fCurrentRow < rowNum) {
            BufPrintf("\"\"\r\n");
            fCurrentRow++;
        }

        if (ProcessRow(rowNum, &srcPtr, &length) != 0)
            break;

        fCurrentRow++;
    }

    /* 
     * Read the optional tags.
     */
    /* (nah) */

    RTFEnd();

    SetResultBuffer(pOutput);
    pOutput->SetOutputKind(ReformatOutput::kOutputCSV);
    retval = 0;

bail:
    return retval;
}

/*
 * Process one row of spreadsheet data.
 */
int ReformatASP::ProcessRow(int rowNum, const uint8_t** pSrcPtr, long* pLength)
{
    uint8_t ctrl;
    bool first = true;

    fCurrentCol = 0;
    while (*pLength > 0) {
        ctrl = Read8(pSrcPtr, pLength);
        if (ctrl >= 0x01 && ctrl <= 0x7f) {
            if (!first)
                BufPrintf(",");
            else
                first = false;
            /* read cell entry contents */
            if (ctrl > *pLength) {
                LOGI("  ASP GLITCH: cell len exceeds file len (%d %d)",
                    *pLength, ctrl);
                break;
            }
            ProcessCell(*pSrcPtr, ctrl);
            (*pSrcPtr) += ctrl;
            *pLength -= ctrl;
        } else if (ctrl >= 0x81 && ctrl <= 0xfe) {
            /* skip this many columns */
            if (!first)
                BufPrintf(",");
            else
                first = false;

            ctrl -= 0x80;
            ctrl--;
            while (ctrl--) {
                BufPrintf(",");
                fCurrentCol++;
            }
        } else if (ctrl == 0xff) {
            /* end of row */
            break;
        } else {
            /* unexpected 0x00 or 0x80 */
            LOGI("  ASP GLITCH: unexpected ctrl byte 0x%02x", ctrl);
            break;
        }

        fCurrentCol++;
    }

    BufPrintf("\r\n");

    return 0;
}

/*
 * Process the contents of a single cell.
 */
void ReformatASP::ProcessCell(const uint8_t* srcPtr, long cellLength)
{
    uint8_t flag1, flag2;
    double dval;
    int i;

    BufPrintf("\"");

    flag1 = *srcPtr++;
    cellLength--;

    if (flag1 & 0x80) {     /* bit 7 set? */
        /* this is a value, not a label */
        flag2 = *srcPtr++;
        cellLength--;

        if (flag1 & 0x20) { /* bit 5 set? */
            /* this is a "value constant" */
            dval = ConvertSANEDouble(srcPtr);
            BufPrintf("%f", dval);
        } else {
            if (flag2 & 0x08) { /* bit 3 set? */
                /* this is a "value label", AW30+ only */
                /* skip over cached string result */
                if (*srcPtr >= cellLength) {
                    LOGI("  ASP GLITCH: invalid value label str len");
                    BufPrintf("GLITCH");
                } else {
                    srcPtr += *srcPtr +1;
                    /* output tokens */
                    while (cellLength > 0)
                        PrintToken(&srcPtr, &cellLength);
                }
            } else {
                /* this is a "value formula" */
                //dval = ConvertSANEDouble(srcPtr);
                /* skip over cached computation result */
                if (cellLength <= kSANELen) {
                    LOGI("  ASP GLITCH: invalid value formula len");
                    BufPrintf("GLITCH");
                } else {
                    srcPtr += kSANELen;
                    cellLength -= kSANELen;
                    /* [tokens] */
                    while (cellLength > 0)
                        PrintToken(&srcPtr, &cellLength);
                }
            }
        }
    } else {
        /* this is a label, not a value */

        if (flag1 & 0x20) { /* bit 5 set? */
            /* propagated label cell */
            for (i = 0; i < kPropCount; i++)
                BufPrintQChar(*srcPtr);
        } else {
            /* regular label cell */
            for (i = 0; i < cellLength; i++)
                BufPrintQChar(srcPtr[i]);
        }
    }

    BufPrintf("\"");
}

/*
 * Print the AppleWorks SS token pointed to by srcPtr.  Some tokens require
 * several bytes to express.
 */
void ReformatASP::PrintToken(const uint8_t** pSrcPtr, long* pLength)
{
    /* string constants; note these must NOT contain '"' chars */
    const int kTokenStart = 0xc0;
    const char* tokenTable[0x100-kTokenStart] = {
        /*0xc0*/ "@Deg",    "@Rad",     "@Pi",      "@True",
        /*0xc4*/ "@False",  "@Not",     "@IsBlank", "@IsNA",
        /*0xc8*/ "@IsError", "@Exp",    "@Ln",      "@Log",
        /*0xcc*/ "@Cos",    "@Sin",     "@Tan",     "@ACos",
        /*0xd0*/ "@ASin",   "@ATan2",   "@ATan",    "@Mod",
        /*0xd4*/ "@FV",     "@PV",      "@PMT",     "@Term",
        /*0xd8*/ "@Rate",   "@Round",   "@Or",      "@And",
        /*0xdc*/ "@Sum",    "@Avg",     "@Choose",  "@Count",
        /*0xe0*/ "@Error",  "@IRR",     "@If",      "@Int",
        /*0xe4*/ "@Lookup", "@Max",     "@Min",     "@NA",
        /*0xe8*/ "@NPV",    "@Sqrt",    "@Abs",     "",
        /*0xec*/ "<>",      ">=",       "<=",       "=",
        /*0xf0*/ ">",       "<",        ",",        "^",
        /*0xf4*/ ")",       "-",        "+",        "/",
        /*0xf8*/ "*",       "(",        "-" /*unary*/, "+" /*unary*/,
        /*0xfc*/ "...",     "",         "",         ""
    };
    uint8_t token;

    token = Read8(pSrcPtr, pLength);
    if (token < kTokenStart) {
        LOGI("  ASP GLITCH: funky token 0x%02x", token);
        return;
    }

    BufPrintf("%s", tokenTable[token - kTokenStart]);
    if (token == 0xe0 || token == 0xe7) {
        /* @Error and @NA followed by three zero bytes */
        if (*pLength < 3) {
            LOGI("  ASP GLITCH: ran off end processing tokens");
            return;
        }
        *pSrcPtr += 3;
        *pLength -= 3;
    } else if (token == 0xfd) {
        /* SANE double number */
        if (*pLength < 8) {
            LOGI("  ASP GLITCH: not enough left to grab a SANE");
            return;
        }
        double dval = ConvertSANEDouble(*pSrcPtr);
        BufPrintf("%f", dval);
        *pSrcPtr += 8;
        *pLength -= 8;
    } else if (token == 0xfe) {
        /* row, column reference (relative to current cell) */
        int row, col;
        col = Read8(pSrcPtr, pLength);
        if (col >= 128)
            col -= 256;
        row = Read16(pSrcPtr, pLength);
        if (row >= 32768)
            row -= 65536;
        BufPrintf("%s%d", PrintCol(fCurrentCol+col), fCurrentRow+row);
    } else if (token == 0xff) {
        /* Pascal string */
        int i;
        i = Read8(pSrcPtr, pLength);
        if (i > *pLength) {
            LOGI("  ASP GLITCH: string exceeds cell len");
            return;
        }
        while (i--) {
            uint8_t ch = Read8(pSrcPtr, pLength);
            BufPrintQChar(ch);
        }
    }
}

/*
 * Format the current column number into something like 'A' or 'BA'.  This
 * stores the value in fPrintColBuf and returns a pointer to it.
 */
const char* ReformatASP::PrintCol(int col)
{
    if (col < 0 || col >= 702) {
        LOGI("  ASP can't PrintCol(%d)", col);
        fPrintColBuf[0] = fPrintColBuf[1] = '?';
        fPrintColBuf[2] = '\0';
    } else if (col < 26) {
        fPrintColBuf[0] = 'A' + col;
        fPrintColBuf[1] = '\0';
    } else {
        fPrintColBuf[0] = 'A' + col / 26;
        fPrintColBuf[1] = 'A' + col % 26;
        fPrintColBuf[2] = '\0';
    }
    return fPrintColBuf;
}

/*
 * Convert a 64-bit SANE double to an x86 double.  The format is the same as
 * IEEE 754, which happily is the same used by the VC++6.0 compiler.
 *
 * Info from http://www.cs.trinity.edu/About/The_Courses/cs2322/ieee-fp.html
 * (also http://www.psc.edu/general/software/packages/ieee/ieee.html).
 *
 * -----
 * The 64-bit double format is divided into three fields as shown below:
 *
 *    1       11               52
 *  +-------------------------------------+
 *  | s |     e    |           f          |
 *  +-------------------------------------+
 *
 * The value v of the number is determined by these fields as shown in
 * the following table:
 *
 * Values of double-format numbers (64 bits) 
 * ___________________________________________________________
 * e        f         v                           class of v
 * ___________________________________________________________
 * 0<e<2047 (any)     v=(-1)s x 2(e-1023) x (1.f)  normalized
 * e=0      f!=0      v=(-1)s x 2(e-1022) x (0.f)  denormalized
 * e=0      f=0       v=(-1)s x 0                 zero
 * e=2047   f=0       v=(-1)s x infinity          infinity
 * e=2047   f!=0      v is a NaN                  NaN
 *
 * For example, the double representation (in hex notation) of 1.5 is 
 * 3FF8000000000000
 * is 
 * 3F847AE147AE147A
 * -----
 */
double ReformatASP::ConvertSANEDouble(const uint8_t* srcPtr)
{
    double newVal;
    uint8_t* dptr;
    int i;

    ASSERT(sizeof(newVal) == kSANELen);

    dptr = (uint8_t*) &newVal;
    for (i = 0; i < kSANELen; i++)
        *dptr++ = *srcPtr++;

    return newVal;
}
