cmdline.c

/*
 * Spin to C/C++ translator
 * Copyright 2011-2025 Total Spectrum Software Inc.
 * 
 * +--------------------------------------------------------------------
 * ¦  TERMS OF USE: MIT License
 * +--------------------------------------------------------------------
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files
 * (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * +--------------------------------------------------------------------
 */

#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>
#include <time.h>
#include <unistd.h>
#include "spinc.h"
#include "preprocess.h"
#include "version.h"
#include "cmdline.h"
#include "becommon.h"

static int TrivialSpinFunction(Module *P);
void PrintDependencies(const char *depname, const char *outname);

extern const char *gl_progname; /* defined in common.c */
const char *gl_cc = NULL;
const char *gl_intstring = "int32_t";

const char *gl_outname = NULL;
bool gl_print_sizes = false;

void InitializeSystem(CmdLineOptions *cmd, const char **argv)
{
    memset(cmd, 0, sizeof(*cmd));
    gl_src_charset = CHARSET_UTF8;
    gl_run_charset = CHARSET_UTF8;
    cmd->eepromSize = 32768;
    InitPreprocessor(argv);
    gl_max_errors = 1;
    gl_colorize_output = isatty(fileno(stderr));
    current_print_color = PRINT_NORMAL;
}

int FindLabelValue(const char *name, int defaultval) {
    Symbol *sym;
    sym = LookupSymbol(name);
    if (sym && sym->kind == SYM_LABEL) {
        Label *lab = (Label *)sym->v.ptr;
        return lab->hubval;
    }
    return defaultval;
}
    
void
PrintFileSize(const char *fname)
{
    FILE *f = fopen(fname, "rb");
    unsigned len;

    if (f) {
        fseek(f, 0L, SEEK_END);
        len = ftell(f);
        fclose(f);
        printf("Program size is %u bytes\n", len);
    }
    if (gl_print_sizes) {
        int start_interpreter, end_interpreter;
        int start_code, end_code;
        
        start_interpreter = FindLabelValue("__SIZE_INTERPRETER_START", -1);
        end_interpreter = FindLabelValue("__SIZE_INTERPRETER_END", -1);
        start_code = FindLabelValue("__SIZE_CODE_START", -1);
        end_code = FindLabelValue("__SIZE_CODE_END", -1);
        if (start_interpreter >= 0 && end_interpreter >= 0) {
            printf(" Interpreter size=%6d bytes\n", end_interpreter - start_interpreter);
        }
        if (start_code >= 0 && end_code >= 0) {
            printf(" Code size       =%6d bytes\n", end_code - start_code);
        }
    }
}

void
CompileAsmToBinary(const char *binname, const char *asmname)
{
    const char *listFile = gl_listing ? ReplaceExtension(binname, ".lst") : NULL;
    if (gl_errors > 0) {
        // no point in going all the way to compiling
        // the final assembly, it isn't valid anyway
        remove(binname);
        if (listFile) {
            remove(listFile);
        }
        exit(1);
    }
    gl_output = OUTPUT_DAT;
    gl_dat_offset = (gl_p2 ? 0 : DEFAULT_P1_DAT_OFFSET);
    gl_interp_kind = 0;
    
    Module *Q = ParseTopFiles(&asmname, 1, 1);
    if (gl_errors == 0) {
        if (listFile) {
            OutputLstFile(listFile, Q);
        }
        OutputDatFile(binname, Q, 1);
    }
}

