PwpFile.cxx

Go to the documentation of this file.

/****************************************************************************
 *
 * class PwpFile
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/

#include "PwpFile.h"
#include "PwpFileWriter.h"
#include "pwpPlatform.h"

#include <cctype>
#include <cstring>
#include <cstdio>
#include <string>


// readOrdered(), writeOrdered() max number of swappable buffer bytes
enum {
    ORDERED_MAXSIZE = 8
};


//***************************************************************************
//***************************************************************************
//***************************************************************************

class PwpAsciiWriter : public PwpFileWriter {
public:

    PwpAsciiWriter(PwpFile &file) :
        PwpFileWriter(file)
    {
    }


    virtual ~PwpAsciiWriter()
    {
    }


    virtual bool write(PWP_INT64 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        return 0 <= fprintf(file_.fp(), "%s%" PWP_INT64_FORMAT "%s",
            (prefix ? prefix : ""), val, (suffix ? suffix : ""));
    }


    virtual bool write(PWP_INT32 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        return 0 <= fprintf(file_.fp(), "%s%ld%s", (prefix ? prefix : ""),
            (long)val, (suffix ? suffix : ""));
    }


    virtual bool write(PWP_INT16 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        return 0 <= fprintf(file_.fp(), "%s%ld%s", (prefix ? prefix : ""),
            (long)val, (suffix ? suffix : ""));
    }


    virtual bool write(PWP_INT8 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        return 0 <= fprintf(file_.fp(), "%s%ld%s", (prefix ? prefix : ""),
            (long)val, (suffix ? suffix : ""));
    }


    virtual bool write(PWP_UINT64 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        return 0 <= fprintf(file_.fp(), "%s%" PWP_UINT64_FORMAT "%s",
            (prefix ? prefix : ""), val, (suffix ? suffix : ""));
    }


    virtual bool write(PWP_UINT32 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        return 0 <= fprintf(file_.fp(), "%s%lu%s", (prefix ? prefix : ""),
            (unsigned long)val, (suffix ? suffix : ""));
    }


    virtual bool write(PWP_UINT16 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        return 0 <= fprintf(file_.fp(), "%s%lu%s", (prefix ? prefix : ""),
            (unsigned long)val, (suffix ? suffix : ""));
    }


    virtual bool write(PWP_UINT8 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        return 0 <= fprintf(file_.fp(), "%s%lu%s", (prefix ? prefix : ""),
            (unsigned long)val, (suffix ? suffix : ""));
    }


    virtual bool write(PWP_FLOAT val, const char *suffix = 0,
        const char *prefix = 0)
    {
        return file_.isDouble() ?
            writeWdPrec(val, fmtFieldWdDouble_, fmtPrecDouble_,
                (suffix ? suffix : ""), (prefix ? prefix : "")) :
            writeWdPrec(val, fmtFieldWdSingle_, fmtPrecSingle_,
                (suffix ? suffix : ""), (prefix ? prefix : ""));
    }


    virtual bool write(PWP_REAL val, const char *suffix = 0,
        const char *prefix = 0)
    {
        return file_.isSingle() ?
            writeWdPrec(val, fmtFieldWdSingle_, fmtPrecSingle_,
                (suffix ? suffix : ""), (prefix ? prefix : "")) :
            writeWdPrec(val, fmtFieldWdDouble_, fmtPrecDouble_,
                (suffix ? suffix : ""), (prefix ? prefix : ""));
    }


    virtual bool write(const char * val, PWP_INT size = -1, char /*pad*/ = 0)
    {
        if (-1 == size) {
            size = (PWP_INT)strlen(val);
        }
        return 0 <= fprintf(file_.fp(), "%*.*s", (int)size, (int)size, val);
    }


