Subversion Repositories forwardcom

/****************************  containers.cpp  **********************************
* Author:        Agner Fog
* Date created:  2006-07-15
* Last modified: 2018-03-30
* Version:       1.10
* Project:       Binary tools for ForwardCom instruction set
*
* This module contains container classes CMemoryBuffer and CFileBuffer for
* dynamic memory allocation and file read/write. See containers.h for
* further description.
*
* Copyright 2006-2020 GNU General Public License http://www.gnu.org/licenses
*****************************************************************************/
 
#include "stdafx.h"
 
// Names of file formats
SIntTxt FileFormatNames[] = {
    {FILETYPE_ELF,          "x86 ELF"},
    {FILETYPE_FWC,          "ForwardCom ELF"},
    {FILETYPE_ASM,          "assembly"},
    {FILETYPE_FWC_EXE,      "forwardCom executable"},
    {FILETYPE_FWC_LIB,      "forwardCom library"},
    {FILETYPE_LIBRARY,      "library"}
};
 
 
// Members of class CMemoryBuffer
 
// Constructor
CMemoryBuffer::CMemoryBuffer() {  
    buffer = 0;
    num_entries = data_size = buffer_size = 0;
}
 
// Destructor
CMemoryBuffer::~CMemoryBuffer() {
    clear();                                  // De-allocate buffer
}
 
// De-allocate buffer
void CMemoryBuffer::clear() {
    if (buffer) delete[] buffer;
    buffer = 0;
    num_entries = data_size = buffer_size = 0;
}
 
// Set all contents to zero without changing data size
void CMemoryBuffer::zero() {
    if (buffer) memset(buffer, 0, buffer_size);
}
 
void CMemoryBuffer::setSize(uint32_t size) {
    // Allocate, reallocate or deallocate buffer of specified size.
    // DataSize is initially zero. It is increased by push or pushString.
    // Setting size > dataSize will allocate more buffer and fill it with zeroes but not increase dataSize.
    // Setting size < dataSize will decrease dataSize so that some of the data are discarded.
    if (size < data_size) {
        // Request to delete some data
        data_size = size;
        if (size == 0) num_entries = 0;
        return;
    }
    if (size <= buffer_size) {
        // Request to reduce size but not delete it
        return;                                  // Ignore
    }
    size = (size + buffer_size + 15) & uint32_t(-16);   // Double size and round up to value divisible by 16
    int8_t * buffer2 = 0;                        // New buffer
    buffer2 = new int8_t[size];                  // Allocate new buffer
    if (buffer2 == 0) {err.submit(ERR_MEMORY_ALLOCATION); return;} // Error can't allocate
    memset (buffer2, 0, size);                   // Initialize to all zeroes
    if (buffer) {
        // A smaller buffer is previously allocated
        memcpy (buffer2, buffer, buffer_size);   // Copy contents of old buffer into new
        delete[] buffer;                         // De-allocate old buffer
    }
    buffer = buffer2;                            // Save pointer to buffer
    buffer_size = size;                          // Save size
}
 
void CMemoryBuffer::setDataSize(uint32_t size) {
    // Set data size and fill any new data with zeroes
    if (size > buffer_size) {
        setSize(size);
    }
    else if (size > data_size) {
        memset(buffer + data_size, 0, size - data_size);
    }
    data_size = size;
}
 
