/****************************  containers.cpp  **********************************
* Author:        Agner Fog
* Date created:  2006-07-15
* Last modified: 2016-07-07
* Project:       objconv
* Module:        containers.cpp
* Description:
* Objconv is a portable C++ program for converting object file formats.
* Compile for console mode on any platform.
*
* This module contains container classes CMemoryBuffer and CFileBuffer for
* dynamic memory allocation and file read/write. See containers.h for
* further description.
*
* Copyright 2006-2016 GNU General Public License http://www.gnu.org/licenses
*****************************************************************************/

#include "stdafx.h"

// Names of file formats
SIntTxt FileFormatNames[] = {
    {FILETYPE_COFF,         "COFF"},
    {FILETYPE_OMF,          "OMF"},
    {FILETYPE_ELF,          "ELF"},
    {FILETYPE_MACHO_LE,     "Mach-O Little Endian"},
    {FILETYPE_MACHO_BE,     "Mach-O Big Endian"},
    {FILETYPE_DOS,          "DOS executable"},
    {FILETYPE_WIN3X,        "Windows 3.x executable"},
    {FILETYPE_LIBRARY,      "Function library"},
    {FILETYPE_OMFLIBRARY,   "Function library (OMF)"},
    {IMPORT_LIBRARY_MEMBER, "Windows import library member"},
    {FILETYPE_MAC_UNIVBIN,  "MacIntosh universal binary"},   
    {FILETYPE_MS_WPO,       "Whole program optimization intermediate file, Microsoft specific"},
    {FILETYPE_INTEL_WPO,    "Whole program optimization intermediate file, Intel specific"},
    {FILETYPE_WIN_UNKNOWN,  "Unknown subtype, Windows"},   
    {FILETYPE_ASM,          "Disassembly"}
};


// Members of class CMemoryBuffer
CMemoryBuffer::CMemoryBuffer() {  
    // Constructor
    buffer = 0;
    NumEntries = DataSize = BufferSize = 0;
}

CMemoryBuffer::~CMemoryBuffer() {
    // Destructor
    SetSize(0);                         // De-allocate buffer
}

void CMemoryBuffer::SetSize(uint32 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.
    // Setting size = 0 will discard all data and de-allocate the buffer.
    if (size == 0) {
        // Deallocate
        if (buffer) delete[] buffer;     // De-allocate buffer
        buffer = 0;
        NumEntries = DataSize = BufferSize = 0;
        return;
    }
    if (size < DataSize) {
        // Request to delete some data
        DataSize = size;
        return;
    }
    if (size <= BufferSize) {
        // Request to reduce size but not delete it
        return;                          // Ignore
    }
//  size = (size + 15) & uint32(-16);   // Round up size to value divisible by 16
    size = (size + BufferSize + 15) & uint32(-16);   // Double size and round up to value divisible by 16
    int8 * buffer2 = 0;                 // New buffer
    buffer2 = new int8[size];           // Allocate new buffer
    if (buffer2 == 0) {err.submit(9006); return;} // Error can't allocate
    memset (buffer2, 0, size);          // Initialize to all zeroes
    if (buffer) {
        // A smaller buffer is previously allocated
        memcpy (buffer2, buffer, BufferSize); // Copy contents of old buffer into new
        delete[] buffer;                 // De-allocate old buffer
    }
    buffer = buffer2;                   // Save pointer to buffer
    BufferSize = size;                  // Save size
}

uint32 CMemoryBuffer::Push(void const * obj, uint32 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 OldOffset = DataSize;

    // New data size will be old data size plus size of new object
    uint32 NewOffset = DataSize + size;

    if (NewOffset > BufferSize) {
        // 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 NewSize = (NewOffset * 2 + 1024 + 15) & uint32(-16);
        int8 * buffer2 = 0;                        // New buffer
        // Allocate new buffer
        buffer2 = new int8[NewSize];
        if (buffer2 == 0) {
            // Error can't allocate
            err.submit(9006);  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, BufferSize);
        }
        BufferSize = 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
        DataSize = NewOffset;
        NumEntries++;
    }
    // Return offset to allocated object
    return OldOffset;
}

uint32 CMemoryBuffer::PushString(char const * s) {
    // Add ASCIIZ string to buffer, return offset
    return Push (s, uint32(strlen(s))+1);
}

uint32 CMemoryBuffer::GetLastIndex() {
    // Index of last object pushed (zero-based)
    return NumEntries - 1;
}

void CMemoryBuffer::SetDataSize(uint32 size) {
    if (size > BufferSize) {
        // Allocate more space
        SetSize(size + 2048);
    }
    // Set DataSize to after alignment space
    DataSize = size;
}