int ProcessCommandLine(CmdLineOptions *cmd)
{
    Module *P;
    const char *listFile = NULL;
    
//    if (gl_output == OUTPUT_COGSPIN) {
//        gl_optimize_flags &= ~OPT_REMOVE_UNUSED_FUNCS;
//    }
    if (gl_relocatable) {
        if (!gl_p2) {
            fprintf(stderr, "ERROR: relocatable output only supported for P2\n");
            exit(1);
        }
        gl_no_coginit = 1;
        if (gl_hub_base != 0) {
            fprintf(stderr, "Warning: --relocatable overrides -H\n");
            gl_hub_base = 0;
        }
    }
    /* add some predefined symbols */
    
    if (gl_p2) {
        pp_define(&gl_pp, "__propeller__", "2");
    } else {
        pp_define(&gl_pp, "__propeller__", "1");
    }
    pp_define(&gl_pp, "__FASTSPIN__", str_(VERSION_MAJOR));
    pp_define(&gl_pp, "__FLEXSPIN__", str_(VERSION_MAJOR));
    pp_define(&gl_pp, "__FLEXBASIC__", str_(VERSION_MAJOR));
    pp_define(&gl_pp, "__FLEXC__", str_(VERSION_MAJOR));
    pp_define(&gl_pp, "__SPINCVT__", str_(VERSION_MAJOR));

    // exact version number
    pp_define(&gl_pp, "__FLEX_MAJOR__", str_(VERSION_MAJOR));
    pp_define(&gl_pp, "__FLEX_MINOR__", str_(VERSION_MINOR));
    pp_define(&gl_pp, "__FLEX_REV__",   str_(VERSION_REV));
    
    // time and date versions
    {
        // pp_define does not do a strdup() on the data, so we need
        // to do that
        char quote_data[256];
        time_t now = time(NULL);
        struct tm *tm = localtime(&now);
        
        sprintf(quote_data, "\"%s\"", version_string);
        pp_define(&gl_pp, "__VERSION__", strdup(quote_data));

        strftime(quote_data, sizeof(quote_data), "\"%b %d %Y\"",  tm);
        pp_define(&gl_pp, "__DATE__", strdup(quote_data));

        strftime(quote_data, sizeof(quote_data), "\"%H:%M:%S\"",  tm);
        pp_define(&gl_pp, "__TIME__", strdup(quote_data));
    }
    if (gl_cenv_flags & CENV_PROVIDE_EXIT) {
        pp_define(&gl_pp, "__EXIT_STATUS__", "1");
    }
    if (gl_cenv_flags & CENV_NO_CRNL) {
        pp_define(&gl_pp, "__FLEXC_NO_CRNL__", "1");
    }
    if (gl_debug) {
        pp_define(&gl_pp, "__DEBUG__", "1");
    }
    if (gl_output == OUTPUT_ASM || gl_output == OUTPUT_COGSPIN) {
        pp_define(&gl_pp, "__SPIN2PASM__", "1");
        pp_define(&gl_pp, "__OUTPUT_ASM__", "1");
    } else if (gl_output == OUTPUT_CPP || gl_output == OUTPUT_C) {
        pp_define(&gl_pp, "__SPIN2CPP__", "1");
        if (gl_output == OUTPUT_CPP) {
            pp_define(&gl_pp, "__cplusplus", "1");
            pp_define(&gl_pp, "__OUTPUT_CPP__", "1");
        } else {
            pp_define(&gl_pp, "__OUTPUT_C__", "1");
        }
    } else if (gl_output == OUTPUT_BYTECODE) {
        pp_define(&gl_pp, "__OUTPUT_BYTECODE__", "1");
        if (gl_interp_kind == INTERP_KIND_P1ROM) {
            pp_define(&gl_pp, "__OUTPUT_BYTECODE_P1ROM__", "1");
        } else if (gl_interp_kind == INTERP_KIND_P2SPIN) {
            pp_define(&gl_pp, "__OUTPUT_BYTECODE_P2SPIN__", "1");
        } else if (gl_interp_kind == INTERP_KIND_NUCODE) {
            pp_define(&gl_pp, "__OUTPUT_BYTECODE_NUCODE__", "1");
        }
    }
    {
        const char *basename;
        char *our_progname;
        if (gl_outname) {
            basename = gl_outname;
        } else if (cmd->file_argv[0]) {
            basename = ReplaceExtension(cmd->file_argv[0], ".binary");
        } else {
            basename = "a.binary";
        }
        size_t len = strlen(basename) + 2;
        our_progname = (char *)malloc(len + 1);
        our_progname[0] = '\"';
        strcpy(our_progname+1, basename);
        our_progname[len-1] = '\"';
        our_progname[len] = 0;
        pp_define(&gl_pp, "__FLEXSPIN_PROGRAM__", our_progname);
    }
    pp_define(&gl_pp, "__ILP32__", "1");
    if (gl_p2) {
        pp_define(&gl_pp, "__P2__", "1");
        pp_define(&gl_pp, "__propeller2__", "1");
    } else {
        pp_define(&gl_pp, "__P1__", "1");
    }
    if (gl_fixedreal) {
        pp_define(&gl_pp, "__fixedreal__", "1");
    }
    // Note: replicating logic from GuessFcacheSize here, kinda terrible
    if (gl_fcache_size > 0 || (gl_fcache_size == -1 && (!gl_p2 || (gl_optimize_flags&OPT_AUTO_FCACHE)))) {
        pp_define(&gl_pp,"__HAVE_FCACHE__","1");
    }
    /* if -Oremove-features is not on, then assume certain features are present */
    if ( 0 == (gl_optimize_flags & OPT_REMOVE_FEATURES) ) {
        unsigned i, flag;
        for (i = 0; i < 32; i++) {
            flag = 1U << i;
            if ( (FEATURE_DEFAULTS_NOOPT) & flag ) {
                ActivateFeature(flag);
            }
        }
    }
    /* set up the binary offset */
    gl_dat_offset = -1; // by default offset is unknown
    if ( (gl_output == OUTPUT_DAT||gl_output == OUTPUT_ASM) && cmd->outputBin) {
        // a 24 byte spin header is prepended to binary output of dat
        // (but not in p2 mode)
        gl_dat_offset = gl_p2 ? 0 : DEFAULT_P1_DAT_OFFSET;
    } else if (gl_output == OUTPUT_DAT && gl_gas_dat) {
        // GAS output for dat uses symbols, so @@@ is OK there
        gl_dat_offset = 0;
    }

    // compression
    if (gl_compress) {
        gl_lmm_kind = LMM_KIND_COMPRESS;
        gl_fcache_size = 0;
        gl_optimize_flags |= OPT_REMOVE_HUB_BSS;
        if (gl_p2) {
            fprintf(stderr, "-z is not supported on P2 yet");
            exit(2);
        }
    }
    // listing file
    if (gl_listing && !(gl_output == OUTPUT_DAT)) {
        gl_srccomments = 1;
    }
    
    /* initialize the parser; we do that after command line processing
       so that command line options can influence it */
    Init();

    /* now actually parse the file */
    if (!cmd->quiet) {
        gl_printprogress = 1;
    }
    if (cmd->printSizes) {
        gl_print_sizes = true;
    }
    P = ParseTopFiles(cmd->file_argv, cmd->file_argc, cmd->outputBin);

    if (cmd->outputFiles) {
        PrintSourceFiles();
        return 0;
    }
    
    if (P) {
        int compile_original = 0;
        
        /* set up output file names */
        if (gl_listing) {
            listFile = ReplaceExtension(P->fullname, ".lst");
            if (gl_errors >= gl_max_errors) {
                remove(listFile);
            }
            
        }

        if (cmd->outputDependencies) {
            const char *depname = gl_outname;
            const char *binname = gl_outname;
            if (!depname) {
                depname = ReplaceExtension(P->fullname, ".d");
            }
            if (!binname) {
                if (gl_output == OUTPUT_OBJ) {
                    binname = ReplaceExtension(P->fullname, ".o");
                } else {
                    binname = ReplaceExtension(P->fullname, ".binary");
                }
            }
            PrintDependencies(depname, binname);
        }
        
        if (gl_output == OUTPUT_OBJ) {
            const char *binname = gl_outname;
            if (!binname) {
                binname = ReplaceExtension(P->fullname, ".o");
            }
            if (gl_errors >= gl_max_errors) {
                remove(binname);
                return 1;
            }
            OutputObjFile(binname, P);
        } else if (gl_output == OUTPUT_ZIP) {
            const char *zipname = gl_outname;
            if (!zipname) {
                char zipappend[128];
                time_t now = time(NULL);
                struct tm *tm = localtime(&now);
                strftime(zipappend, sizeof(zipappend), "-%Y-%m-%d.zip", tm);
                zipname = ReplaceExtension(P->fullname, zipappend);
            }
            OutputZipFile(zipname);
            if (gl_errors == 0) {
                printf("Created %s\n", zipname);
            }
        } else if (cmd->outputDat) {
            cmd->outname = gl_outname;
            if (gl_gas_dat) {
	            if (!cmd->outname) {
                    cmd->outname = ReplaceExtension(P->fullname, ".S");
                }
                OutputGasFile(cmd->outname, P);
            } else {
                if (!cmd->outname) {
                    if (cmd->outputBin) {
                        if (cmd->useEeprom) {
                            cmd->outname = ReplaceExtension(P->fullname, ".eeprom");
                        } else {
                            cmd->outname = ReplaceExtension(P->fullname, ".binary");
                        }
                    } else {
                        cmd->outname = ReplaceExtension(P->fullname, ".dat");
                    }
                }
                if (cmd->bstcMode && !listFile) {
                    cmd->outname = ReplaceExtension(cmd->outname, ".binary");
                }
                if (gl_errors >= gl_max_errors) {
                    remove(cmd->outname);
                    return 1;
                }
                if (listFile) {
                    OutputLstFile(listFile, P);
                }
                OutputDatFile(cmd->outname, P, cmd->outputBin);
                if (cmd->outputBin) {
                    DoPropellerPostprocess(cmd->outname, cmd->useEeprom ? cmd->eepromSize : 0);
                }
            }
        } else if (cmd->outputAsm || (cmd->outputBytecode && gl_interp_kind == INTERP_KIND_NUCODE) ) {
            const char *binname = NULL;
            const char *asmname = NULL;
            if (cmd->compile) {
                binname = gl_outname;
                if (binname) {
                    asmname = ReplaceExtension(binname, gl_p2 ? ".p2asm" : ".pasm");
                } else {
                    if (cmd->useEeprom) {
                        binname = ReplaceExtension(P->fullname, ".eeprom");
                    } else {
                        binname = ReplaceExtension(P->fullname, ".binary");
                    }
                }
            } else {
                asmname = gl_outname;
            }
            if (!asmname) {
                if (gl_output == OUTPUT_COGSPIN) {
                    if (gl_p2) {
                        asmname = ReplaceExtension(P->fullname, ".cog.spin2");
                    } else {
                        asmname = ReplaceExtension(P->fullname, ".cog.spin");
                    }
                } else {
                    asmname = ReplaceExtension(P->fullname, gl_p2 ? ".p2asm" : ".pasm");
                }
            }
            if (gl_errors >= gl_max_errors) {
                if (asmname) remove(asmname);
                if (binname) remove(binname);
                return 1;
            }
            if (TrivialSpinFunction(P)) {
                // we can just assemble the .spin file directly
                asmname = strdup(P->fullname);
                compile_original = 1;
            } else if (gl_interp_kind == INTERP_KIND_NUCODE) {
                if (!gl_p2) {
                    ERROR(NULL, "Nucode only supported on P2");
                }
                OutputNuCode(asmname, P);
            } else {
                OutputAsmCode(asmname, P, cmd->outputMain);
            }
            if (cmd->compile)  {
                gl_caseSensitive = !compile_original;
                gl_warn_flags &= ~(WARN_ASM_FIRST_PASS|WARN_ASM_USAGE); // already issued warnings
                gl_optimize_flags = 0; // no need to re-optimize
                gl_cenv_flags = 0;     // already handled C startup code
                CompileAsmToBinary(binname, asmname);
                if (gl_errors == 0) {
                    DoPropellerPostprocess(binname, cmd->useEeprom ? cmd->eepromSize : 0);
                } else {
                    remove(binname);
                }
                if (!cmd->quiet) {
                    printf("Done.\n");
                    if (gl_errors == 0) {
                        PrintFileSize(binname);
                    }
                }
            }
        } else if (cmd->outputBytecode) {
            if (!cmd->outname) {
                if (cmd->useEeprom) {
                    cmd->outname = ReplaceExtension(P->fullname, ".eeprom");
                } else {
                    cmd->outname = ReplaceExtension(P->fullname, ".binary");
                }
            }

            if (gl_errors >= gl_max_errors) {
                remove(cmd->outname);
                return 1;
            }
            if (gl_interp_kind == INTERP_KIND_NUCODE) {
                ERROR(NULL, "How did we get here?");
            } else {
                OutputByteCode(cmd->outname,P);
                DoPropellerPostprocess(cmd->outname,cmd->useEeprom ? cmd->eepromSize : 0);
            }
        } else {
            fprintf(stderr, "This front end cannot convert to C\n");
        }
    } else {
        fprintf(stderr, "parse error\n");
        return 1;
    }

    return 0;
}