private:

    bool writeWdPrec(PWP_REAL val, int wd, int prec, const char *sfx,
        const char *pfx)
    {
        switch (fmtType_) {
        case FormatG:
            return 0 <= fprintf(file_.fp(), "%s%g%s", pfx, val, sfx);
        case FormatWdPrecG:
            return 0 <= fprintf(file_.fp(), "%s%*.*g%s", pfx, wd, prec, val, sfx);
        case FormatWdG:
            return 0 <= fprintf(file_.fp(), "%s%*g%s", pfx, wd, val, sfx);
        case FormatPrecG:
            return 0 <= fprintf(file_.fp(), "%s%.*g%s", pfx, prec, val, sfx);

        case FormatF:
            return 0 <= fprintf(file_.fp(), "%s%f%s", pfx, val, sfx);
        case FormatWdPrecF:
            return 0 <= fprintf(file_.fp(), "%s%*.*f%s", pfx, wd, prec, val, sfx);
        case FormatWdF:
            return 0 <= fprintf(file_.fp(), "%s%*f%s", pfx, wd, val, sfx);
        case FormatPrecF:
            return 0 <= fprintf(file_.fp(), "%s%.*f%s", pfx, prec, val, sfx);

        case FormatE:
            return 0 <= fprintf(file_.fp(), "%s%e%s", pfx, val, sfx);
        case FormatWdPrecE:
            return 0 <= fprintf(file_.fp(), "%s%*.*e%s", pfx, wd, prec, val, sfx);
        case FormatWdE:
            return 0 <= fprintf(file_.fp(), "%s%*e%s", pfx, wd, val, sfx);
        case FormatPrecE:
            return 0 <= fprintf(file_.fp(), "%s%.*e%s", pfx, prec, val, sfx);
        }
        return false;
    }
};


//***************************************************************************
//***************************************************************************
//***************************************************************************

class PwpBinaryWriter : public PwpFileWriter {

    template< typename T >
    bool writeOrdered(T val) {
        return writeOrdered(&val, sizeof(T));
    }

public:

    PwpBinaryWriter(PwpFile &file) :
        PwpFileWriter(file)
    {
    }


    virtual ~PwpBinaryWriter()
    {
    }


    virtual bool write(PWP_INT64 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return writeOrdered(val);
    }


    virtual bool write(PWP_INT32 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return writeOrdered(val);
    }


    virtual bool write(PWP_INT16 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return writeOrdered(val);
    }


    virtual bool write(PWP_INT8 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return writeOrdered(val);
    }


    virtual bool write(PWP_UINT64 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return writeOrdered(val);
    }


    virtual bool write(PWP_UINT32 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return writeOrdered(val);
    }


    virtual bool write(PWP_UINT16 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return writeOrdered(val);
    }


    virtual bool write(PWP_UINT8 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return writeOrdered(val);
    }


    virtual bool write(PWP_FLOAT val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        if (file_.isDouble()) {
            return writeOrdered((PWP_REAL)val);
        }
        return writeOrdered(val);
    }


    virtual bool write(PWP_REAL val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        if (file_.isSingle()) {
            return writeOrdered((PWP_FLOAT)val);
        }
        return writeOrdered(val);
    }


    virtual bool write(const char * val, PWP_INT size = -1, char pad = 0)
    {
        bool ret = false;
        if (0 != val) {
            PWP_INT len = (PWP_INT)strlen(val);
            if (-1 == size) {
                size = len;
            }
            if (len >= size) {
                // no padding needed
                ret = (1 == pwpFileWrite(val, size, 1, file_.fp()));
            }
            else if (1 == pwpFileWrite(val, len, 1, file_.fp())) {
                // str already written, now write pad chars
                ret = true;
                const size_t bufSz = 512;
                char padBuf[bufSz] = { '\0' }; // compiler fills all with zeros
                if (0 != pad) {
                    memset(padBuf, pad, bufSz);
                }
                size -= len; // reduce size by # chars already written
                while (ret && (bufSz < size)) {
                    ret = (1 == pwpFileWrite(padBuf, bufSz, 1, file_.fp()));
                    size -= bufSz;
                }
                // write final partial buffer (size == 0 is okay)
                ret = ret && (1 == pwpFileWrite(padBuf, size, 1, file_.fp()));
            }
        }
        return ret;
    }

private:

    bool
    writeOrdered(const void *buf, size_t size)
    {
        bool ret = false;
        FILE *fp = file_.fp();
        if (0 == buf) {
            // bad
        }
        else if (1 == size) {
            ret = (1 == pwpFileWrite(buf, size, 1, fp));
        }
        else if (!(size & 0x1) && (ORDERED_MAXSIZE >= size)) {
            static unsigned char tmpBuf[ORDERED_MAXSIZE];
            if (file_.needByteSwap()) {
                const char *cbuf = (const char *)buf;
                size_t hNdx = 0;
                size_t tNdx = size - 1;
                while (hNdx < tNdx) {
                    tmpBuf[hNdx]   = cbuf[tNdx];
                    tmpBuf[tNdx--] = cbuf[hNdx++];
                }
                buf = tmpBuf; // write tmpBuf instead
            }
            ret = (1 == pwpFileWrite(buf, size, 1, fp));
        }
        return ret;
    }
};


//***************************************************************************
//***************************************************************************
//***************************************************************************

class PwpUnformattedWriter : public PwpFileWriter {
public:

    PwpUnformattedWriter(PwpFile &file) :
        PwpFileWriter(file)
    {
        PwuUnfFileBegin(file_.fp(), &file_.unfData());
    }


    virtual ~PwpUnformattedWriter()
    {
        PwuUnfFileEnd(&file_.unfData());
    }


    virtual bool beginRecord() {
        endRecord();
        PwuUnfFileSetEndianness(&file_.unfData(), file_.getByteOrder());
        return 0 != PwuUnfRecBegin(&file_.unfData());
    }


    virtual bool beginRecord(PWP_UINT32 bytes, PWP_UINT32 count = 1) {
        endRecord();
        PwuUnfFileSetEndianness(&file_.unfData(), file_.getByteOrder());
        return 0 != PwuUnfRecBeginFixed(&file_.unfData(), bytes, count);
    }


    virtual bool endRecord() {
        return 0 != PwuUnfRecEnd(&file_.unfData());
    }


    virtual bool write(PWP_INT64 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return 0 != PwuUnfRecWriteINT64(&file_.unfData(), val);
    }


    virtual bool write(PWP_INT32 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return 0 != PwuUnfRecWriteINT32(&file_.unfData(), val);
    }


    virtual bool write(PWP_INT16 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return 0 != PwuUnfRecWriteINT16(&file_.unfData(), val);
    }


    virtual bool write(PWP_INT8 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return 0 != PwuUnfRecWriteINT8(&file_.unfData(), val);
    }


    virtual bool write(PWP_UINT64 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return 0 != PwuUnfRecWriteUINT64(&file_.unfData(), val);
    }


    virtual bool write(PWP_UINT32 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return 0 != PwuUnfRecWriteUINT32(&file_.unfData(), val);
    }


    virtual bool write(PWP_UINT16 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return 0 != PwuUnfRecWriteUINT16(&file_.unfData(), val);
    }


    virtual bool write(PWP_UINT8 val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        return 0 != PwuUnfRecWriteUINT8(&file_.unfData(), val);
    }


    virtual bool write(PWP_FLOAT val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        if (file_.isDouble()) {
            return 0 != PwuUnfRecWriteREAL(&file_.unfData(), (PWP_REAL)val);
        }
        return 0 != PwuUnfRecWriteFLOAT(&file_.unfData(), val);
    }


    virtual bool write(PWP_REAL val, const char *suffix = 0,
        const char *prefix = 0)
    {
        (void)prefix, (void)suffix;
        if (file_.isSingle()) {
            return 0 != PwuUnfRecWriteFLOAT(&file_.unfData(), (PWP_FLOAT)val);
        }
        return 0 != PwuUnfRecWriteREAL(&file_.unfData(), val);
    }


    virtual bool write(const char * val, PWP_INT size = -1, char pad = 0)
    {
        bool ret = false;
        if (0 != val) {
            PWP_INT len = (PWP_INT)strlen(val);
            if (-1 == size) {
                size = len;
            }
            if (len >= size) {
                // no padding needed
                ret = (0 != PwuUnfRecWriteBuf(&file_.unfData(), val, size));
            }
            else if (0 != PwuUnfRecWriteBuf(&file_.unfData(), val, len)) {
                // str already written, now write pad chars
                ret = true;
                const size_t bufSz = 512;
                char padBuf[bufSz] = { '\0' }; // compiler fills all with zeros
                if (0 != pad) {
                    memset(padBuf, pad, bufSz);
                }
                size -= len; // reduce size by # chars already written
                while (ret && (bufSz < size)) {
                    ret = (0 != PwuUnfRecWriteBuf(&file_.unfData(), padBuf,
                        bufSz));
                    size -= bufSz;
                }
                // write final partial buffer (size == 0 is okay)
                ret = ret && (0 != PwuUnfRecWriteBuf(&file_.unfData(), padBuf,
                    size));
            }
        }
        return ret;
    }
};


//***************************************************************************
//***************************************************************************
//***************************************************************************

PwpFile::PwpFile(FILE *fp, std::string filename, int mode) :
    fp_(0),
    mode_(0),
    filename_(),
    byteOrder_(PWP_ENDIAN_NATIVE),
    precision_(PWP_PRECISION_DOUBLE),
    ud_(),
    writer_(0)
{
    wrap(fp, filename, mode);
}


PwpFile::PwpFile(std::string filename, int mode) :
    fp_(0),
    mode_(0),
    filename_(),
    byteOrder_(PWP_ENDIAN_NATIVE),
    precision_(PWP_PRECISION_DOUBLE),
    ud_(),
    writer_(0)
{
    open(filename, mode);
}

