pwpPlatform.cxx

Go to the documentation of this file.

/****************************************************************************
 *
 * runtime Plugin platform dependent function calls
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/
 
#include <cstdlib>
#include <memory>
#include <string.h>
#include <sys/stat.h>
#include <vector>
 
#if defined(WINDOWS)
#   include <io.h>
#   include <direct.h>
#   include <malloc.h>
#else
#   include <stdlib.h>
#endif // WINDOWS
 
// apiUtils.h included for ASSERT_COMPILE() macros.
// TODO: Consider isolating ASSERT macros to their own header "apiAssert.h"?
#include "apiUtils.h"
#include "pwpPlatform.h"
 
 
#if defined(WINDOWS)
 
#   define sysTextMode      't'
#   define sysBinaryMode    'b'
#   define sysFileno(fp)    _fileno(fp)
#   define sysFstat         _fstat64
#   define sysGetCwd()      ::_wgetcwd(0, FILENAME_MAX)
 
    using SysStatBuf    = struct _stat64;
    using DirUniquePtr  = std::unique_ptr<wchar_t, decltype(free)*>;
 
#else // *nix or mac
 
#   define sysTextMode      '\0'
#   define sysBinaryMode    'b'
#   define sysFileno(fp)    fileno(fp)
#   define sysFstat         fstat
#   define sysGetCwd()      ::getcwd(0, FILENAME_MAX)
 
    using SysStatBuf    = struct stat;
    using DirUniquePtr  = std::unique_ptr<char, decltype(free)*>;
 
#endif // WINDOWS
 
 
#define strOK(ss)       ((nullptr != ss) && ('\0' != ss[0]))
#define chrAPPEND(p,c)  ((nullptr != p) ? (*p++ = c) : 0)
 
#define isMODE(allBits,modeBits) (((allBits) & (modeBits)) == modeBits)
 
#if !defined(FILENAME_MAX)
#   define FILENAME_MAX   512
#endif
 
 
#ifdef WINDOWS
 
static wchar_t *
utf8ToU16(const char *s)
{
    wchar_t *result = 0;
    size_t element = 0;
    if (nullptr != s) {
        size_t len;
        len = ::strlen(s) + 1;
        result = (wchar_t *)::malloc(len * sizeof(wchar_t));
        //
        // UTF-8 is a specific scheme for mapping a sequence of 1-4 bytes to a
        // number from 0x000000 to 0x10FFFF:
        //
        // 00000000 -- 0000007F: 0xxxxxxx
        // 00000080 -- 000007FF: 110xxxxx 10xxxxxx
        // 00000800 -- 0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
        // 00010000 -- 001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
        //
        // where the x's are the bits to be extracted from the sequence and
        // combined to form the final value.
        //
        while ('\0' != *s) {
            unsigned char c = (unsigned char)*s;
            switch (0xF0 & c) {
            // No indicator, so just convert
            default:
                result[element] = (wchar_t)c;
                ++s;
                break;
            // Possible two byte utf8 character
            case 0xC0:
            case 0xD0:
                // Two byte character 110xxxxx 10xxxxxx
                if (0x80 == (*(s + 1) & 0xC0)) {
                    result[element] = (wchar_t)(
                        ((c & 0x1F) << 6) | (*(s + 1) & 0x3F));
                    s += 2;
                }
                // Doesn't have the second byte correct, so leave as is
                else {
                    result[element] = (wchar_t)c;
                    ++s;
                }
                break;
            // Possible three byte utf8 character
            case 0xE0:
                // Three byte character 1110xxxx 10xxxxxx 10xxxxxx
                if (0x80 == (*(s + 1) & 0xC0) && 0x80 == (*(s + 2) & 0xC0)) {
                    result[element] = (wchar_t)(((c & 0x0F) << 12) |
                        ((*(s + 1) & 0x3F) << 6) | (*(s + 2) & 0x3F));
                    s += 3;
                }
                // Doesn't have the second and third byte correct, so leave as
                // is
                else {
                    result[element] = (wchar_t)c;
                    ++s;
                }
                break;
            // Four byte case which can't be compressed into 16 bits, so just
            // convert the bytes as is
            case 0xF0:
                result[element] = (wchar_t)c;
                ++s;
                break;
            }
            ++element;
        }
    }
    else {
        result = (wchar_t *)::malloc(sizeof(wchar_t));
    }
    result[element] = 0;
    return result;
}
 
 
#ifdef NOT_NEEDED
static wchar_t *
utf8ToU16Old(const char *s)
{
    wchar_t *result = 0;
    size_t len;
    size_t element = 0;
    if (0 != s) {
        len = ::strlen(s) + 1;
        result = (wchar_t *)::malloc(len * sizeof(wchar_t));
        //
        // UTF-8 is a specific scheme for mapping a sequence of 1-4 bytes to a
        // number from 0x000000 to 0x10FFFF:
        //
        // 00000000 -- 0000007F: 0xxxxxxx
        // 00000080 -- 000007FF: 110xxxxx 10xxxxxx
        // 00000800 -- 0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
        // 00010000 -- 001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
        //
        // where the x's are the bits to be extracted from the sequence and
        // combined to form the final value.
        //
        while ('\0' != *s) {
            unsigned char c = (unsigned char)*s;
            // Not an encoded character.
            if (0xC0 > c) {
                result[element] = (wchar_t)c;
                ++s;
            }
            // Possible 2-byte utf-8 character
            else if (0xE0 > c) {
                // Two byte character 110xxxxx 10xxxxxx
                if (0x80 == (*(s + 1) & 0xC0)) {
                    result[element] = (wchar_t)(
                        (c & 0x1F) << 6 | (*(s + 1) & 0x3F));
                    s += 2;
                }
                // Doesn't have the second byte correct, so leave as is
                else {
                    result[element] = (wchar_t)c;
                    ++s;
                }
            }
            // Possible 3-byte utf-8 character
            else if (0xF0 > c) {
                // Three byte character 1110xxxx 10xxxxxx 10xxxxxx
                if (0x80 == (*(s + 1) & 0xC0) && 0x80 == (*(s + 2) & 0xC)) {
                    result[element] = (wchar_t)(((c & 0x0F) << 12) |
                        ((*(s + 1) & 0x3F) << 6) | (*(s + 2) & 0x3F));
                    s += 3;
                }
                // Doesn't have the second and third byte correct, so leave as
                // is
                else {
                    result[element] = (wchar_t)c;
                    ++s;
                }
            }
            // Can't convert a 4-byte sequence down to 16 bits so just treat
            // each byte as is
            else {
                result[element] = (wchar_t)c;
                ++s;
            }
            ++element;
        }
    }
    else {
        result = (wchar_t *)::malloc(sizeof(wchar_t));
    }
    result[element] = 0;
    return result;
}
#endif // NOT_NEEDED
 
 
// windows only overload
static int
pwpSetCurDir(const wchar_t *dir)
{
    return ((nullptr != dir) && (0 == ::_wchdir(dir))) ? 0 : -1;
}
 
#endif // WINDOWS
 
 
FILE *
pwpFileOpen(const char *filename, int mode)
{
    FILE *ret = 0;
    while (strOK(filename)) {
        char modeStr[4] = {0,0,0,0};
        char *p = modeStr;
        // get base mode
        if (isMODE(mode, pwpRead)) {
            chrAPPEND(p, 'r');
        }
        else if (isMODE(mode, pwpWrite)) {
            chrAPPEND(p, 'w');
        }
        else if (isMODE(mode, pwpAppend)) {
            chrAPPEND(p, 'a');
        }
        else {
            break; // error
        }
 
        // get extended mode
        if (isMODE(mode, pwpPlus_)) {
            chrAPPEND(p, '+');
        }
 
        // get format
        if (isMODE(mode, pwpBinary) || isMODE(mode, pwpUnformatted)) {
            chrAPPEND(p, sysBinaryMode);
        }
        else if (isMODE(mode, pwpFormatted) || isMODE(mode, pwpAscii)) {
            chrAPPEND(p, sysTextMode);
        }
        else {
            break; // error
        }
 
#ifdef WINDOWS
        DirUniquePtr wname{ utf8ToU16(filename), free };
        DirUniquePtr wmode{ utf8ToU16(modeStr), free };
        if (wname && wmode) {
            ret = ::_wfopen(wname.get(), wmode.get());
        }
        else {
            ret = 0;
        }
#else
        ret = fopen(filename, modeStr);
#endif // WINDOWS
        break; // force exit from while()
    }
    return ret;
}
 
 
int
pwpFileClose(FILE *fp)
{
    int ret = sysEOF;
    if (fp) {
        ret = fclose(fp);
    }
    return ret;
}
 
 
int
pwpFileEof(FILE *fp)
{
    return fp ? feof(fp) : 0;
}
 
 
int
pwpFileFlush(FILE *fp)
{
    return fp ? fflush(fp) : -1;
}
 
 
int
pwpFileGetpos(FILE *fp, sysFILEPOS *pos)
{
    int ret = -1;
    if (fp && pos) {
        ret = fgetpos(fp, pos);
    }
    return ret;
}
 
 
int
pwpFileSetpos(FILE *fp, const sysFILEPOS *pos)
{
    int ret = -1;
    if (fp && pos) {
        ret = fsetpos(fp, pos);
    }
    return ret;
}
 
 
int
pwpFileGetSize(FILE *fp, size_t *size)
{
    SysStatBuf buf;
    // make sure files over 2GB are supported
    ASSERT_COMPILE(sizeof(buf.st_size) == sizeof(size_t));
    int ret = 0;
    if (0 == fp || 0 == size) {
        ret = -1;
    }
    else if (0 != sysFstat(sysFileno(fp), &buf)) {
        *size = 0;
        ret = -1;
    }
    else {
        *size = (size_t)buf.st_size;
    }
    return ret;
}
 
 
int
pwpFilenameGetSize(const char *filename, size_t *size)
{
    int ret = 0;
    if (0 == filename || 0 == size) {
        ret = -1;
    }
    else {
#ifdef WINDOWS
        struct _stat64 buf;
        DirUniquePtr wname{ utf8ToU16(filename), free };
        if (nullptr == wname) {
            ret = -1;
        }
        else {
            if (0 != ::_wstat64(wname.get(), &buf)) {
                *size = 0;
                ret = -1;
            }
            else {
                *size = (size_t)buf.st_size;
            }
        }
#else
        struct stat buf;
        if (0 != stat(filename, &buf)) {
            *size = 0;
            ret = -1;
        }
        else {
            *size = (size_t)buf.st_size;
        }
#endif // WINDOWS
    }
    return ret;
}
 
 
size_t
pwpFileRead(void *buf, size_t size, size_t count, FILE *fp)
{
    size_t ret = 0;
    if (buf && size && count && fp) {
        ret = fread(buf, size, count, fp);
    }
    return ret;
}
 
 
size_t
pwpFileWrite(const void *buf, size_t size, size_t count, FILE *fp)
{
    size_t ret = 0;
    if (buf && size && count && fp) {
        ret = fwrite(buf, size, count, fp);
    }
    return ret;
}
 
 
size_t
pwpFileWriteStr(const char *str, FILE *fp)
{
    return str ? pwpFileWrite(str, strlen(str), 1, fp) : 0;
}
 
 
void
pwpFileRewind(FILE *fp)
{
    if (fp) {
        rewind(fp);
    }
}
 
 
int
pwpFileDelete(const char *filename)
{
    int ret = 0;
    if (strOK(filename)) {
#ifdef WINDOWS
        DirUniquePtr wname{ utf8ToU16(filename), free };
        if (nullptr == wname) {
            ret = -1;
        }
        else {
            ret = ::_wunlink(wname.get());
        }
#else
        ret = unlink(filename);
#endif // WINDOWS
    }
    return ret;
}
 
 
int
pwpSetCurDir(const char *dir)
{
#if defined(WINDOWS)
    return pwpSetCurDir(DirUniquePtr{ utf8ToU16(dir), free }.get());
#else
    return (nullptr != dir) ? chdir(dir) : -1;
#endif
}
 
 
int
pwpCwdPush(const char *dir)
{
    static std::vector<DirUniquePtr> dirStack;
    int ret = -1;
    if (strOK(dir)) {
        // sysGetCwd() returns a malloc()'ed buffer
        DirUniquePtr curDir{ sysGetCwd(), free };
        if ((nullptr != curDir) && (0 == pwpSetCurDir(dir))) {
            // Move curDir to dirStack so ~curDir will not free() it
            dirStack.push_back(std::move(curDir));
            ret = 0;
        }
        // ~curDir will free() ptr if not move()'ed above
    }
    else if (!dirStack.empty()) {
        // pop dir
        ret = pwpSetCurDir(dirStack.back().get());
        // ~DirUniquePtr() will free() ptr
        dirStack.pop_back();
    }
    return ret;
}
 
 
int
pwpCwdPop(void)
{
    return pwpCwdPush(nullptr);
}