const char * GetOptionString(char *buf, size_t n, const char *opts)
{
    int i = 0;
    int c;
    int balance = 0;

    if (n <= 1) {
        return NULL;
    }
    --n;
    for(;;) {
        c = *opts;
        if (c == 0) {
            *buf = 0;
            return opts;
        }
        if (c == ')' && balance == 0) {
            *buf = 0;
            return NULL;
        }
        opts++;
        if (c == ',') {
            *buf = 0;
            return opts;
        }
        if (i < n) {
            *buf++ = c;
            i++;
        }
        if (c == '(') {
            balance++;
        } else if (c == ')') {
            balance--;
        }
    }
}

typedef struct FlagTable {
    const char *name;
    unsigned bits;
} FlagTable;

static FlagTable optflag[] = {
    { "remove-unused", OPT_REMOVE_UNUSED_FUNCS },
    { "remove-features", OPT_REMOVE_FEATURES },
    { "remove-dead", OPT_DEADCODE },
    { "merge-duplicate-functions", OPT_MERGE_DUPLICATES },
    { "inline-small", OPT_INLINE_SMALLFUNCS },
    { "regs", OPT_BASIC_REGS },
    { "branch-convert", OPT_BRANCHES },
    { "const", OPT_CONST_PROPAGATE },
    { "peephole", OPT_PEEPHOLE },
    { "tail-calls", OPT_TAIL_CALLS },
    { "loop-basic", OPT_LOOP_BASIC },
    { "loop-reduce", OPT_PERFORM_LOOPREDUCE },
    { "fcache", OPT_AUTO_FCACHE },
    { "inline-single", OPT_INLINE_SINGLEUSE },
    { "cse", OPT_PERFORM_CSE },
    { "remove-bss", OPT_REMOVE_HUB_BSS },
    { "casetable", OPT_CASETABLE },
    { "extrasmall", OPT_EXTRASMALL },
    { "bcmacros", OPT_MAKE_MACROS },
    { "special-functions", OPT_SPECIAL_FUNCS },
    { "cordic-reorder", OPT_CORDIC_REORDER},
    { "local-reuse", OPT_LOCAL_REUSE},
    { "aggressive-mem", OPT_AGGRESSIVE_MEM},
    { "cold-code", OPT_COLD_CODE},
    { "spin-relax-memory", OPT_SPIN_RELAXMEM},
    { "fast-inline-asm", OPT_FASTASM },
    { "peek-args", OPT_PEEK_ARGS },
    { "experimental", OPT_EXPERIMENTAL },
    { "all", OPT_FLAGS_ALL },
};
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))