PwpFile::PwpFile(const PwpFile &ref) :
    fp_(nullptr),
    mode_(),
    filename_(),
    byteOrder_(ref.byteOrder_),
    precision_(ref.precision_),
    ud_(),
    writer_(nullptr)
{
    open(ref.filename_, ref.mode_);
}

PwpFile::~PwpFile()
{
    close();
}

PwpFile&
PwpFile::operator = (const PwpFile &ref)
{
    open(ref.filename_, ref.mode_);
    byteOrder_ = ref.byteOrder_;
    precision_ = ref.precision_;
    return *this;
}


bool
PwpFile::wrap(FILE *fp, std::string filename, int mode)
{
    close();
    fp_ = fp;
    if (0 != fp_) {
        filename_ = filename;
        mode_ = mode;
        if (isAscii()) {
            writer_ = new PwpAsciiWriter(*this);
        }
        else if (isBinary()) {
            writer_ = new PwpBinaryWriter(*this);
        }
        else if (isUnformatted()) {
            writer_ = new PwpUnformattedWriter(*this);
        }
        if (0 == writer_) {
            close(); // bad error
        }
    }
    return 0 != fp_;
}


bool
PwpFile::open(std::string filename, int mode)
{
    return wrap(pwpFileOpen(filename.c_str(), mode), filename, mode);
}


bool
PwpFile::isOpen() const
{
    return 0 != fp_;
}

bool 
PwpFile::fileEof() const
{
    return 0 != feof(fp_);
}


bool
PwpFile::close()
{
    // delete writer_ BEFORE closing file so dtor has a chance to use file.
    delete writer_;
    writer_ = 0;
    bool ret = (0 == pwpFileClose(fp_));
    fp_ = 0;
    filename_.clear();
    mode_ = 0;
    return ret;
}


PWP_ENDIANNESS
PwpFile::setByteOrder(PWP_ENDIANNESS byteOrder)
{
    PWP_ENDIANNESS ret = byteOrder_;
    byteOrder_ = byteOrder;
    return ret;
}


PWP_ENDIANNESS
PwpFile::getByteOrder(bool mapBigLittle) const
{
    return mapBigLittle ? mapToBigLittle(byteOrder_) : byteOrder_;
}


PWP_ENUM_PRECISION
PwpFile::setPrecision(PWP_ENUM_PRECISION precision)
{
    PWP_ENUM_PRECISION ret = precision_;
    precision_ = precision;
    return ret;
}


PWP_ENUM_PRECISION
PwpFile::getPrecision() const
{
    return precision_;
}


bool
PwpFile::isReadable() const
{
    return 0 != (mode_ & pwpRead);
}


bool
PwpFile::isWritable() const
{
    return 0 != (mode_ & pwpWrite);
}


bool
PwpFile::isSingle() const
{
    return PWP_PRECISION_SINGLE == precision_;
}


bool
PwpFile::isDouble() const
{
    return PWP_PRECISION_DOUBLE == precision_;
}


bool
PwpFile::isAscii() const
{
    return 0 != (mode_ & (pwpAscii | pwpFormatted));
}

bool
PwpFile::checkAscii() const
{
    bool ret = false;
    PwpFile local(*this);
    PWP_UINT64 fileSize;
    getSize(filename_.c_str(), fileSize);
    
    // Process chunks of data from file to determine ASCII-ness!
    const size_t NumChunks = 4;
    const size_t ChunkSize = 256;
    const size_t FullBufSize = ChunkSize * NumChunks;
    PWP_UINT8 buf[FullBufSize];
    PWP_UINT n = 0;
    if (FullBufSize >= fileSize) {
        // Entire file fits in buf
        n = pwpFileRead(buf, sizeof(PWP_UINT8), FullBufSize, local.fp_);
    }
    else {
        // Get chunk 1 from start of file
        n = pwpFileRead(buf, sizeof(PWP_UINT8), ChunkSize, local.fp_);
        // Get chunks 2 ... NumChunks from file at equally spaced intervals
        for (PWP_UINT chunk = 1; chunk < NumChunks; ++chunk) {
            if (!local.setIntPos((chunk * fileSize) / NumChunks)) {
                continue;
            }
            // Fill this chunk with chars from start of interval.
            n += pwpFileRead(buf + n, sizeof(PWP_UINT8), ChunkSize, local.fp_);
        }
    }

    // Scan for number of non-ascii chars found in buf[]
    PWP_UINT nNonAscii = 0;
    for (PWP_UINT ii = 0; ii < n; ++ii) {
        if ((0x80 <= buf[ii]) || (0x08 >= buf[ii])) {
            ++nNonAscii;
        }
    }
    ret = ((nNonAscii / (PWP_REAL)n) < 0.1);

    return ret;
}

