/****************************  cmdline.cpp  **********************************
* Author:        Agner Fog
* Date created:  2006-07-25
* Last modified: 2018-01-29
* Project:       objconv
* Module:        cmdline.cpp
* Description:
* This module is for interpretation of command line options
* Also contains symbol change function
*
* Copyright 2006-2018 GNU General Public License http://www.gnu.org/licenses
*****************************************************************************/

#include "stdafx.h"

// List of recognized output file type options
static SIntTxt TypeOptionNames[] = {
    {CMDL_OUTPUT_ELF,   "elf"},
    {CMDL_OUTPUT_PE,    "pe"},
    {CMDL_OUTPUT_PE,    "coff"},
    {CMDL_OUTPUT_PE,    "cof"},
    {CMDL_OUTPUT_PE,    "win"},
    {CMDL_OUTPUT_OMF,   "omf"},
    {CMDL_OUTPUT_MACHO, "mac"},
    {CMDL_OUTPUT_MACHO, "macho"},
    {CMDL_OUTPUT_MACHO, "mach-o"},
    {CMDL_OUTPUT_MACHO, "mach"},
    {CMDL_OUTPUT_MASM,  "asm"},
    {CMDL_OUTPUT_MASM,  "masm"},
    {CMDL_OUTPUT_MASM,  "tasm"},
    {CMDL_OUTPUT_MASM,  "nasm"},
    {CMDL_OUTPUT_MASM,  "yasm"},
    {CMDL_OUTPUT_MASM,  "gasm"},
    {CMDL_OUTPUT_MASM,  "gas"}
};

// List of subtype names
static SIntTxt SubtypeNames[] = {
    {SUBTYPE_MASM,  "asm"},
    {SUBTYPE_MASM,  "masm"},
    {SUBTYPE_MASM,  "tasm"},
    {SUBTYPE_YASM,  "nasm"},
    {SUBTYPE_YASM,  "yasm"},
    {SUBTYPE_GASM,  "gasm"},
    {SUBTYPE_GASM,  "gas"}
};

// List of standard names that are always translated
const uint32 MaxType = FILETYPE_MACHO_LE;

// Standard names in 32-bit mode
const char * StandardNames32[][MaxType+1] = {
    //  0,    COFF,          OMF,           ELF,                MACHO
    {0,"___ImageBase","___ImageBase","__executable_start","__mh_execute_header"}
};

// Standard names in 64-bit mode
// COFF removes an underscore in 32-bit. There is no 64-bit OMF 
const char * StandardNames64[][MaxType+1] = {
    //  0,    COFF,       OMF,         ELF,                MACHO
    {0,"__ImageBase",  "",    "__executable_start","__mh_execute_header"}
};

const int NumStandardNames = sizeof(StandardNames32) / sizeof(StandardNames32[0]);


// Command line interpreter
CCommandLineInterpreter cmd;                  // Instantiate command line interpreter

CCommandLineInterpreter::CCommandLineInterpreter() {
    // Default constructor
    memset(this, 0, sizeof(*this));            // Set all to zero
    Verbose        = CMDL_VERBOSE_YES;         // How much diagnostics to print on screen
    DumpOptions    = DUMP_NONE;                // Dump options
    DebugInfo      = CMDL_DEBUG_DEFAULT;       // Strip or convert debug info
    ExeptionInfo   = CMDL_EXCEPTION_DEFAULT;   // Strip or preserve exception handling info
    SegmentDot     = CMDL_SECTIONDOT_NOCHANGE; // Change underscore/dot in beginning of segment names
    Underscore     = CMDL_UNDERSCORE_NOCHANGE; // Add/remove underscores in symbol names
    LibraryOptions = CMDL_LIBRARY_DEFAULT;     // Library options
}


CCommandLineInterpreter::~CCommandLineInterpreter() { // Destructor
}


void CCommandLineInterpreter::ReadCommandLine(int argc, char * argv[]) {

    // Read command line
    for (int i = 1; i < argc; i++) {
        ReadCommandItem(argv[i]);
    }
    if (ShowHelp || (InputFile == 0 && OutputFile == 0) /* || !OutputType */) {
        // No useful command found. Print help
        Help();  ShowHelp = 1;
        return;
    }
    // Check file options
    FileOptions = CMDL_FILE_INPUT;
    if (LibraryOptions == CMDL_LIBRARY_ADDMEMBER) {
        // Adding object files to library. Library may not exist
        FileOptions = CMDL_FILE_IN_IF_EXISTS;
    }
    if (DumpOptions || ((LibraryOptions & CMDL_LIBRARY_EXTRACTMEM) && !(LibraryOptions & CMDL_LIBRARY_ADDMEMBER))) {
        // Dumping or extracting. Output file not used
        if (OutputFile) err.submit(1103); // Output file name ignored
        OutputFile = 0;
    }
    else {
        // Output file required
        FileOptions |= CMDL_FILE_OUTPUT;
    }
    if ((LibraryOptions & CMDL_LIBRARY_ADDMEMBER) && !(LibraryOptions & CMDL_LIBRARY_CONVERT)) {
        // Adding library members only. Output file may have same name as input file
        FileOptions |= CMDL_FILE_IN_OUT_SAME;
    }
    // Check output type
    if (!OutputType) {
        // Output type not defined yet
        if (LibraryOptions & (CMDL_LIBRARY_CONVERT | CMDL_LIBRARY_ADDMEMBER)) {
            OutputType = FILETYPE_LIBRARY;
        }
    }
}