void CMemoryBuffer::Align(uint32 a) {
    // Align next entry to address divisible by a
    SetDataSize((DataSize + a - 1) / a * a);
}

// Members of class CFileBuffer
CFileBuffer::CFileBuffer() : CMemoryBuffer() {  
    // Default constructor
    FileName = 0;
    OutputFileName = 0;
    FileType = WordSize = Executable = 0;
}

CFileBuffer::CFileBuffer(char const * filename) : CMemoryBuffer() {  
    // Constructor
    FileName = filename;
    FileType = WordSize = 0;
}

void CFileBuffer::Read(int IgnoreError) {                   
    // Read file into buffer
    uint32 status;                             // Error status

#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) {
        // Cannot read file
        if (!IgnoreError) err.submit(2103, FileName); // Error. Input file must be read
        SetSize(0); return;                     // Make empty file buffer
    }
    DataSize = filelength(fh);                 // Get file size
    if (DataSize <= 0) {
        if (!IgnoreError) err.submit(2105, FileName); // Wrong size
        return;}
    SetSize(DataSize + 2048);                  // Allocate buffer, 2k extra
    status = _read(fh, Buf(), DataSize);       // Read from file
    if (status != DataSize) err.submit(2103, FileName);
    status = _close(fh);                       // Close file
    if (status != 0) err.submit(2103, FileName);

#else            // Works with most compilers:

    FILE * fh = fopen(FileName, "rb");
    if (!fh) {
        // Cannot read file
        if (!IgnoreError) err.submit(2103, 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 || (unsigned long)fsize >= 0xFFFFFFFF) {
        // File too big or zero size
        err.submit(2105, FileName); fclose(fh); return;
    }
    DataSize = (uint32)fsize;
    rewind(fh);
    // Allocate buffer
    SetSize(DataSize + 2048);                 // Allocate buffer, 2k extra
    // Read entire file
    status = (uint32)fread(Buf(), 1, DataSize, fh);
    if (status != DataSize) err.submit(2103, FileName);
    status = fclose(fh);
    if (status != 0) err.submit(2103, FileName);

#endif
}

void CFileBuffer::Write() {                  
    // Write buffer to file:
    if (OutputFileName) FileName = OutputFileName;
    // Two alternative ways to write a file:

#ifdef _MSC_VER       // Microsoft compiler prefers this:

    int fh;                                       // File handle
    uint32 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(2104, FileName);  return;}
    // Write file
    status = _write(fh, Buf(), DataSize);
    // Check if error
    if (status != DataSize) err.submit(2104, FileName);
    // Close file
    status = _close(fh);
    // Check if error
    if (status != 0) err.submit(2104, FileName);

#else                // Works with most compilers:

    // Open file in binary mode
    FILE * ff = fopen(FileName, "wb");
    // Check if error
    if (!ff) {err.submit(2104, FileName);  return;}
    // Write file
    uint32 n = (uint32)fwrite(Buf(), 1, DataSize, ff);
    // Check if error
    if (n != DataSize) err.submit(2104, FileName);
    // Close file
    n = fclose(ff);
    // Check if error
    if (n) {err.submit(2104, FileName);  return;}

#endif
}