static bool
parseUnformattedRecord(PwpFile &theFile, PWP_INT64 &totalRecSize, bool &swap)
{
    bool result = false;
    PWP_UINT64 fileSize;
    theFile.getSize(fileSize);

    totalRecSize = 0;
    if (0 < fileSize) {
        // It is valid for block length to be zero. So, there must be at
        // least (header + footer) bytes remaining in file for a valid
        // record to exist.
        const PWP_INT64 HDRFTR_VALUE_SIZE = sizeof(PWP_INT32);
        const PWP_INT64 MIN_RECORD_SIZE = 2 * HDRFTR_VALUE_SIZE;

        try {
            // calc starting unconsumed file bytes
            PWP_INT64 bytesRemaining = fileSize - theFile.getPos();
            if (bytesRemaining >= MIN_RECORD_SIZE) {
                // get record's data block size
                PWP_INT32 blockSize = theFile.readSwap<PWP_INT32>(swap);
                // verify there are enough bytes left in theFile for footer
                // skip past data block to beginning of footer
                // consume footer and verify the header/footer values match
                bytesRemaining -= HDRFTR_VALUE_SIZE + blockSize;
                if ((HDRFTR_VALUE_SIZE <= bytesRemaining) &&
                    theFile.setIntPos(theFile.getPos() + blockSize) &&
                    (blockSize == theFile.readSwap<PWP_INT32>(swap))) {
                    totalRecSize = HDRFTR_VALUE_SIZE + blockSize +
                        HDRFTR_VALUE_SIZE;
                    result = true;
                }
            }
        }
        catch (...) {
            result = false;
        }
    }
    return result;
}

bool
PwpFile::checkUnformatted(bool &swapped, std::vector<PWP_INT64> *pRecSizes) const
{
    bool result = false;
    PwpFile local(*this);
    if (pRecSizes) {
        pRecSizes->clear();
    }
    
    PWP_INT64 totalRecSize;
    sysFILEPOS start; 
    local.getPos(start);
    bool swap = true;

    if (!parseUnformattedRecord(local, totalRecSize, swap)) {
        local.setPos(start);
        // toggle swap bytes flag and try to read first record again
        swap = !swap;
        parseUnformattedRecord(local, totalRecSize, swap);
    }
    if (0 < totalRecSize) {
        if (pRecSizes) {
            pRecSizes->push_back(totalRecSize);
        }
        PWP_UINT64 fileSize;
        local.getSize(fileSize);
        PWP_INT64 bytesRemaining = fileSize - totalRecSize;
        while (parseUnformattedRecord(local, totalRecSize, swap)) {
            if (pRecSizes) {
                pRecSizes->push_back(totalRecSize);
            }
            bytesRemaining -= totalRecSize;
        }
        result = (0 == bytesRemaining);
        if (result) {
            swapped = swap;
        }
    }

    local.setPos(start);
    
    return result;
}

bool
PwpFile::isBinary() const
{
    return 0 != (mode_ & pwpBinary);
}


bool
PwpFile::isUnformatted() const
{
    return 0 != (mode_ & pwpUnformatted);
}


bool
PwpFile::isEof() const
{
    return 0 != pwpFileEof(fp_);
}


bool
PwpFile::flush()
{
    return 0 == pwpFileFlush(fp_);
}


bool
PwpFile::getPos(sysFILEPOS &pos) const
{
    return 0 == pwpFileGetpos(fp_, &pos);
}

PWP_INT64
PwpFile::getPos() const
{
#if !defined(linux)
    fpos_t pos;
    pwpFileGetpos(fp_, &pos);
#else
    //linux fpos_t cannot be casted to long
    PWP_INT64 pos;
    pos = ::ftell(fp_);
#endif
    return (PWP_INT64)pos;
}


bool
PwpFile::setIntPos(const PWP_INT64 &position)
{
#if !defined(linux)
    fpos_t pos = position;
    return 0 == pwpFileSetpos(fp_, &pos);
#else
    return (::fseek(fp_,position,SEEK_SET) == 0);
#endif
}

bool
PwpFile::setPos(const sysFILEPOS &position)
{
    return 0 == pwpFileSetpos(fp_, &position);
}

bool
PwpFile::rewind()
{
    pwpFileRewind(fp_);
    return 0 != fp_;
}


bool
PwpFile::getSize(PWP_UINT64 &size) const
{
    size_t sz;
    return (0 == pwpFileGetSize(fp_, &sz)) ?
                ((size = (PWP_UINT64)sz), true) :
                false;
}