void CCommandLineInterpreter::ReadCommandItem(char * string) {
    // Read one option from command line
    // Skip leading whitespace
    while (*string != 0 && *string <= ' ') string++;
    if (*string == 0) return;  // Empty string

    // Look for option prefix and response file prefix
    const char OptionPrefix1 = '-';  // Option must begin with '-'
#if defined (_WIN32) || defined (__WINDOWS__)
    const char OptionPrefix2 = '/';  // '/' allowed instead of '-' in Windows only
#else
    const char OptionPrefix2 = '-';
#endif
    const char ResponseFilePrefix = '@';  // Response file name prefixed by '@'
    if (*string == OptionPrefix1 || *string == OptionPrefix2) {
        // Option prefix found. This is a command line option
        InterpretCommandOption(string+1);
    }
    else if (*string == ResponseFilePrefix) {
        // Response file prefix found. Read more options from response file
        ReadCommandFile(string+1);
    }
    else {
        // No prefix found. This is an input or output file name
        InterpretFileName(string);
    }

    int loc, last = SymbolList.GetNumEntries() - 1;
    if (last > 0) {
        // relocate last entry (binary insertion sort):
        SSymbolChange * List = (SSymbolChange *)SymbolList.Buf();
        SSymbolChange key = List[last];
        SymbolBinSearch(key.Name1, last, &loc);
        memmove(List + loc + 1, List + loc, (last - loc) * sizeof(SSymbolChange));
        List[loc] = key;
    }
}


void CCommandLineInterpreter::ReadCommandFile(char * filename) {
    // Read commands from file
    if (*filename <= ' ') {
        err.submit(1001); return;    // Warning: empty filename
    }

    // Check if too many response file buffers (possibly because file includes itself)
    if (++NumBuffers > MAX_COMMAND_FILES) {err.submit(2107); return;}

    // Allocate buffer for response files.
    if (ResponseFiles.GetNumEntries() == 0) {
        ResponseFiles.SetNum(MAX_COMMAND_FILES);
        ResponseFiles.SetZero();
    }

    // Read response file into new buffer
    ResponseFiles[NumBuffers-1].FileName = filename;
    ResponseFiles[NumBuffers-1].Read();

    // Get buffer with file contents
    char * buffer = ResponseFiles[NumBuffers-1].Buf();
    char * ItemBegin, * ItemEnd;  // Mark begin and end of token in buffer

    // Check if buffer is allocated
    if (buffer) {

        // Parse contents of response file for tokens
        while (*buffer) {

            // Skip whitespace
            while (*buffer != 0 && uint8(*buffer) <= uint8(' ')) buffer++;
            if (*buffer == 0) break; // End of buffer found
            ItemBegin = buffer;

            // Find end of token
            ItemEnd = buffer+1;
            while (uint8(*ItemEnd) > uint8(' ')) ItemEnd++;
            if (*ItemEnd == 0) {
                buffer = ItemEnd;
            }
            else {
                buffer = ItemEnd + 1;
                *ItemEnd = 0;    // Mark end of token
            }
            // Found token. 
            // Check if it is a comment beginning with '#' or '//'
            if (ItemBegin[0] == '#' || (ItemBegin[0] == '/' && ItemBegin[1] == '/' )) {
                // This is a comment. Skip to end of line
                ItemEnd = buffer;
                while (*ItemEnd != 0 && *ItemEnd != '\n') {
                    ItemEnd++;
                }
                if (*ItemEnd == 0) {
                    buffer = ItemEnd;
                }
                else {
                    buffer = ItemEnd + 1;
                }
                continue;
            }
            // Not a comment. Interpret token
            ReadCommandItem(ItemBegin);
        }
    }
}


void CCommandLineInterpreter::InterpretFileName(char * string) {
    // Interpret input or output filename from command line

    switch (libmode) {
    case 1:            // First filename after -lib = inputfile and outputfile
        InputFile = string;
        libmode = 2;
        return;

    case 2:            // Second or later filename after -lib = object file to add to library
        AddObjectToLibrary(string, string);
        return;
    }
    // libmode = 0: Ordinary input or output file

    if (!InputFile) {
        // Input file not specified yet
        InputFile = string;
    }
    else if (!OutputFile) {
        // Output file not specified yet
        OutputFile = string;
    }
    else {
        // Both input and output files already specified
        err.submit(2001);
    }
}


void CCommandLineInterpreter::InterpretCommandOption(char * string) {
    // Interpret one option from command line
    if (*string <= ' ') {
        err.submit(1001); return;    // Warning: empty option
    }

    // Detect option type
    switch(string[0]) {
    case 'f': case 'F':   // output file format
        if (string[1] == 'd') {
            // -fd == deprecated dump option
            InterpretDumpOption(string+2);  break;
        }
        InterpretOutputTypeOption(string+1);  break;

    case 'v': case 'V':   // verbose/silent
        InterpretVerboseOption(string+1);  break;

    case 'd': case 'D':   // dump option
        InterpretDumpOption(string+1);  break;
        // Debug info option
        //InterpretDebugInfoOption(string+1);  break;

    case 'x': case 'X':   // Exception handler info option
        InterpretExceptionInfoOption(string+1);  break;

    case 'h': case 'H': case '?':  // Help
        ShowHelp = 1;  break;

    case 'e': case 'E':   // Error option
    case 'w': case 'W':   // Warning option
        InterpretErrorOption(string);  break;

    case 'n': case 'N':   // Symbol name change option
    case 'a': case 'A':   // Symbol name alias option
        InterpretSymbolNameChangeOption(string);  break;

    case 'i': case 'I':   // Imagebase
        if ((string[1] | 0x20) == 'm') {
            InterpretImagebaseOption(string);
        }
        break;

    case 'l': case 'L':   // Library option
        InterpretLibraryOption(string);  break;

    case 'c':  // Count instruction codes supported
        // This is an easter egg: You can only get it if you know it's there
        if (strncmp(string,"countinstructions", 17) == 0) {
            CDisassembler::CountInstructions();
            exit(0);
        }

    default:    // Unknown option
        err.submit(1002, string);
    }
}