uint32_t CMemoryBuffer::push(void const * obj, uint32_t size) {
    // Add object to buffer, return offset
    // Parameters: 
    // obj = pointer to object, 0 if fill with zeroes
    // size = size of object to push
 
    // Old offset will be offset to new object
    uint32_t OldOffset = data_size;
 
    // New data size will be old data size plus size of new object
    uint32_t NewOffset = data_size + size;
 
    if (NewOffset > buffer_size) {
        // Buffer too small, allocate more space.
        // We can use SetSize for this only if it is certain that obj is not 
        // pointing to an object previously allocated in the old buffer
        // because it would be deallocated before copied into the new buffer:
        // SetSize (NewOffset + NewOffset / 2 + 1024);
 
        // Allocate more space without using SetSize:
        // Double the size + 1 kB, and round up size to value divisible by 16
        uint32_t NewSize = (NewOffset * 2 + 1024 + 15) & uint32_t(-16);
        int8_t * buffer2 = 0;                    // New buffer
        // Allocate new buffer
        buffer2 = new int8_t[NewSize];
        if (buffer2 == 0) {
            // Error can't allocate
            err.submit(ERR_MEMORY_ALLOCATION);  return 0;
        }
        // Initialize to all zeroes
        memset (buffer2, 0, NewSize);
        if (buffer) {
            // A smaller buffer is previously allocated
            // Copy contents of old buffer into new
            memcpy (buffer2, buffer, buffer_size);
        }
        buffer_size = NewSize;                   // Save size
        if (obj && size) {                         
            // Copy object to new buffer
            memcpy (buffer2 + OldOffset, obj, size);
            obj = 0;                             // Prevent copying once more
        }
        // Delete old buffer after copying object
        if (buffer) delete[] buffer;
 
        // Save pointer to new buffer
        buffer = buffer2;
    }
    // Copy object to buffer if nonzero
    if (obj && size) {
        memcpy (buffer + OldOffset, obj, size);
    }
    if (size) {
        // Adjust new offset
        data_size = NewOffset;
    }
    num_entries++;
 
    // Return offset to allocated object
    return OldOffset;
}
 
uint32_t CMemoryBuffer::pushString(char const * s) {
    // Add ASCIIZ string to buffer, return offset
    return push (s, uint32_t(strlen(s))+1);
}
 
uint32_t CMemoryBuffer::getLastIndex() const {
    // Index of last object pushed (zero-based)
    return num_entries - 1;
}
 
void CMemoryBuffer::align(uint32_t a) {
    // Align next entry to address divisible by a. must be a power of 2
    // uint32_t NewOffset = (data_size + a - 1) / a * a;   // use this if a is not a power of 2
    uint32_t NewOffset = (data_size + a - 1) & (-(int32_t)a);
    if (NewOffset > buffer_size) {
        // Allocate more space
        setSize (NewOffset + 2048);
    }
    // Set DataSize to after alignment space
    data_size = NewOffset;
}
 
// Make a copy of whole buffer
void CMemoryBuffer::copy(CMemoryBuffer const & b) {
    setSize(0);                                  // clear own buffer
    setSize(b.dataSize());                       // set new size
    memcpy(buffer, b.buf(), b.dataSize());       // copy data
    num_entries = b.numEntries();                // copy num_entries
    data_size = b.dataSize();                    // size used
}
 
// Members of class CFileBuffer
CFileBuffer::CFileBuffer() : CMemoryBuffer() {  
    // Default constructor
    fileType = wordSize = executable = 0;
}
 