bool
PwpFile::getSize(const char *filename, PWP_UINT64 &size)
{
    size_t sz;
    return (0 == pwpFilenameGetSize(filename, &sz)) ?
        ((size = (PWP_UINT64)sz), true) :
        false;
}


void
PwpFile::setName(std::string filename)
{
    filename_ = filename;
}


const char *
PwpFile::getName() const
{
    return filename_.c_str();
}


bool
PwpFile::read(void *buf, size_t size, size_t count)
{
    return count == pwpFileRead(buf, size, count, fp_);
}


bool
PwpFile::wspaceSkip()
{
    int c;
    while (1) {
        if (!getcNotEOF(c)) {
            return false;
        }
        if (!std::isspace(c)) {
            break;
        }
    }
    // put back non-whitespace char
    return ungetc(c);
}


bool
PwpFile::readToken(std::string &tok)
{
    tok.clear();
    if (wspaceSkip()) {
        tok.reserve(DefReserve);
        while (1) {
            const int c = ::fgetc(fp_);
            if (EOF == c) {
                break;
            }
            if (!std::isspace(c)) {
                tok += static_cast<char>(c);
                continue;
            }
            // found trailing white space char, put it back and stop
            ::ungetc(c, fp_);
            break;
        }
    }
    return !tok.empty();
}


bool
PwpFile::readAlphaToken(std::string &tok)
{
    tok.clear();
    if (wspaceSkip()) {
        tok.reserve(DefReserve);
        while (1) {
            const int c = ::fgetc(fp_);
            if (EOF == c) {
                break;
            }
            if (std::isalpha(c)) {
                tok += static_cast<char>(c);
                continue;
            }
            // found non-alpha char put it back
            ::ungetc(c, fp_);
            break;
        }
    }
    return !tok.empty();
}


bool
PwpFile::readUntil(std::string &str, const int stopC, int maxLen,
    const bool doTrim)
{
    if (0 == maxLen) {
        maxLen = 2048; // sanity check
    }
    str.clear();
    str.reserve(DefReserve);
    int len = 0;
    while (len <= maxLen) {
        const int c = ::fgetc(fp_);
        // check this first to support stopC == EOF
        if (stopC == c) {
            if (doTrim) {
                trim(str);
            }
            return true;
        }
        if (EOF == c) {
            break;
        }
        str += static_cast<char>(c);
        ++len;
    }
    return false;
}


bool
PwpFile::readAscVal(PWP_REAL *v, PWP_UINT32 cnt, const PWP_UINT32 base)
{
    (void)base;
    while (cnt--) {
        if (1 != fscanf(*this, "%lf", v++)) {
            return false;
        }
    }
    return true;
}


bool
PwpFile::readAscVal(PWP_FLOAT *v, PWP_UINT32 cnt, const PWP_UINT32 base)
{
    (void)base;
    while (cnt--) {
        if (1 != fscanf(*this, "%f", v++)) {
            return false;
        }
    }
    return true;
}


bool
PwpFile::readAscVal(PWP_UINT32 *v, PWP_UINT32 cnt, const PWP_UINT32 base)
{
    (void)base;
    while (cnt--) {
        if (1 != fscanf(*this, "%u", (unsigned int*)v++)) {
            return false;
        }
    }
    return true;
}


bool
PwpFile::readAscVal(char *v, PWP_UINT32 cnt, const PWP_UINT32 base)
{
    (void)base;
    while (cnt--) {
        if (1 != fscanf(*this, "%c", v++)) {
            return false;
        }
    }
    return true;
}

bool
PwpFile::readInt(PWP_UINT32 &val, const PWP_UINT32 base,
    PWP_UINT32 maxDigits)
{
    if (0 == maxDigits) {
        maxDigits = PWP_UINT32_MAX;
    }
    std::string tok;
    if (wspaceSkip()) {
        tok.reserve(DefReserve);
        while (0 != maxDigits) {
            const int c = ::fgetc(fp_);
            if (EOF == c) {
                return !tok.empty();
            }
            if (10 == base) {
                if (std::isdigit(c)) {
                    tok += static_cast<char>(c);
                    --maxDigits;
                    continue;
                }
            }
            else if (16 == base) {
                if (std::isxdigit(c)) {
                    tok += static_cast<char>(c);
                    --maxDigits;
                    continue;
                }
            }
            else if (8 == base) {
                if ((c >= '0') && (c <= '7')) {
                    tok += static_cast<char>(c);
                    --maxDigits;
                    continue;
                }
            }
            else if (!std::isspace(c)) {
                // other base - this is not complete
                tok += static_cast<char>(c);
                --maxDigits;
                continue;
            }
            // found non-int char put it back
            ::ungetc(c, fp_);
            break;
        }
    }
    return tok.empty() ? false :
        ((val = std::stoul(tok.c_str(), 0, int(base))), true);
}