void CCommandLineInterpreter::InterpretLibraryOption(char * string) {
    // Interpret options for manipulating library/archive files

    // Check for -lib command
    if (stricmp(string, "lib") == 0) {  // Found -lib command
        if (InputFile) {
            libmode = 2;                  // Input file already specified. Remaining file names are object files to add
        }
        else {
            libmode = 1;                  // The rest of the command line must be interpreted as library name and object file names
        }
        return;
    }

    SSymbolChange sym = {0,0,0,0};      // Symbol change record
    int i;                              // Loop counter

    // Check for member name and optional new name in this command
    char * name1 = 0, * name2 = 0, separator;
    if ((string[2] == ':' || string[2] == '|') && string[3]) {
        // name1 found
        separator = string[2];
        name1 = string+3;
        // Search for second separator or end
        name2 = name1 + 1;
        while (name2[0] != 0) {
            if (name2[0] == separator) {
                *name2 = 0;  // Mark end of name1
                if (name2[1]) {
                    // name2 found
                    name2++;     // Name2 starts here
                    break;
                }
            }
            name2++;
        }
        if (name2 == 0 || name2[0] == 0 || name2[0] == separator) {
            // name 2 is blank
            //name2 = name1;
            name2 = 0;
        }
        else {
            // Check if name2 ends with separator
            for (i = 0; i < (int)strlen(name2); i++) {
                if (name2[i] == separator) name2[i] = 0;
            }
        }
    }
    // Check for duplicate name
    if (SymbolIsInList(name1)) {
        // This symbol is already in list
        err.submit(2017, name1);
        return;
    }

    sym.Name1 = name1;     // Store names in symbol change record
    sym.Name2 = name2;     

    switch (string[1]) {
    case 'a': case 'A':      // Add input file to library
        if (name1) {
            AddObjectToLibrary(name1, name2);
        }
        else err.submit(2004, string);
        break;

    case 'x': case 'X':      // Extract member(s) from library
        if (name1) {
            // Extract specified member
            cmd.LibraryOptions = CMDL_LIBRARY_EXTRACTMEM;
            sym.Action  = SYMA_EXTRACT_MEMBER;
            SymbolList.Push(&sym, sizeof(sym));
        }
        else {
            // Extract all members
            cmd.LibraryOptions = CMDL_LIBRARY_EXTRACTALL;
        }
        break;

    case 'd': case 'D':  // Delete member from library
        if (name1) {
            // Delete specified member
            cmd.LibraryOptions = CMDL_LIBRARY_CONVERT;
            sym.Action  = SYMA_DELETE_MEMBER;
            SymbolList.Push(&sym, sizeof(sym));
        }
        else err.submit(2004, string);
        break;

    case 's': case 'S':  // Use short member names for compatibility
        cmd.LibrarySubtype = LIBTYPE_SHORTNAMES;
        break;

    default:
        err.submit(2004, string);  // Unknown option
    }
}


void CCommandLineInterpreter::AddObjectToLibrary(char * filename, char * membername) {
    // Add object file to library 
    if (!filename || !*filename) {          
        err.submit(2004, filename-1);  return;     // Empty string
    }

    if (!membername || !*membername) membername = filename;

    SSymbolChange Sym = {0,0,0,0};                // Symbol change record

    Sym.Name2 = filename;                         // Object file name

    if (!MemberNamesAllocated) {
        // Allocate space for truncated member names
        const int SafetySpace = 1024;

        // Get size of response files
        if (ResponseFiles.GetNumEntries()) {
            MemberNamesAllocated = ResponseFiles[0].GetDataSize() + ResponseFiles[1].GetDataSize();
        }
        // Allocate this size + SafetySpace
        MemberNames.SetSize(MemberNamesAllocated + SafetySpace);

        // Remember allocated buffer size
        MemberNamesAllocated = MemberNames.GetBufferSize();
    }

    // Truncate name and store it in MemberNames
    //uint32 Name1Offset = MemberNames.PushString(CLibrary::TruncateMemberName(membername));
    uint32 Name1Offset = MemberNames.PushString(membername);   
    Sym.Name1 = (char*)(MemberNames.Buf() + Name1Offset);
    CLibrary::StripMemberName(Sym.Name1);

    // Note: Sym.Name1 points to allocated memory in violation of good programming practice.
    // Check that it is not reallocated:
    if (MemberNames.GetBufferSize() != MemberNamesAllocated) {
        err.submit(2506); // Cannot reallocate MemberNames because we have pointers to in in SymbolList
        return;
    }

    // Check for duplicate name
    if (SymbolIsInList(Sym.Name1)) {
        // This symbol is already in list
        err.submit(2017, Sym.Name1);
        return;
    }

    // Store options
    cmd.LibraryOptions |= CMDL_LIBRARY_ADDMEMBER;
    Sym.Action  = SYMA_ADD_MEMBER;

    // Store SYMA_ADD_MEMBER record in symbol list
    SymbolList.Push(&Sym, sizeof(Sym));
}


void CCommandLineInterpreter::InterpretOutputTypeOption(char * string) {
    // Interpret output file format option from command line

    int opt;
    for (opt = 0; opt < TableSize(TypeOptionNames); opt++) {
        int len = (int)strlen(TypeOptionNames[opt].b);
        if (strncmp(string, TypeOptionNames[opt].b, len) == 0) {
            // Match found
            if (OutputType)  err.submit(2003, string);  // More than one output type specified
            if (DumpOptions) err.submit(2007);          // Both dump and convert specified

            // Save desired output type
            OutputType = TypeOptionNames[opt].a;

            // Check if name is followed by a word size
            int wordsize = 0;
            if (string[len]) wordsize = atoi(string+len);
            switch (wordsize) {
            case 0:  // No word size specified
                break;

            case 32: case 64:  // Valid word size
                DesiredWordSize = wordsize;
                break;

            default:  // Illegal word size
                err.submit(2002, wordsize);
            }
            break;   // Finished searching
        }
    }

    // Check if found
    if (opt >= TableSize(TypeOptionNames)) err.submit(2004, string-1);

    if (OutputType == CMDL_OUTPUT_MASM) {
        // Get subtype
        for (opt = 0; opt < TableSize(SubtypeNames); opt++) {
            int len = (int)strlen(SubtypeNames[opt].b);
            if (strncmp(string, SubtypeNames[opt].b, len) == 0) {
                // Match found
                SubType = SubtypeNames[opt].a;  break;
            }
        }
    }
}


void CCommandLineInterpreter::InterpretVerboseOption(char * string) {
    // Interpret silent/verbose option from command line
    Verbose = atoi(string);
}