int CFileBuffer::GetFileType() {
    // Detect file type
    if (FileType) return FileType;            // File type already known
    if (!DataSize) return 0;                  // No file
    if (!Buf()) return 0;                     // No contents

    uint32 namelen = FileName ? (uint32)strlen(FileName) : 0;

    if (strncmp(Buf(),"!<arch>",7) == 0) {
        // UNIX style library. Contains members of file type COFF, ELF or MACHO
        FileType = FILETYPE_LIBRARY;
    }
    else if (strncmp(Buf(),ELFMAG,4) == 0) {
        // ELF file
        FileType = FILETYPE_ELF;
        Executable = Get<Elf32_Ehdr>(0).e_type != ET_REL;
        switch (Buf()[EI_CLASS]) {
        case ELFCLASS32:
            WordSize = 32; break;
        case ELFCLASS64:
            WordSize = 64; break;
        }
    }
    else if (Get<uint32>(0) == MAC_MAGIC_32) {
        // Mach-O 32 little endian
        FileType = FILETYPE_MACHO_LE;
        WordSize = 32;
        Executable = Get<MAC_header_32>(0).filetype != MAC_OBJECT;
    }
    else if (Get<uint32>(0) == MAC_MAGIC_64) {
        // Mach-O 64 little endian
        FileType = FILETYPE_MACHO_LE;
        WordSize = 64;
        Executable = Get<MAC_header_64>(0).filetype != MAC_OBJECT;
    }
    else if (Get<uint32>(0) == MAC_CIGAM_32) {
        // Mach-O 32 big endian
        FileType = FILETYPE_MACHO_BE;
        WordSize = 32;
    }
    else if (Get<uint32>(0) == MAC_CIGAM_64) {
        // Mach-O 64 big endian
        FileType = FILETYPE_MACHO_BE;
        WordSize = 64;
    }
    else if (Get<uint32>(0) == MAC_CIGAM_UNIV) {
        // MacIntosh universal binary
        FileType = FILETYPE_MAC_UNIVBIN;
        WordSize = 0;
    }   
    else if (Get<uint32>(0) == 0xFFFF0000 || Get<uint32>(0) == 0x10000) {
        // Windows subtypes:
        if (Get<uint16>(4) == 0) {
            // This type only occurs when attempting to extract a member from an import library
            FileType = IMPORT_LIBRARY_MEMBER;
        }
        else if (Get<uint16>(4) == 1) {
            // Whole program optimization intermediate file for MS compiler. Undocumented
            FileType = FILETYPE_MS_WPO;
        }
        else {
            // Other subtypes not known
            FileType = FILETYPE_WIN_UNKNOWN;
        }
        // Get word size
        if (Get<uint16>(6) == PE_MACHINE_I386) {
            WordSize = 32;
        }
        else if (Get<uint16>(6) == PE_MACHINE_X8664) {
            WordSize = 64;
        }
        else {
            WordSize = 0;
        }
    }
    else if (Get<uint16>(0) == PE_MACHINE_I386) {
        // COFF/PE 32
        FileType = FILETYPE_COFF;
        WordSize = 32;
        Executable = (Get<SCOFF_FileHeader>(0).Flags & PE_F_EXEC) != 0;
    }
    else if (Get<uint16>(0) == PE_MACHINE_X8664) {
        // COFF64/PE32+
        FileType = FILETYPE_COFF;
        WordSize = 64;
        Executable = (Get<SCOFF_FileHeader>(0).Flags & PE_F_EXEC) != 0;
    }
    else if (Get<uint8>(0) == OMF_THEADR) {
        // OMF 16 or 32
        FileType = FILETYPE_OMF;
        // Word size can only be determined by searching through records in file:
        GetOMFWordSize(); // Determine word size
    }
    else if (Get<uint8>(0) == OMF_LIBHEAD) {
        // OMF Library 16 or 32
        FileType = FILETYPE_OMFLIBRARY;
    }
    else if ((Get<uint16>(0) & 0xFFF9) == 0x5A49) {
        // DOS file or file with DOS stub
        FileType = FILETYPE_DOS;
        WordSize = 16;
        Executable = 1;
        uint32 Signature = Get<uint32>(0x3C);
        if (Signature + 8 < DataSize) {
            if (Get<uint16>(Signature) == 0x454E) {
                // Windows 3.x file
                FileType = FILETYPE_WIN3X;
            }
            else if (Get<uint16>(Signature) == 0x4550) {
                // COFF file
                uint16 MachineType = Get<uint16>(Signature + 4);
                if (MachineType == PE_MACHINE_I386) {
                    FileType = FILETYPE_COFF;
                    WordSize = 32;
                }
                else if (MachineType == PE_MACHINE_X8664) {
                    FileType = FILETYPE_COFF;
                    WordSize = 64;
                }
            }
        }
    }
    else if (namelen > 4 && stricmp(FileName + namelen - 4, ".com") == 0) {
        // DOS .com file recognized only from its extension
        FileType = FILETYPE_DOS;
        WordSize = 16;  Executable = 1;
    }
    else if (Get<uint16>(0) == 0 && namelen > 4 && stricmp(FileName + namelen - 4, ".obj") == 0) {
        // Possibly alias record in COFF library
        FileType = FILETYPE_COFF;
        WordSize = 0;
        Executable = 0;
    }
    else {
        // Unknown file type
        int utype = Get<uint32>(0);        
        err.submit(2018, utype, FileName); 
        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
    SetSize(0);                          // Deallocate memory buffer
    memset(this, 0, sizeof(*this));
}

char * CFileBuffer::SetFileNameExtension(const char * f) {
    // Set file name extension according to FileType
    static char name[MAXFILENAMELENGTH+8];
    int i;

    if (strlen(f) > MAXFILENAMELENGTH) err.submit(2203, f);
    strncpy(name, f, MAXFILENAMELENGTH);

    // Search for last '.' in file name
    for (i = (int)strlen(name)-1; i > 0; i--) if (name[i] == '.') break;
    if (i < 1) {
        // '.' not found. Append '.' to name
        i = (int)strlen(name); if (i > MAXFILENAMELENGTH-4) i = MAXFILENAMELENGTH-4;
    }
    // Get default extension
    if (cmd.OutputType == FILETYPE_ASM) {
        strcpy(name+i, ".asm"); // Assembly file
    }
    else if (cmd.OutputType == FILETYPE_COFF || cmd.OutputType == FILETYPE_OMF) {
        if ((FileType & (FILETYPE_LIBRARY | FILETYPE_OMFLIBRARY)) || (cmd.LibraryOptions & CMDL_LIBRARY_ADDMEMBER)) {
            strcpy(name+i, ".lib"); // Windows function library
        }
        else {
            strcpy(name+i, ".obj"); // Windows object file
        }
    }
    else { // output type is ELF or MACHO
        if ((FileType & (FILETYPE_LIBRARY | FILETYPE_OMFLIBRARY)) || (cmd.LibraryOptions & CMDL_LIBRARY_ADDMEMBER)) {
            strcpy(name+i, ".a");   // Linux/BSD/Mac function library
        }
        else {
            strcpy(name+i, ".o");   // Linux/BSD/Mac object file
        }
    }
    return name;
}

void CFileBuffer::CheckOutputFileName() {
    // Make output file name or check that requested name is valid
    if (!(cmd.FileOptions & CMDL_FILE_OUTPUT)) return;

    OutputFileName = cmd.OutputFile;
    if (OutputFileName == 0) {
        // Output file name not specified. Make filename
        OutputFileName = cmd.OutputFile = SetFileNameExtension(FileName);
    }
    if (strcmp(FileName,OutputFileName) == 0 && !(cmd.FileOptions & CMDL_FILE_IN_OUT_SAME)) {
        // Input and output files have same name
        err.submit(2005, FileName);
    }
}

void operator >> (CFileBuffer & a, CFileBuffer & b) {
    // Transfer ownership of buffer and other properties from a to b
    b.SetSize(0);                            // 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.DataSize   = a.GetDataSize();          // Size of data, offset to vacant space
    b.BufferSize = a.GetBufferSize();        // Size of allocated buffer
    b.NumEntries = a.GetNumEntries();        // Number of objects pushed
    b.Executable = a.Executable;             // File is executable
    if (a.WordSize) b.WordSize = a.WordSize; // Segment word size (16, 32, 64)
    if (a.FileName) b.FileName = a.FileName; // Name of input file
    if (a.OutputFileName) b.OutputFileName = a.OutputFileName;// Name of output file
    if (a.GetFileType())  b.FileType = a.GetFileType();       // Object file type
    a.SetSize(0);                            // Reset a's properties
}

void CFileBuffer::GetOMFWordSize() {
    // Determine word size for OMF file.
    // There is no simple way to get the word size. Looking for odd-numbered
    // record types is not sufficient. A 32-bit OMF file may use 16-bit SEGDEF 
    // records. We have to look for segments with the 'P' attribute set. And
    // even this is not completely safe, because MASM may generate empty 32-bit
    // segments so we have to look only at segments with nonzero size. 
    // We can still have any mixture of 16- and 32-bit segments, though, so no
    // method is absolutely safe.

    // We have to parse through all records in file buffer
    uint8  RecordType;                            // Type of current record
    uint32 RecordStart;                           // Index to start of current record
    uint32 RecordEnd;                             // Index to end of current record
    uint32 RecordLength;                          // Length of current record
    uint32 Index = 0;                             // Current offset from buffer while reading
    OMF_SAttrib SegAttr;                          // Segment attributed
    uint32 SegLength;                             // Segment length

    WordSize = 16;                                // WordSize = 16 if no 32 bit records found

    while (Index < GetDataSize()) {
        RecordStart = Index;                       // Record starts here
        RecordType = Get<uint8>(Index++);          // Get first byte of record = type
        RecordLength = Get<uint16>(Index);         // Next two bytes = length
        Index += 2;
        RecordEnd = RecordStart + RecordLength + 3;// End of record
        if (RecordEnd > GetDataSize()) {
            // Record goes beyond end of file
            err.submit(2301);  break;
        }
        if ((RecordType & 1) && RecordType < OMF_LIBHEAD) { // Odd-numbered type means 32 bit
            WordSize = 32;                                   // ..but this method is not safe
        }
        if ((RecordType & 0xFE) == OMF_SEGDEF) {   // Segment definition record
            SegAttr.b = Get<uint8>(Index++);        // Get segment attributes
            if (SegAttr.u.A == 0) {
                // Frame and Offset only included if A = 0
                Index += 2+1;
            }
            SegLength = (RecordType & 1) ? Get<uint32>(Index) : Get<uint16>(Index); // Segment length

            if (SegAttr.u.P && SegLength) {         // if segment has P attribute and nonzero length
                WordSize = 32;                       // .. then it is a 32-bit segment
            }
        }
        Index = RecordEnd;                         // Point to next record
    }
}


// Class CTextFileBuffer is used for building text files
// Constructor
CTextFileBuffer::CTextFileBuffer() {
    column = 0;
    // Use UNIX linefeeds only if GASM output
    LineType = (cmd.SubType == SUBTYPE_GASM) ? 1 : 0;
}

void CTextFileBuffer::Put(const char * text) {
    // Write text string to buffer
    uint32 len = (uint32)strlen(text);            // Length of text
    Push(text, len);                              // Add to buffer without terminating zero
    column += len;                                // Update column
}

void CTextFileBuffer::Put(const char character) {
    // Write single character to buffer
    Push(&character, 1);                          // Add to buffer
    column ++;                                    // Update column
}

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 i) {
    // Insert spaces until column i
    uint32 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 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 x, int MasmForm) {
    // Write hexadecimal 8 bit number to buffer
    // If MasmForm >= 1 then the function will write the number in a
    // way that can be read by the assembler, e.g. 0FFH or 0xFF
    char text[16];
    if (MasmForm && cmd.SubType == SUBTYPE_GASM) {
        // Needs 0x prefix
        sprintf(text, "0x%02X", x);
        Put(text);
        return;
    }
    if (MasmForm && x >= 0xA0) {
        Put("0");                                  // Make sure it doesn't begin with a letter
    }
    sprintf(text, "%02X", x);
    Put(text);
    if (MasmForm) Put("H");
}