void CFileBuffer::read(const char * filename, int ignoreError) {                   
    // Read file into buffer
    // InoreError: 0: abort on error, CMDL_FILE_IN_IF_EXISTS: ignore error, CMDL_FILE_SEARCH_PATH: search for file also in exe directory
    uint32_t status;                             // Error status
 
    const int MAXPATHL = 1024;  //!                 // Buffer for constructing file path
    char name[MAXPATHL];
#if defined (_WIN32) || defined (__WINDOWS__)
    const char slash[2] = "\\";  // path separator depends on operating system
#else
    const char slash[2] = "/";
#endif
 
#ifdef _MSC_VER  // Microsoft compiler prefers this:
 
    int fh;                                      // File handle
    fh = _open(filename, O_RDONLY | O_BINARY);   // Open file in binary mode
    if (fh == -1) {
        if (ignoreError == CMDL_FILE_SEARCH_PATH && strlen(cmd.programName) + strlen(filename) < MAXPATHL) {
            // Search for file in directory of executable file
            strcpy(name, cmd.programName);
            char *s1 = name, * s2;               // find last slash
            do {
                s2 = strchr(s1+1, slash[0]);
                if (s2) s1 = s2;  else *s1 = 0;
            } while(s2);
            strcat(name, slash);
            strcat(name, filename);
            fh = _open(name, O_RDONLY | O_BINARY); // Open file in binary mode
        }
        if (fh == -1) {
            // Cannot read file
            if (ignoreError != CMDL_FILE_IN_IF_EXISTS) err.submit(ERR_INPUT_FILE, filename); // Error. Input file must be read
            setSize(0); return;                  // Make empty file buffer
        }
    }
    data_size = _filelength(fh);                 // Get file size
    if (data_size <= 0) {
        if (ignoreError == 0) err.submit(ERR_FILE_SIZE, filename); // Wrong size
        return;}
    setSize(data_size + 2048);                   // Allocate buffer, 2k extra
    status = _read(fh, buf(), data_size);        // Read from file
    if (status != data_size) err.submit(ERR_INPUT_FILE, filename);
    status = _close(fh);                         // Close file
    if (status != 0) err.submit(ERR_INPUT_FILE, filename);
 
#else              // Works with most compilers:
 
    FILE * fh = fopen(filename, "rb");
    if (!fh) {
        // Cannot read file
        if (ignoreError == CMDL_FILE_SEARCH_PATH && strlen(cmd.programName) + strlen(filename) < MAXPATHL) {
            // Search for file in directory of executable file
            strcpy(name, cmd.programName);
            char *s1 = name, * s2;               // find last slash
            do {
                s2 = strchr(s1+1, slash[0]);
                if (s2) s1 = s2;  else *s1 = 0;
            } while(s2);
            strcat(name, slash);
            strcat(name, filename);
            fh = fopen(name, "rb");
        }
        if (!fh) {
            // Cannot read file
            if (ignoreError != CMDL_FILE_IN_IF_EXISTS) err.submit(ERR_INPUT_FILE, filename); // Error. Input file must be read
            setSize(0); return;                  // Make empty file buffer
        }
    }
    // Find file size
    fseek(fh, 0, SEEK_END);
    long int fsize = ftell(fh);
    if (fsize <= 0 && ignoreError == 0) {
        // File zero size
        err.submit(ERR_FILE_SIZE, filename); fclose(fh); return;
    }
    if ((unsigned long)fsize >= 0xFFFFFFFF) {
        // File too big 
        err.submit(ERR_FILE_SIZE, filename); fclose(fh); return;
    }
    data_size = (uint32_t)fsize;
    rewind(fh);
    // Allocate buffer
    setSize(data_size + 2048);                    // Allocate buffer, 2k extra
    // Read entire file
    status = (uint32_t)fread(buf(), 1, data_size, fh);
    if (status != data_size) err.submit(ERR_INPUT_FILE, filename);
    status = fclose(fh);
    if (status != 0) err.submit(ERR_INPUT_FILE, filename);
 
#endif
}
 
void CFileBuffer::write(const char * filename) {                  
    // Write buffer to file:
 
    // Two alternative ways to write a file:
 
#ifdef _MSC_VER    // Microsoft compiler prefers this:
 
    int fh;                                      // File handle
    uint32_t status;                             // Error status
    // Open file in binary mode
    fh = _open(filename, O_RDWR | O_BINARY | O_CREAT | O_TRUNC, _S_IREAD | _S_IWRITE); 
    // Check if error
    if (fh == -1) {err.submit(ERR_OUTPUT_FILE, filename);  return;}
    // Write file
    status = _write(fh, buf(), data_size);
    // Check if error
    if (status != data_size) err.submit(ERR_OUTPUT_FILE, filename);
    // Close file
    status = _close(fh);
    // Check if error
    if (status != 0) err.submit(ERR_OUTPUT_FILE, filename);
 
#else              // Works with most compilers:
 
    // Open file in binary mode
    FILE * ff = fopen(filename, "wb");
    // Check if error
    if (!ff) {err.submit(ERR_OUTPUT_FILE, filename);  return;}
    // Write file
    uint32_t n = (uint32_t)fwrite(buf(), 1, data_size, ff);
    // Check if error
    if (n != data_size) err.submit(ERR_OUTPUT_FILE, filename);
    // Close file
    n = fclose(ff);
    // Check if error
    if (n) {err.submit(ERR_OUTPUT_FILE, filename);  return;}
 
#endif
}
 