void CCommandLineInterpreter::InterpretDumpOption(char * string) {
    // Interpret dump option from command line
    if (OutputType || DumpOptions) err.submit(2007);          // Both dump and convert specified

    char * s1 = string;
    while (*s1) {
        switch (*(s1++)) {
        case 'f': case 'F':  // dump file header
            DumpOptions |= DUMP_FILEHDR;  break;
        case 'h': case 'H':  // dump section headers
            DumpOptions |= DUMP_SECTHDR;  break;
        case 's': case 'S':  // dump symbol table
            DumpOptions |= DUMP_SYMTAB;  break;
        case 'r': case 'R':  // dump relocations
            DumpOptions |= DUMP_RELTAB;  break;
        case 'n': case 'N':  // dump string table
            DumpOptions |= DUMP_STRINGTB;  break;
        case 'c': case 'C':  // dump comment records (currently only for OMF)
            DumpOptions |= DUMP_COMMENT;  break;         
        default:
            err.submit(2004, string-1);  // Unknown option
        }
    }
    if (DumpOptions == 0) DumpOptions = DUMP_FILEHDR;
    OutputType = CMDL_OUTPUT_DUMP;
    if (OutputType && OutputType != CMDL_OUTPUT_DUMP) err.submit(2007); // Both dump and convert specified
    OutputType = CMDL_OUTPUT_DUMP;
}


void CCommandLineInterpreter::InterpretDebugInfoOption(char * string) {
    // Interpret debug info option from command line
    if (strlen(string) > 1) err.submit(2004, string-1);  // Unknown option
    switch (*string) {
    case 's': case 'S': case 'r': case 'R':  // Strip (remove)
        DebugInfo = CMDL_DEBUG_STRIP;  break;
    case 'p': case 'P':                      // Preserve
        DebugInfo = CMDL_DEBUG_PRESERVE;  break;
    case 'l': case 'L':                      // (Not supported)
        DebugInfo = CMDL_DEBUG_LINNUM;  break;
    case 'c': case 'C':                      // (Not supported)
        DebugInfo = CMDL_DEBUG_SYMBOLS;  break;
    default:
        err.submit(2004, string-1);  // Unknown option
    }
}


void CCommandLineInterpreter::InterpretExceptionInfoOption(char * string) {
    // Interpret exception handler info option from command line
    if (strlen(string) > 1) err.submit(2004, string-1);  // Unknown option
    switch (*string) {
    case 's': case 'S': case 'r': case 'R':  // Strip (remove)
        ExeptionInfo = CMDL_EXCEPTION_STRIP;  break;
    case 'p': case 'P':                      // Preserve
        ExeptionInfo = CMDL_EXCEPTION_PRESERVE;  break;
    default:
        err.submit(2004, string-1);  // Unknown option
    }
}


void CCommandLineInterpreter::InterpretErrorOption(char * string) {
    // Interpret warning/error option from command line
    if (strlen(string) < 3) {
        err.submit(2004, string); return; // Unknown option
    } 
    int newstatus;   // New status for this error number

    switch (string[1]) {
    case 'd': case 'D':  // Disable
        newstatus = 0;  break;

    case 'w': case 'W':  // Treat as warning
        newstatus = 1;  break;

    case 'e': case 'E':  // Treat as error
        newstatus = 2;  break;

    default:
        err.submit(2004, string);  // Unknown option
        return;
    }
    if (string[2] == 'x' || string[2] == 'X') {
        // Apply new status to all non-fatal messages
        for (SErrorText * ep = ErrorTexts; ep->Status < 9; ep++) {
            ep->Status = newstatus;  // Change status of all errors
        }
    }
    else {
        int ErrNum = atoi(string+2);
        if (ErrNum == 0 && string[2] != '0') {
            err.submit(2004, string);  return; // Unknown option
        }
        // Search for this error number
        SErrorText * ep = err.FindError(ErrNum);
        if (ep->Status & 0x100) {
            // Error number not found
            err.submit(1003, ErrNum);  return; // Unknown error number
        }
        // Change status of this error
        ep->Status = newstatus;
    }
}