void CTextFileBuffer::PutHex(uint16 x, int MasmForm) {
    // Write hexadecimal 16 bit number to buffer
    // If MasmForm >= 1 then the function will write the number in a
    // way that can be read by the assembler, e.g. 0FFH or 0xFF
    // If MasmForm == 2 then leading zeroes are stripped
    char text[16];
    if (MasmForm && cmd.SubType == SUBTYPE_GASM) {
        // Needs 0x prefix
        sprintf(text, MasmForm==1 ? "0x%04X" : "0x%X", x);
        Put(text);
        return;
    }
    sprintf(text, (MasmForm < 2) ? "%04X" : "%X", x);
    // Check if leading zero needed
    if (MasmForm && text[0] > '9') {
        Put("0");                                  // Leading zero needed
    }
    Put(text);
    if (MasmForm) Put("H");
}

void CTextFileBuffer::PutHex(uint32 x, int MasmForm) {
    // Write hexadecimal 32 bit number to buffer
    // If MasmForm >= 1 then the function will write the number in a
    // way that can be read by the assembler, e.g. 0FFH or 0xFF
    // If MasmForm == 2 then leading zeroes are stripped
    char text[16];
    if (MasmForm && cmd.SubType == SUBTYPE_GASM) {
        // Needs 0x prefix
        sprintf(text, MasmForm==1 ? "0x%08X" : "0x%X", x);
        Put(text);
        return;
    }

    sprintf(text, (MasmForm < 2) ? "%08X" : "%X", x);
    // Check if leading zero needed
    if (MasmForm && text[0] > '9') {
        Put("0");                                  // Leading zero needed
    }
    Put(text);
    if (MasmForm) Put("H");
}

void CTextFileBuffer::PutHex(uint64 x, int MasmForm) {
    // Write unsigned hexadecimal 64 bit number to buffer
    // If MasmForm >= 1 then the function will write the number in a
    // way that can be read by the assembler, e.g. 0FFH or 0xFF
    // If MasmForm == 2 then leading zeroes are stripped
    char text[32];
    if (MasmForm < 2) {  // Print all digits
        sprintf(text, "%08X%08X", HighDWord(x), uint32(x));
    }
    else { // Skip leading zeroes
        if (HighDWord(x)) {
            sprintf(text, "%X%08X", HighDWord(x), uint32(x));
        }
        else {
            sprintf(text, "%X", uint32(x));
        }
    }
    if (MasmForm) {
        if (cmd.SubType == SUBTYPE_GASM) {
            // Needs 0x prefix
            Put("0x");
            Put(text);
        }
        else {
            // use 0FFH form
            if (text[0] > '9')  Put("0");           // Leading zero needed
            Put(text);
            Put("H");
        }
    }
    else {
        // write hexadecimal number only
        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, "%.16G", x);
    Put(text);
}