int CFileBuffer::getFileType() {
    // Detect file type
    //if (fileType) return fileType;             // Must re-evaluate fileType in case buffer is reused
    if (!data_size) return 0;                    // No file
    if (!buf()) return 0;                        // No contents
 
    //uint32_t namelen = fileName ? (uint32_t)strlen(fileName) : 0;
 
    //if (strncmp((char*)Buf(),ELFMAG,4) == 0) {
    if (get<uint32_t>(0) == ELFMAG) { 
        // ELF file
        fileType = FILETYPE_ELF;
        executable = get<ElfFwcEhdr>(0).e_type != ET_REL;
        switch (buf()[EI_CLASS]) {
        case ELFCLASS32:
            wordSize = 32; break;
        case ELFCLASS64:
            wordSize = 64; break;
        }
        machineType = get<ElfFwcEhdr>(0).e_machine;   // Copy file header.e_machine;
        if (machineType == EM_FORWARDCOM) fileType = FILETYPE_FWC;
    }
    else if (memcmp(buf(), archiveSignature, 8) == 0) {
        fileType = FILETYPE_LIBRARY;
    }
    else {
        // Unknown file type
        int utype = get<uint32_t>(0);        
       // err.submit(ERR_UNKNOWN_FILE_TYPE, utype, fileName); 
        err.submit(ERR_UNKNOWN_FILE_TYPE, utype, "!"); 
        fileType = 0;
    }
    return fileType;
}
 
 
char const * CFileBuffer::getFileFormatName(int FileType) {
    // Get name of file format type
    return Lookup (FileFormatNames, FileType);
}
 
 
void CFileBuffer::setFileType(int type) {
    // Set file format type
    fileType = type;
}
 
void CFileBuffer::reset() {
    // Set all members to zero
    clear();                                  // Deallocate memory buffer
    zeroAllMembers(*this);
}
 
void operator >> (CMemoryBuffer & a, CMemoryBuffer & b) {
    // Transfer ownership of buffer and other properties from a to b
    b.clear();                                   // De-allocate old buffer from target if it has one
    b.buffer = a.buffer;                         // Transfer buffer
    a.buffer = 0;                                // Remove buffer from source, so that buffer has only one owner
 
    // Copy properties
    b.data_size   = a.dataSize();                // Size of data, offset to vacant space
    b.buffer_size = a.bufferSize();              // Size of allocated buffer
    b.num_entries = a.numEntries();              // Number of objects pushed
    a.clear();                                   // Reset a's properties
}
 
void operator >> (CFileBuffer & a, CFileBuffer & b) {
    // Transfer ownership of buffer and other properties from a to b
    b.clear();                                   // De-allocate old buffer from target if it has one
    b.buffer = a.buffer;                         // Transfer buffer
    a.buffer = 0;                                // Remove buffer from source, so that buffer has only one owner
 
    // Copy properties
    b.data_size   = a.dataSize();                // Size of data, offset to vacant space
    b.buffer_size = a.bufferSize();              // Size of allocated buffer
    b.num_entries = a.numEntries();              // Number of objects pushed
    b.executable = a.executable;                 // File is executable
    b.machineType = a.machineType;               // Machine type
    if (a.wordSize) b.wordSize = a.wordSize;     // Segment word size (16, 32, 64)
    if (a.getFileType()) {
        b.fileType = a.getFileType();            // Object file type
    }
    a.clear();                                   // Reset a's properties
}
 
 
// Class CTextFileBuffer is used for building text files
// Constructor
CTextFileBuffer::CTextFileBuffer() {
    column = 0;
#ifdef _WIN32
    lineType = 0;                                // DOS/Windows type linefeed
#else
    lineType = 1;                                // Unix type linefeed
#endif
}
 