void CCommandLineInterpreter::InterpretSymbolNameChangeOption(char * string) {
    // Interpret various options for changing symbol names
    SSymbolChange sym = {0,0,0,0};   // Symbol change record
    string[0] |= 0x20;  // change first letter to lower case

    // Check for symbol names in this command
    char * name1 = 0, * name2 = 0;
    if (string[2] == ':' && string[3]) {
        // name1 found
        name1 = string+3;
        // Search for second ':' or end
        name2 = name1 + 1;
        while (name2[0] != 0) {
            if (name2[0] == ':') {
                *name2 = 0;  // Mark end of name1
                if (name2[1]) {
                    // name2 found
                    name2++;     // Name2 starts here
                    break;
                }
            }
            name2++;
        }
        if (name2 && name2[0]) {
            // name2 found. check if it ends with ':'
            for (uint32 i = 0; i < (uint32)strlen(name2); i++) {
                if (name2[i] == ':') name2[i] = 0;
            }
        }
        if (name2[0] == 0) name2 = 0;
    }
    // Check for duplicate name
    if (name1 && SymbolIsInList(name1)) {
        // This symbol is already in list
        err.submit(2015, name1);
        return;
    }

    switch (string[1]) {
    case 'u': case 'U':  // underscore option
        switch (string[2]) {
        case 0:
            Underscore = CMDL_UNDERSCORE_CHANGE; 
            if (string[0] == 'a') Underscore |= CMDL_KEEP_ALIAS;
            break;
        case '+': case 'a': case 'A': 
            Underscore = CMDL_UNDERSCORE_ADD; 
            if (string[0] == 'a') Underscore |= CMDL_KEEP_ALIAS;
            break;
        case '-': case 'r': case 'R': 
            Underscore = CMDL_UNDERSCORE_REMOVE; 
            if (string[0] == 'a') Underscore |= CMDL_KEEP_ALIAS;
            break;
        default:
            err.submit(2004, string);  // Unknown option
        }
        break;

    case 'd': case 'D':  // section name dot option
        SegmentDot = CMDL_SECTIONDOT_CHANGE; 
        break;

    case 'r': case 'R':  // name replace option
        if (name1 == 0 || name2 == 0 || *name1 == 0 || *name2 == 0) {
            err.submit(2008, string); return;
        }
        sym.Name1 = name1;
        sym.Name2 = name2;
        sym.Action  = SYMA_CHANGE_NAME;
        if (string[0] == 'a') sym.Action |= SYMA_ALIAS;
        SymbolList.Push(&sym, sizeof(sym));  SymbolChangeEntries++;
        break;

    case 'p': case 'P':  // prefix replace option
        if (name1 == 0 || *name1 == 0) {
            err.submit(2008, string); return;
        }
        if (name2 == 0) name2 = (char*)"";
        sym.Name1 = name1;
        sym.Name2 = name2;
        sym.Action  = SYMA_CHANGE_PREFIX;
        if (string[0] == 'a') sym.Action |= SYMA_ALIAS;
        PrefixSuffixList.Push(&sym, sizeof(sym));  SymbolChangeEntries++;
        break;

    case 's': case 'S':  // suffix replace option
        if (name1 == 0 || *name1 == 0) {
            err.submit(2008, string); return;
        }
        if (name2 == 0) name2 = (char*)"";
        sym.Name1 = name1;
        sym.Name2 = name2;
        sym.Action  = SYMA_CHANGE_SUFFIX;
        if (string[0] == 'a') sym.Action |= SYMA_ALIAS;
        PrefixSuffixList.Push(&sym, sizeof(sym));  SymbolChangeEntries++;
        break;

    case 'w': case 'W':  // Weaken symbol
        if (name1 == 0 || *name1 == 0 || name2) {
            err.submit(2009, string); return;
        }
        sym.Name1 = name1;
        sym.Action  = SYMA_MAKE_WEAK;
        SymbolList.Push(&sym, sizeof(sym));  SymbolChangeEntries++;
        break;

    case 'l': case 'L':  // Make symbol local or hidden
        if (name1 == 0 || *name1 == 0 || name2) {
            err.submit(2009, string); return;
        }
        sym.Name1 = name1;
        sym.Action  = SYMA_MAKE_LOCAL;
        SymbolList.Push(&sym, sizeof(sym));  SymbolChangeEntries++;
        break;

    default:
        err.submit(2004, string);  // Unknown option
    }
}

void CCommandLineInterpreter::InterpretImagebaseOption(char * string) {
    // Interpret image base option
    char * p = strchr(string, '=');
    if ((strnicmp(string, "imagebase", 9) && strnicmp(string, "image_base", 10)) || !p) {
        // Unknown option
        err.submit(1002, string);
        return;
    }
    if (ImageBase) err.submit(2330); // Imagebase specified more than once

    p++;  // point to number following '='
    // Loop through string to interpret hexadecimal number
    while (*p) {
        char letter = *p | 0x20; // lower case letter
        if (*p >= '0' && *p <= '9') {
            // 0 - 9 hexadecimal digit
            ImageBase = (ImageBase << 4) + *p - '0';
        }
        else if (letter >= 'a' && letter <= 'f') {
            // A - F hexadecimal digit
            ImageBase = (ImageBase << 4) + letter - 'a' + 10;
        }
        else if (letter == 'h') {
            // Hexadecimal number may end with 'H'
            break;
        }
        else if (letter == 'x' || letter == ' ') {
            // Hexadecimal number may begin with 0x
            if (ImageBase) {
                // 'x' preceded by number other than 0
                err.submit(1002, string); break;
            }
        }
        else {
            // Any other character not allowed
            err.submit(1002, string); break;
        }
        // next character
        p++;
    }
    if (ImageBase & 0xFFF) {
        // Must be divisible by page size
        err.submit(2331, string);
    }
    if ((int32)ImageBase <= 0) {
        // Cannot be zero or > 2^31
        err.submit(2332, string);
    }
}


SSymbolChange const * CCommandLineInterpreter::GetMemberToAdd() {
    // Get names of object files to add to library
    // replaced will be set to 1 if a member with the same name is replaced

    // Search through SymbolList, continuing from last CurrentSymbol
    while (CurrentSymbol < SymbolList.GetDataSize()) {
        // Get pointer to current symbol record
        SSymbolChange * Sym = (SSymbolChange *)(SymbolList.Buf() + CurrentSymbol);
        // Increment pointer
        CurrentSymbol += sizeof(SSymbolChange);
        // Check record type
        if (Sym->Action == SYMA_ADD_MEMBER) {
            // Name found
            return Sym;
        }
    }
    // No more names found
    return 0;
}


void CCommandLineInterpreter::CheckExtractSuccess() {
    // Check if library members to extract were found

    // Search through SymbolList for extract records
    for (uint32 i = 0; i < SymbolList.GetDataSize(); i += sizeof(SSymbolChange)) {
        SSymbolChange * Sym = (SSymbolChange *)(SymbolList.Buf() + i);
        if (Sym->Action == SYMA_EXTRACT_MEMBER && Sym->Done == 0) {
            // Member has not been extracted
            err.submit(1104, Sym->Name1);
        }
    }
}


void CCommandLineInterpreter::CheckSymbolModifySuccess() {
    // Check if symbols to modify were found

    // Search through SymbolList for symbol change records
    for (uint32 i = 0; i < SymbolList.GetDataSize(); i += sizeof(SSymbolChange)) {
        SSymbolChange * Sym = (SSymbolChange *)(SymbolList.Buf() + i);
        if (Sym->Action >= SYMA_MAKE_WEAK && Sym->Action < SYMA_ADD_MEMBER && Sym->Done == 0) {
            // Member has not been extracted
            err.submit(1106, Sym->Name1);
        }
        if (Sym->Action == SYMA_DELETE_MEMBER && Sym->Done == 0) {
            // Member has not been extracted
            err.submit(1105, Sym->Name1);
        }
    }
}