bool
PwpFile::readOptionalInt(PWP_UINT32 &v, const PWP_UINT32 defV,
    const PWP_UINT32 base, PWP_UINT32 maxDigits)
{
    return PwpFile::readInt(v, base, maxDigits) ? true : ((v = defV), false);
}


bool
PwpFile::readDouble(PWP_REAL &val, PWP_UINT32 maxDigits)
{
    //char *endPtr;
    //val = std::strtod(toks.at(0).c_str(), &endPtr);
    //return ret;
    if (0 == maxDigits) {
        maxDigits = PWP_UINT32_MAX;
    }
    std::string tok;
    if (wspaceSkip()) {
        tok.reserve(DefReserve);
        while (1) {
            const int c = ::fgetc(fp_);
            if (EOF == c) {
                return false;
            }
            if (std::isdigit(c)) {
                tok += static_cast<char>(c);
                continue;
            }
            // found non-alpha char put it back
            ::ungetc(c, fp_);
            break;
        }
    }
    return tok.empty() ? false :
        ((val = std::stoul(tok.c_str(), 0, 10)), true);
}

bool
PwpFile::unlink(const char *filename)
{
    return 0 == pwpFileDelete(filename);
}


PWP_ENDIANNESS
PwpFile::getOsByteOrder()
{
    return (PWP_ENDIANNESS)PwuGetOsEndianness();
}


PWP_ENDIANNESS
PwpFile::mapToBigLittle(PWP_ENDIANNESS byteOrder)
{
    PWP_ENDIANNESS ret = byteOrder;
    switch (byteOrder) {
    case PWP_ENDIAN_NATIVE:
        ret = getOsByteOrder();
        break;
    case PWP_ENDIAN_FOREIGN:
        ret = (PWP_ENDIAN_BIG == getOsByteOrder() ? PWP_ENDIAN_LITTLE :
                PWP_ENDIAN_BIG);
        break;
    case PWP_ENDIAN_BIG:
    case PWP_ENDIAN_LITTLE:
        break; // already set above
    default:
        ret = PWP_ENDIAN_ERROR;
        break;
    }
    return ret;
}


bool
PwpFile::needByteSwap(PWP_ENDIANNESS byteOrder)
{
    return getOsByteOrder() != mapToBigLittle(byteOrder);
}


bool
PwpFile::beginRecord() {
    return writer_ && writer_->beginRecord();
}


bool
PwpFile::beginRecord(PWP_UINT32 bytes, PWP_UINT32 count) {
    return writer_ && writer_->beginRecord(bytes, count);
}


bool
PwpFile::endRecord() {
    return writer_ && writer_->endRecord();
}


bool
PwpFile::write(PWP_INT64 val, const char *suffix, const char *prefix)
{
    return writer_ && writer_->write(val, suffix, prefix);
}


bool
PwpFile::write(PWP_INT32 val, const char *suffix, const char *prefix)
{
    return writer_ && writer_->write(val, suffix, prefix);
}


bool
PwpFile::write(PWP_INT16 val, const char *suffix, const char *prefix)
{
    return writer_ && writer_->write(val, suffix, prefix);
}


bool
PwpFile::write(PWP_INT8 val, const char *suffix, const char *prefix)
{
    return writer_ && writer_->write(val, suffix, prefix);
}


bool
PwpFile::write(PWP_UINT64 val, const char *suffix, const char *prefix)
{
    return writer_ && writer_->write(val, suffix, prefix);
}


bool
PwpFile::write(PWP_UINT32 val, const char *suffix, const char *prefix)
{
    return writer_ && writer_->write(val, suffix, prefix);
}


bool
PwpFile::write(PWP_UINT16 val, const char *suffix, const char *prefix)
{
    return writer_ && writer_->write(val, suffix, prefix);
}


bool
PwpFile::write(PWP_UINT8 val, const char *suffix, const char *prefix)
{
    return writer_ && writer_->write(val, suffix, prefix);
}


bool
PwpFile::write(PWP_FLOAT val, const char *suffix, const char *prefix)
{
    return writer_ && writer_->write(val, suffix, prefix);
}


bool
PwpFile::write(PWP_REAL val, const char *suffix, const char *prefix)
{
    return writer_ && writer_->write(val, suffix, prefix);
}