uint32_t CTextFileBuffer::put(const char * text) {
    // Write text string to buffer
    uint32_t len = (uint32_t)strlen(text);       // Length of text
    uint32_t ret = push(text, len);              // Add to buffer without terminating zero
    column += len;                               // Update column
    return ret;                                  // Return index
}
 
void CTextFileBuffer::put(const char character) {
    // Write single character to buffer
    push(&character, 1);                         // Add to buffer
    column ++;                                   // Update column
}
 
uint32_t CTextFileBuffer::putStringN(const char * s, uint32_t len) {
    // Write string to buffer, add terminating zero
    static const int8_t nul = 0;
    uint32_t retval = push(s, len);  
    push(&nul, 1);
    num_entries--;                               // compensate for pushing twice
    column += len + 1;
    return retval;
}
 
void CTextFileBuffer::newLine() {
    // Add linefeed
    if (lineType == 0) {
        push("\r\n", 2);                         // DOS/Windows style linefeed
    }
    else {
        push("\n", 1);                           // UNIX style linefeed
    }
    column = 0;                                  // Reset column
}
 
void CTextFileBuffer::tabulate(uint32_t i) {
    // Insert spaces until column i
    uint32_t j;
    if (i > column) {                            // Only insert spaces if we are not already past i
        for (j = column; j < i; j++) push(" ", 1); // Insert i - column spaces
        column = i;                              // Update column
    }
}
 
void CTextFileBuffer::putDecimal(int32_t x, int IsSigned) {
    // Write decimal number to buffer, unsigned or signed
    char text[16];
    sprintf(text, IsSigned ? "%i" : "%u", x);
    put(text);
}
 
void CTextFileBuffer::putHex(uint8_t x, int ox) {
    // Write hexadecimal 8 bit number to buffer
    // ox meaning: 1 = put 0x prefix, 2 = prefix zeroes to fixed length
    char text[16];
    sprintf(text, ox & 2 ? "%s%02X" : "%s%X", ox & 1 ? "0x" : "", x);
    put(text);
}
 
void CTextFileBuffer::putHex(uint16_t x, int ox) {
    // Write hexadecimal 16 bit number to buffer
    // ox meaning: 1 = put 0x prefix, 2 = prefix zeroes to fixed length
    char text[16];
    sprintf(text, ox & 2 ? "%s%04X" : "%s%X", ox & 1 ? "0x" : "", x);
    put(text);
}
 
void CTextFileBuffer::putHex(uint32_t x, int ox) {
    // Write hexadecimal 32 bit number to buffer
    // ox meaning: 1 = put 0x prefix, 2 = prefix zeroes to fixed length
    char text[16];
    sprintf(text, ox & 2 ? "%s%08X" : "%s%X", ox & 1 ? "0x" : "", x);
    put(text);
}
 
void CTextFileBuffer::putHex(uint64_t x, int ox) {
    // Write unsigned hexadecimal 64 bit number to buffer
    // ox meaning: 1 = put 0x prefix, 2 = prefix zeroes to fixed length
    char text[32];
    if (ox & 2) {  // Print all digits
        sprintf(text, "%s%08X%08X", ox & 1 ? "0x" : "", highDWord(x), uint32_t(x));
    }
    else { // Skip leading zeroes
        if (highDWord(x)) {
            sprintf(text, "%s%X%08X", ox & 1 ? "0x" : "", highDWord(x), uint32_t(x));
        }
        else {
            sprintf(text, "%s%X", ox & 1 ? "0x" : "", uint32_t(x));
        }
    }
    put(text);
}
 
void CTextFileBuffer::putFloat16(uint16_t x) {
    // Write half precision floating point number to buffer
    char text[32];
    sprintf(text, "%.3G", half2float(x));
    put(text);
}
 
 
void CTextFileBuffer::putFloat(float x) {
    // Write floating point number to buffer
    char text[64];
    sprintf(text, "%.7G", x);
    put(text);
}
 
void CTextFileBuffer::putFloat(double x) {
    // Write floating point number to buffer
    char text[64];
    sprintf(text, "%.12G", x);
    put(text);
}