int ParseOptimizeString(AST *line, const char *str, int *flag_ptr)
{
    int flags = *flag_ptr;
    int notflag;
    int bits, i;
    char buf_base[80];
    char *buf;
    
    if (!(*str)) {
        // default to -O2
        *flag_ptr = DEFAULT_ASM_OPTS | EXTRA_ASM_OPTS;
        return 1;
    }
    while (str && *str) {
        buf = buf_base;
        str = GetOptionString(buf, sizeof(buf_base), str);
        if (*buf == '!' || *buf == '~') {
            buf++;
            notflag = 1;
        } else if (buf[0] == 'n' && buf[1] == 'o' && buf[2] == '-') {
            buf += 3;
            notflag = 1;
        } else {
            notflag = 0;
        }
        if (*buf == 0) {
            continue;
        }
        /* basic values like -O1, -O2, etc */
        if (buf[1] == 0) {
            switch(buf[0]) {
            case '0':
                flags = MINIMAL_ASM_OPTS;
                continue;
            case '1':
                flags = DEFAULT_ASM_OPTS;
                continue;
            case 's':
                flags = DEFAULT_ASM_OPTS | OPT_EXTRASMALL | OPT_INLINE_SINGLEUSE;
                continue;
            case '2':
            case '3':
            case '4':
            case '5':
                flags = DEFAULT_ASM_OPTS | EXTRA_ASM_OPTS;
                continue;
            default:
                ERROR(line, "Unrecognized optimization set: %s", buf);
                return 0;
            }
        }
        bits = 0;
        for (i = 0; i < ARRAY_SIZE(optflag); i++) {
            if (!strcmp(optflag[i].name, buf)) {
                bits = optflag[i].bits;
                break;
            }
        }
        if (!bits) {
            WARNING(line, "Unrecognized optimization flag: %s", buf);
        }
        if (notflag) {
            flags &= ~bits;
        } else {
            flags |= bits;
        }
    }
    *flag_ptr = flags;
    return 1;
}