void
PwpFile::setFmtFieldSingle(const int width, const int prec)
{
    if (0 != writer_) {
        writer_->setFmtFieldSingle(width, prec);
    }
}


void
PwpFile::getFmtFieldSingle(int &width, int &prec) const
{
    if (0 != writer_) {
        writer_->getFmtFieldSingle(width, prec);
    }
}


void
PwpFile::setFmtFieldDouble(const int width, const int prec)
{
    if (0 != writer_) {
        writer_->setFmtFieldDouble(width, prec);
    }
}


void
PwpFile::getFmtFieldDouble(int &width, int &prec) const
{
    if (0 != writer_) {
        writer_->getFmtFieldDouble(width, prec);
    }
}



void
PwpFile::setFmtType(PwpWriterInterface::FormatType type)
{
    if (0 != writer_) {
        writer_->setFmtType(type);
    }
}


PwpWriterInterface::FormatType
PwpFile::getFmtType() const
{
    return writer_ ? writer_->getFmtType() : PwpWriterInterface::FormatG;
}


bool
PwpFile::write(const char * val, PWP_INT size, char pad)
{
    return writer_ && writer_->write(val, size, pad);
}


//***************************************************************************
//***************************************************************************
//***************************************************************************

PwpFileRecord::PwpFileRecord(PwpFile &file, bool doBeginRecord) :
    file_(file)
{
    if (doBeginRecord) {
        beginRecord();
    }
}


PwpFileRecord::PwpFileRecord(PwpFile &file, PWP_UINT32 bytes, PWP_UINT32 count) :
    file_(file)
{
    beginRecord(bytes, count);
}


PwpFileRecord::~PwpFileRecord()
{
    if (file_.isOpen()) {
        endRecord();
    }
}


bool
PwpFileRecord::beginRecord() {
    return file_.beginRecord();
}


bool
PwpFileRecord::beginRecord(PWP_UINT32 bytes, PWP_UINT32 count) {
    return file_.beginRecord(bytes, count);
}


bool
PwpFileRecord::endRecord() {
    return file_.endRecord();
}


bool
PwpFileRecord::write(PWP_INT64 val, const char *suffix,
    const char *prefix)
{
    return file_.write(val, suffix, prefix);
}


bool
PwpFileRecord::write(PWP_INT32 val, const char *suffix,
    const char *prefix)
{
    return file_.write(val, suffix, prefix);
}


bool
PwpFileRecord::write(PWP_INT16 val, const char *suffix,
    const char *prefix)
{
    return file_.write(val, suffix, prefix);
}


bool
PwpFileRecord::write(PWP_INT8 val, const char *suffix,
    const char *prefix)
{
    return file_.write(val, suffix, prefix);
}


bool
PwpFileRecord::write(PWP_UINT64 val, const char *suffix,
    const char *prefix)
{
    return file_.write(val, suffix, prefix);
}


bool
PwpFileRecord::write(PWP_UINT32 val, const char *suffix,
    const char *prefix)
{
    return file_.write(val, suffix, prefix);
}


bool
PwpFileRecord::write(PWP_UINT16 val, const char *suffix,
    const char *prefix)
{
    return file_.write(val, suffix, prefix);
}


bool
PwpFileRecord::write(PWP_UINT8 val, const char *suffix,
    const char *prefix)
{
    return file_.write(val, suffix, prefix);
}


bool
PwpFileRecord::write(PWP_FLOAT val, const char *suffix,
    const char *prefix)
{
    return file_.write(val, suffix, prefix);
}


bool
PwpFileRecord::write(PWP_REAL val, const char *suffix,
    const char *prefix)
{
    return file_.write(val, suffix, prefix);
}


void
PwpFileRecord::setFmtFieldSingle(const int width, const int prec)
{
    file_.setFmtFieldSingle(width, prec);
}


void
PwpFileRecord::getFmtFieldSingle(int &width, int &prec) const
{
    file_.getFmtFieldSingle(width, prec);
}


void
PwpFileRecord::setFmtFieldDouble(const int width, const int prec)
{
    file_.setFmtFieldDouble(width, prec);
}


void
PwpFileRecord::getFmtFieldDouble(int &width, int &prec) const
{
    file_.getFmtFieldDouble(width, prec);
}



void
PwpFileRecord::setFmtType(PwpWriterInterface::FormatType type)
{
    file_.setFmtType(type);
}


PwpWriterInterface::FormatType
PwpFileRecord::getFmtType() const
{
    return file_.getFmtType();
}


bool
PwpFileRecord::write(const char * val, PWP_INT size, char pad)
{
    return file_.write(val, size, pad);
}