int CCommandLineInterpreter::SymbolIsInList(char const * name) {
    // Check if name is already in symbol list
    int unused;
    return SymbolBinSearch(name, SymbolList.GetNumEntries(), &unused);
}


int CCommandLineInterpreter::SymbolBinSearch(char const * name, int nsym, int * location) {
    SSymbolChange * List = (SSymbolChange *)SymbolList.Buf();
    int lo = 0, hi = nsym - 1;
    while (lo <= hi) {
        int mid = (lo + hi) >> 1;
        int comp = strcmp(name, List[mid].Name1);
        if (!comp) {
            *location = mid;
            return 1;
        } else if (comp < 0) {
            hi = mid - 1;
        } else {
            lo = mid + 1;
        }
    }
    *location = lo;
    return 0;
}


int CCommandLineInterpreter::SymbolChange(char const * oldname, char const ** newname, int symtype) {
    // Check if symbol has to be changed
    int action = 0, i, isym;
    int nsym = SymbolList.GetNumEntries();
    int n_prefix_suffix = PrefixSuffixList.GetNumEntries();
    if (oldname == 0) return SYMA_NOCHANGE;
    if (newname) *newname = 0;

    // Convert standard names if type conversion
    if (cmd.InputType != cmd.OutputType 
        && uint32(cmd.InputType) <= MaxType && uint32(cmd.OutputType) <= MaxType) {
            if (DesiredWordSize == 32) {
                // Look for standard names to translate, 32-bit
                for (i = 0; i < NumStandardNames; i++) {
                    if (strcmp(oldname, StandardNames32[i][cmd.InputType]) == 0) {
                        // Match found
                        *newname = StandardNames32[i][cmd.OutputType];
                        CountSymbolNameChanges++;
                        return SYMA_CHANGE_NAME; // Change name of symbol
                    }
                }
            }
            else {
                // Look for standard names to translate, 64-bit
                for (i = 0; i < NumStandardNames; i++) {
                    if (strcmp(oldname, StandardNames64[i][cmd.InputType]) == 0) {
                        // Match found
                        *newname = StandardNames64[i][cmd.OutputType];
                        CountSymbolNameChanges++;
                        return SYMA_CHANGE_NAME; // Change name of symbol
                    }
                }
            }
    }

    // See if there are other conversions to do
    if (Underscore == 0 && SegmentDot == 0 && nsym == 0 && n_prefix_suffix == 0) return SYMA_NOCHANGE;  // Nothing to do
    if (oldname == 0 || *oldname == 0) return SYMA_NOCHANGE;                    // No name

    static char NameBuffer[MAXSYMBOLLENGTH];

    // search for name in list of names specified by user on command line
    SSymbolChange * psym;
    int found = SymbolBinSearch(oldname, nsym, &isym);
    if (found) {
        psym = (SSymbolChange *)SymbolList.Buf() + isym;
    } else {
        // Search prefix/suffix match
        psym = (SSymbolChange *)PrefixSuffixList.Buf();
        for (isym = 0; isym < n_prefix_suffix; isym++, psym++) {
            int n1len = (int)strlen(psym->Name1); // Length of string to search for
            int onlen = (int)strlen(oldname);     // Length of string to match
            if ((psym->Action&~SYMA_ALIAS) == SYMA_CHANGE_PREFIX && strncmp(oldname, psym->Name1, n1len)==0) break; // matching prefix found
            if ((psym->Action&~SYMA_ALIAS) == SYMA_CHANGE_SUFFIX && strcmp(oldname+onlen-n1len, psym->Name1)==0) break; // matching suffix found
        }
        found = isym < n_prefix_suffix;
    }

    if (found) {
        // A matching name was found.
        action = psym->Action;
        // Whatever action is specified here is overriding any general option
        // Statistics counting
        switch (action & ~SYMA_ALIAS) {

        case SYMA_MAKE_WEAK: // Make public symbol weak
            if (symtype == SYMT_PUBLIC) {
                CountSymbolsWeakened++;  psym->Done++;
            }
            else { // only public symbols can be weakened
                err.submit(1020, oldname); // cannot make weak
                action = SYMA_NOCHANGE;
            }
            break;

        case SYMA_MAKE_LOCAL: // Hide public or external symbol
            if (symtype == SYMT_PUBLIC || symtype == SYMT_EXTERNAL) {
                CountSymbolsMadeLocal++;  psym->Done++;
                if (symtype == SYMT_EXTERNAL) err.submit(1023, oldname);
            }
            else { // only public and external symbols can be made local
                err.submit(1021, oldname); // cannot make local
                action = SYMA_NOCHANGE;
            }
            break;

        case SYMA_CHANGE_NAME: // Change name of symbol or segment or library member
            CountSymbolNameChanges++;  psym->Done++;  
            *newname = psym->Name2;
            break;

        case SYMA_CHANGE_PREFIX: // Change beginning of symbol name
            if (symtype == SYMT_PUBLIC || symtype == SYMT_EXTERNAL || symtype == SYMT_LOCAL || symtype == SYMT_SECTION) {
                if (strlen(oldname) - strlen(psym->Name1) + strlen(psym->Name2) >= MAXSYMBOLLENGTH) {
                    err.submit(2202, oldname);  // Name too long
                    action = SYMA_NOCHANGE;  break;
                }
                strcpy(NameBuffer, psym->Name2);
                strcpy(NameBuffer + strlen(psym->Name2), oldname + strlen(psym->Name1));
                action = SYMA_CHANGE_NAME;
                *newname = NameBuffer;
                CountSymbolNameChanges++;  psym->Done++;
            }
            else { // only symbols and segments can change prefix
                err.submit(1024, oldname);
                action = SYMA_NOCHANGE;
            }
            break;

        case SYMA_CHANGE_SUFFIX: // Change end of symbol name
            if (symtype == SYMT_PUBLIC || symtype == SYMT_EXTERNAL || symtype == SYMT_LOCAL || symtype == SYMT_SECTION) {
                if (strlen(oldname) - strlen(psym->Name1) + strlen(psym->Name2) >= MAXSYMBOLLENGTH) {
                    err.submit(2202, oldname);  // Name too long
                    action = SYMA_NOCHANGE;  break;
                }
                strcpy(NameBuffer, oldname);
                strcpy(NameBuffer + strlen(oldname) - strlen(psym->Name1), psym->Name2);
                action = SYMA_CHANGE_NAME;
                *newname = NameBuffer;
                CountSymbolNameChanges++;  psym->Done++;
            }
            else { // only symbols and segments can change prefix
                err.submit(1024, oldname);
                action = SYMA_NOCHANGE;
            }
            break;

        case SYMA_EXTRACT_MEMBER:
            *newname = psym->Name2;
            // continue in next case
        case SYMA_DELETE_MEMBER: case SYMA_ADD_MEMBER:
            if (symtype == SYMT_LIBRARYMEMBER) {
                // Change to library member
                psym->Done++;
            }
            else {
                // Ignore action for symbols that have the same name as a library member
                action = SYMA_NOCHANGE;
            }
        }

        if (action && (psym->Action & SYMA_ALIAS)) {
            // Keep old name as alias
            if (symtype == SYMT_PUBLIC) {
                CountSymbolNameAliases++;  psym->Done++;
                action = SYMA_ALIAS;
            }
            else { // only public symbols can have aliases
                CountSymbolNameChanges--;
                err.submit(1022, oldname); // cannot make alias
                action = SYMA_NOCHANGE;
            }
        }

        // Action to take
        return action;
    }

    // Not found in list. Check for section options
    if (symtype == SYMT_SECTION) {
        if (!strncmp(oldname, ".rela", 5)) {
            // ELF relocation section must have same name change as mother section
            const char * name2;
            int action2 = SymbolChange(oldname+5, &name2, symtype);
            if (action2 == SYMA_CHANGE_NAME && strlen(name2) + 6 < MAXSYMBOLLENGTH) {
                sprintf(NameBuffer, ".rela%s", name2);
                *newname = NameBuffer;
                return action2;
            }
        }
        if (!strncmp(oldname, ".rel", 4)) {
            // ELF relocation section must have same name change as mother section
            const char * name2;
            int action2 = SymbolChange(oldname+4, &name2, symtype);
            if (action2 == SYMA_CHANGE_NAME && strlen(name2) + 5 < MAXSYMBOLLENGTH) {
                sprintf(NameBuffer, ".rel%s", name2);
                *newname = NameBuffer;
                return action2;
            }
        }
        if (SegmentDot) {
            // Change section name

            if (SegmentDot == CMDL_SECTIONDOT_U2DOT && oldname[0] == '_') {
                // replace '_' by '.'
                strncpy(NameBuffer, oldname, MAXSYMBOLLENGTH-1);
                NameBuffer[MAXSYMBOLLENGTH-1] = 0;  // Terminate string
                NameBuffer[0] = '.';
                *newname = NameBuffer;
                CountSectionDotConversions++;
                return SYMA_CHANGE_NAME;
            }
            if (SegmentDot == CMDL_SECTIONDOT_DOT2U && oldname[0] == '.') {
                // replace '.' by '_'
                // Note: Microsoft and Intel compilers have . on standard names
                // and _ on nonstandard names in COFF files
                // Borland requires _ on all segment names in OMF files
                /* 
                // Standard section names that should not be changed
                static char const * StandardSectionNames[] = {
                ".text", ".data", ".bss", ".comment", ".lib"
                };
                for (uint32 i = 0; i < sizeof(StandardSectionNames)/sizeof(StandardSectionNames[0]); i++) {
                if (stricmp(oldname,StandardSectionNames[i]) == 0) {
                // Standard name. Don't change
                return SYMA_NOCHANGE;
                }
                }*/
                strncpy(NameBuffer, oldname, MAXSYMBOLLENGTH-1);
                NameBuffer[MAXSYMBOLLENGTH-1] = 0;  // Terminate string
                NameBuffer[0] = '_';
                *newname = NameBuffer;
                CountSectionDotConversions++;
                return SYMA_CHANGE_NAME;
            }
        }
    }

    // Check for underscore options
    if ((Underscore & 0x0F) == CMDL_UNDERSCORE_REMOVE && oldname[0] == '_') {
        // Remove underscore
        if ((Underscore & CMDL_KEEP_ALIAS) && symtype == SYMT_PUBLIC) {
            // Alias only applicable to public symbols
            // Make alias without underscore
            *newname = oldname + 1;
            CountUnderscoreConversions++;  CountSymbolNameAliases++;
            return SYMA_ALIAS;
        }
        // Change name applicable to public and external symbols
        if (symtype == SYMT_PUBLIC || symtype == SYMT_EXTERNAL) {
            // Make new name without underscore
            *newname = oldname + 1;
            CountUnderscoreConversions++;
            return SYMA_CHANGE_NAME;
        }
    }
    if ((Underscore & 0x0F) == CMDL_UNDERSCORE_ADD) {
        // Add underscore even if it already has one
        if ((Underscore & CMDL_KEEP_ALIAS) && symtype == SYMT_PUBLIC) {
            // Alias only applicable to public symbols
            // Make alias with underscore
            strncpy(NameBuffer+1, oldname, MAXSYMBOLLENGTH-2);
            NameBuffer[MAXSYMBOLLENGTH-1] = 0;  // Terminate string
            NameBuffer[0] = '_';
            *newname = NameBuffer;
            CountUnderscoreConversions++;  CountSymbolNameAliases++;
            return SYMA_ALIAS;
        }
        // Change name applicable to public and external symbols
        if (symtype == SYMT_PUBLIC || symtype == SYMT_EXTERNAL) {
            // Make new name with underscore
            strncpy(NameBuffer+1, oldname, MAXSYMBOLLENGTH-2);
            NameBuffer[MAXSYMBOLLENGTH-1] = 0;  // Terminate string
            NameBuffer[0] = '_';
            *newname = NameBuffer;
            CountUnderscoreConversions++;
            return SYMA_CHANGE_NAME;
        }
    }
    return SYMA_NOCHANGE;
}