static FlagTable warnflag[] = {
    { "asm-usage", WARN_ASM_USAGE },
    { "c-const-strings", WARN_C_CONST_STRING },
    { "hide-members", WARN_HIDE_MEMBERS },
    { "init-vars", WARN_UNINIT_VARS },
    { "language-extensions", WARN_LANG_EXTENSIONS },
    { "language-version", WARN_LANG_VERSION },
    { "array-index", WARN_ARRAY_INDEX },
    { "deprecated", WARN_DEPRECATED },
    { "all", WARN_ALL },
};

int ParseWarnString(AST *line, const char *str, int *flag_ptr)
{
    int flags = *flag_ptr;
    int notflag;
    int bits, i;
    char buf_base[80];
    char *buf;
    
    if (!(*str)) {
        // default warnings
        *flag_ptr = DEFAULT_WARN_FLAGS;
        return 1;
    }
    while (str && *str) {
        buf = buf_base;
        str = GetOptionString(buf, sizeof(buf_base), str);
        if (*buf == '!' || *buf == '~') {
            buf++;
            notflag = 1;
        } else if (buf[0] == 'n' && buf[1] == 'o' && buf[2] == '-') {
            buf += 3;
            notflag = 1;
        } else {
            notflag = 0;
        }
        if (*buf == 0) {
            continue;
        }
        bits = 0;
        if (!strcmp(buf, "none")) {
            bits = WARN_ALL;
            notflag = true;
        } else {
            for (i = 0; i < ARRAY_SIZE(warnflag); i++) {
                if (!strcmp(warnflag[i].name, buf)) {
                    bits = warnflag[i].bits;
                    break;
                }
            }
        }
        if (!bits) {
            ERROR(line, "Unrecognized warning flag: %s", buf);
            return 0;
        }
        if (notflag) {
            flags &= ~bits;
        } else {
            flags |= bits;
        }
    }
    *flag_ptr = flags;
    return 1;
}