int CCommandLineInterpreter::SymbolChangesRequested() {
    // Any kind of symbol change requested on command line
    return (Underscore != 0) 
        | (SegmentDot != 0) << 1 
        | (SymbolChangeEntries != 0) << 2;
}


void CCommandLineInterpreter::CountDebugRemoved() {
    // Count debug sections removed
    CountDebugSectionsRemoved++;
}


void CCommandLineInterpreter::CountExceptionRemoved() {
    // Count exception handler sections removed
    CountExceptionSectionsRemoved++;
}


void CCommandLineInterpreter::CountSymbolsHidden() {
    // Count unused external references hidden
    CountUnusedSymbolsHidden++;
}


void CCommandLineInterpreter::ReportStatistics() {
    // Report statistics about name changes etc.
    if (DebugInfo == CMDL_DEBUG_STRIP || ExeptionInfo == CMDL_EXCEPTION_STRIP 
        || Underscore || SegmentDot || SymbolList.GetNumEntries()) {
            printf ("\n");
    }
    if (DebugInfo == CMDL_DEBUG_STRIP) {
        printf ("\n%3i Debug sections removed", CountDebugSectionsRemoved);
    }
    if (ExeptionInfo == CMDL_EXCEPTION_STRIP) {
        printf ("\n%3i Exception sections removed", CountExceptionSectionsRemoved);
    }
    if ((DebugInfo == CMDL_DEBUG_STRIP || ExeptionInfo == CMDL_EXCEPTION_STRIP) 
        && CountUnusedSymbolsHidden) {
            printf ("\n%3i Unused external symbol references hidden", CountUnusedSymbolsHidden);
    }

    if (Underscore || SegmentDot || SymbolList.GetNumEntries()) {
        if (CountUnderscoreConversions || Underscore) {
            printf ("\n%3i Changes in leading underscores on symbol names", CountUnderscoreConversions);
        }
        if (CountSectionDotConversions || SegmentDot) {
            printf ("\n%3i Changes in leading characters on section names", CountSectionDotConversions);
        }
        if (CountSymbolNameChanges) {
            printf ("\n%3i Symbol names changed", CountSymbolNameChanges);
        }
        if (CountSymbolNameAliases) {
            printf ("\n%3i Public symbol names aliased", CountSymbolNameAliases);
        }
        if (CountSymbolsWeakened) {
            printf ("\n%3i Public symbol names made weak", CountSymbolsWeakened);
        }
        if (CountSymbolsMadeLocal) {
            printf ("\n%3i Public or external symbol names made local", CountSymbolsMadeLocal);
        }
        if (SymbolChangeEntries && !CountSymbolNameChanges && !CountSymbolNameAliases && !CountSymbolsWeakened && !CountSymbolsMadeLocal) {
            printf ("\n    No symbols to change were found");
        }
    }
}