int
ParseWFlags(const char *flags) {
    if (!strcmp(flags, "error")) {
        gl_warnings_are_errors = 1;
    } else if (!strcmp(flags, "extra")) {
        /* ignore for now */
    } else if (!strcmp(flags, "abs-paths")) {
        gl_useFullPaths = 1;
    } else if (!strncmp(flags, "max-errors=", 11)) {
        int n = strtol(flags+11, NULL, 10);
        if (n < 1) {
            ERROR(NULL, "Unrecognized value `%s' for max-errors (must be at least 1)\n", flags+11);
            return 0;
        }
        gl_max_errors = n;
    } else {
        return ParseWarnString(NULL, flags, &gl_warn_flags);
    }
    return 1;
}

//
// check to see if the only Spin function in P would
// start the cog code, in which case we can leave off
// the Spin code entirely
//
static int TrivialSpinFunction(Module *P)
{
    Function *pf;
    AST *body;
    AST *expr;
    
    if (!P || !P->functions) {
        // no Spin functions at all!
        return 1;
    }
    pf = P->functions;
    if (pf->next) {
        // more than one function
        return 0;
    }
    body = pf->body;
    if (!body) {
        // hmmm odd, nothing in the Spin code at all?
        // punt, we are confused
        return 0;
    }
    if (body->kind != AST_STMTLIST) {
        return 0;
    }
    if (body->right != 0) {
        // more than one statement
        return 0;
    }
    body = body->left;
    
    while (body && body->kind == AST_COMMENTEDNODE) {
        body = body->left;
    }
    if (!body) {
        // odd, no spin code? punt
        return 0;
    }
    if (body->kind != AST_COGINIT) {
        return 0;
    }
    body = body->left;
    // now check the arguments
    // we want:
    //   coginit(0, @addr, 0)
    // where "addr" is a label

    // check first argument
    if (!body || body->kind != AST_EXPRLIST) return 0;
    expr = body->left;
    body = body->right;

    // check for 0
    if (!IsConstExpr(expr) || EvalConstExpr(expr) != 0) return 0;

    // check second argument
    if (!body || body->kind != AST_EXPRLIST) return 0;
    expr = body->left;
    body = body->right;

    // check for @
    if (expr->kind != AST_ADDROF && expr->kind == AST_ABSADDROF) return 0;
    
    // check third argument
    if (!body || body->kind != AST_EXPRLIST) return 0;
    expr = body->left;
    body = body->right;

    // check for 0
    if (!IsConstExpr(expr) || EvalConstExpr(expr) != 0) return 0;

    return 1;
}

//
// check for special defines like -D_BAUD=nnn
//
void check_special_define(const char *name, const char *def)
{
    int val;
    if (!strcmp(name, "_BAUD")) {
        val = strtoul(def, NULL, 0);
        gl_default_baud = val;
    } else if (!strcmp(name, "_XINFREQ")) {
        val = strtoul(def, NULL, 0);
        gl_default_xinfreq = val;
    } else if (!strcmp(name, "_XTLFREQ")) {
        val = strtoul(def, NULL, 0);
        gl_default_xtlfreq = val;
    }
}

//
// parse character set definition
//
int ParseCharset(int *var, const char *name)
{
    if (!strcasecmp(name, "utf8") || !strcasecmp(name, "utf-8")) {
        *var = CHARSET_UTF8;
        return 1;
    }
    if (!strcasecmp(name, "latin1") || !strcasecmp(name, "latin-1")) {
        *var = CHARSET_LATIN1;
        return 1;
    }
    if (!strcasecmp(name, "parallax") || !strcasecmp(name, "oem")) {
        *var = CHARSET_PARALLAX;
        return 1;
    }
    if (!strcasecmp(name, "shiftjis") || !strcasecmp(name, "shift-jis")) {
        *var = CHARSET_SHIFTJIS;
        return 1;
    }
    return 0;
}

//
// Add a source file to the internal list
//
SourceFile *sourceData = NULL;
int numSourceFiles = 0;
int maxSourceFiles = 0;
static char *sourcePrefix = NULL;

void InitSourceFiles() {
    sourceData = NULL;
    numSourceFiles = 0;
    maxSourceFiles = 0;
    sourcePrefix = NULL;
}

static bool IsSysFile(const char *name) {
    if (strstr(name, "../include/libc/")) return true;
    if (strstr(name, "../include/libsys/")) return true;
    return false;
}

void AddSourceFile(const char *shortName, const char *fullName)
{
    SourceFile *f;
    int i;
    // check for duplicate
    for (i = 0; i < numSourceFiles; i++) {
        f = &sourceData[i];
        if (!strcmp(f->fullName, fullName)) {
            return;
        }
    }
    // check for prefix for short name
    if (!sourcePrefix) {
        char *ptr;
        sourcePrefix = strdup(shortName);
        ptr = strrchr(sourcePrefix, '/');
#ifdef WIN32
        if (ptr && strrchr(ptr, '\\')) {
            ptr = strrchr(ptr, '\\');
        } else if (!ptr) {
            ptr = strrchr(sourcePrefix, '\\');
        }
#endif
        if (ptr) {
            ptr[1] = 0;
        } else {
            sourcePrefix[0] = 0;
        }
    }
        
    size_t n = strlen(sourcePrefix);
    if (n && !strncmp(shortName, sourcePrefix, n)) {
        shortName += n;
    }

    // OK, go ahead and add it
    if (numSourceFiles == maxSourceFiles) {
        maxSourceFiles += 1024;
        sourceData = (SourceFile *)realloc(sourceData, maxSourceFiles * sizeof(SourceFile));
        if (!sourceData) {
            fprintf(stderr, "Out of memory\n");
            exit(2);
        }
    }
    sourceData[numSourceFiles].shortName = shortName;
    sourceData[numSourceFiles].fullName = fullName;
    sourceData[numSourceFiles].isSysFile = IsSysFile(fullName);
    numSourceFiles++;
}

void PrintDependencies(const char *depname, const char *outname)
{
    FILE *outf = stdout;
    int i;
    SourceFile *F;
    
    if (depname) {
        outf = fopen(depname, "w");
    }
    fprintf(outf, "%s : ", outname);
    for (i = 0; i < numSourceFiles; i++) {
        F = &sourceData[i];
        if (F->isSysFile) continue;
        fprintf(outf, "%s ", F->shortName);
    }
    fprintf(outf, "\n");
}

void PrintSourceFiles(void)
{
    int i;
    SourceFile *F;
    for (i = 0; i < numSourceFiles; i++) {
        F = &sourceData[i];
//        printf("%s (%s)\n", F->shortName, F->fullName);
        if (F->isSysFile) continue;
        printf("%s\n", F->fullName);
    }
}