void CCommandLineInterpreter::Help() {
    // Print help message
    printf("\nObject file converter version %.2f for x86 and x86-64 platforms.", OBJCONV_VERSION);
    printf("\nCopyright (c) 2018 by Agner Fog. Gnu General Public License.");
    printf("\n\nUsage: objconv options inputfile [outputfile]");
    printf("\n\nOptions:");
    printf("\n-fXXX[SS]  Output file format XXX, word size SS. Supported formats:");
    printf("\n           PE, COFF, ELF, OMF, MACHO\n");
    printf("\n-fasm      Disassemble file (-fmasm, -fnasm, -fyasm, -fgasm)\n");
    printf("\n-dXXX      Dump file contents to console.");
    printf("\n           Values of XXX (can be combined):");
    printf("\n           f: File header, h: section Headers, s: Symbol table,");
    printf("\n           r: Relocation table, n: string table.\n");

    printf("\n-nu        change symbol Name Underscores to the default for the target format.");
    printf("\n-nu-       remove Underscores from symbol Names.");
    printf("\n-nu+       add Underscores to symbol Names.");
    printf("\n-nd        replace Dot/underscore in section names.");
    printf("\n-nr:N1:N2  Replace symbol Name N1 with N2.");
    printf("\n-np:N1:N2  Replace symbol Prefix N1 with N2.");
    printf("\n-ns:N1:N2  Replace symbol Suffix N1 with N2.");
    printf("\n-ar:N1:N2  make Alias N2 for existing public name N1.");
    printf("\n-ap:N1:N2  Replace symbol Prefix and keep old name as alias.");
    printf("\n-as:N1:N2  Replace symbol Suffix and keep old name as alias.");
    printf("\n-nw:N1     make public symbol Name N1 Weak (ELF and MAC64 only).");
    printf("\n-nl:N1     make public symbol Name N1 Local (invisible).\n");
    //printf("\n-ds        Strip Debug info.");    // default if input and output are different formats
    //printf("\n-dp        Preserve Debug info, even if it is incompatible.");
    printf("\n-xs        Strip exception handling info and other incompatible info.");  // default if input and output are different formats. Hides unused symbols
    printf("\n-xp        Preserve exception handling info and other incompatible info.\n");

    printf("\n-lx        eXtract all members from Library.");
    printf("\n-lx:N1:N2  eXtract member N1 from Library to file N2.");
    printf("\n-ld:N1     Delete member N1 from Library.");
    printf("\n-la:N1:N2  Add object file N1 to Library as member N2.");
    printf("\n           Alternative: -lib LIBRARYNAME OBJECTFILENAMES.\n");

    printf("\n-vN        Verbose options. Values of N:");
    printf("\n           0: Silent, 1: Print file names and types, 2: Tell about conversions.");

    printf("\n-wdNNN     Disable Warning NNN.");
    printf("\n-weNNN     treat Warning NNN as Error. -wex: treat all warnings as errors.");
    printf("\n-edNNN     Disable Error number NNN.");
    printf("\n-ewNNN     treat Error number NNN as Warning.\n");

    printf("\n-h         Print this help screen.\n");

    printf("\n@RFILE     Read additional options from response file RFILE.\n");
    printf("\n\nExample:");
    printf("\nobjconv -felf32 -nu filename.obj filename.o\n\n");
}