/*
 * Ficl softcore generator.
 * Generates both uncompressed and Lempel-Ziv compressed versions.
 * Strips blank lines, strips full-line comments, collapses whitespace.
 * Chops, blends, dices, makes julienne fries.
 *
 * Contributed by Larry Hastings, larry@hastings.org
 */
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "ficl.h"

#ifndef SOFTCORE_OUT
#define SOFTCORE_OUT    "softcore.c"
#endif

extern size_t
lz4_compress(void *s_start, void *d_start, size_t s_len, size_t d_len, int n);

void
fprintDataAsHex(FILE *f, unsigned char *data, int length)
{
        int i;
        while (length) {
                fprintf(f, "\t");
                for (i = 0; (i < 8) && length; i++) {
                        char buf[16];
                        /*
                         * if you don't do this little stuff, you get ugly
                         * sign-extended 0xFFFFFF6b crap.
                         */
                        sprintf(buf, "%08x", (unsigned int)*data++);
                        fprintf(f, "0x%s, ", buf + 6);
                        length--;
                }
                fprintf(f, "\n");
        }
}

void
fprintDataAsQuotedString(FILE *f, char *data)
{
        int lineIsBlank = 1; /* true */

        while (*data) {
                if (*data == '\n') {
                        if (!lineIsBlank)
                                fprintf(f, "\\n\"\n");
                        lineIsBlank = 1; /* true */
                } else {
                        if (lineIsBlank) {
                                fputc('\t', f);
                                fputc('"', f);
                                lineIsBlank = 0; /* false */
                        }

                        if (*data == '"')
                                fprintf(f, "\\\"");
                        else if (*data == '\\')
                                fprintf(f, "\\\\");
                        else
                                fputc(*data, f);
                }
                data++;
        }
        if (!lineIsBlank)
                fprintf(f, "\"");
}

int
main(int argc, char *argv[])
{
        char *uncompressed = (char *)malloc(128 * 1024);
        unsigned char *compressed = malloc(128 * 1024);
        char *trace = uncompressed;
        int i;
        size_t compressedSize = 128 * 1024;
        size_t uncompressedSize;
        char *src, *dst;
        FILE *f;
        time_t currentTimeT;
        struct tm *currentTime;
        char cleverTime[32];

        time(&currentTimeT);
        currentTime = localtime(&currentTimeT);
        strftime(cleverTime, sizeof (cleverTime),
            "%Y/%m/%d %H:%M:%S", currentTime);

        *trace++ = ' ';

        for (i = 1; i < argc; i++) {
                int size;
                /*
                 * This ensures there's always whitespace space between files.
                 * It *also* ensures that src[-1] is always safe in comment
                 * detection code below.  (Any leading whitespace will be
                 * thrown away in a later pass.)
                 * --lch
                 */
                *trace++ = ' ';

                f = fopen(argv[i], "rb");
                fseek(f, 0, SEEK_END);
                size = ftell(f);
                fseek(f, 0, SEEK_SET);
                fread(trace, 1, size, f);
                fclose(f);
                trace += size;
        }
        *trace = 0;

#define IS_EOL(x)       ((*x == '\n') || (*x == '\r'))
#define IS_EOL_COMMENT(x)       \
        (((x[0] == '\\') && isspace(x[1])) || \
        ((x[0] == '/') && (x[1] == '/') && isspace(x[2])))
#define IS_BLOCK_COMMENT(x)     \
        ((x[0] == '(') && isspace(x[1]) && isspace(x[-1]))

        src = dst = uncompressed;
        while (*src) {
                /* ignore leading whitespace, or entirely blank lines */
                while (isspace(*src))
                        src++;
                /* if the line is commented out */
                if (IS_EOL_COMMENT(src)) {
                        /* throw away this entire line */
                        while (*src && !IS_EOL(src))
                                src++;
                        continue;
                }
                /*
                 * This is where we'd throw away mid-line comments, but
                 * that's simply unsafe.  Things like
                 *      start-prefixes
                 *      : \ postpone \ ;
                 *      : ( postpone ( ;
                 * get broken that way.
                 * --lch
                 */
                while (*src && !IS_EOL(src)) {
                        *dst++ = *src++;
                }

                /* strip trailing whitespace */
                dst--;
                while (isspace(*dst))
                        dst--;
                dst++;

                /* and end the line */
                *dst++ = '\n';
        }

        *dst = 0;

        /*
         * now make a second pass to collapse all contiguous whitespace
         * to a single space.
         */
        src = dst = uncompressed;
        while (*src) {
                *dst++ = *src;
                if (!isspace(*src))
                        src++;
                else {
                        while (isspace(*src))
                                src++;
                }
        }
        *dst = 0;

        f = fopen(SOFTCORE_OUT, "wt");
        if (f == NULL) {
                printf("couldn't open " SOFTCORE_OUT
                    " for writing!  giving up.\n");
                exit(-1);
        }

        fprintf(f,
"/*\n"
"** Ficl softcore\n"
"** both uncompressed and LZ4 compressed versions.\n"
"**\n"
"** Generated %s\n"
"**/\n"
"\n"
"#include \"ficl.h\"\n"
"\n"
"\n", cleverTime);

        uncompressedSize = dst - uncompressed;
        compressedSize = lz4_compress(uncompressed, compressed,
            uncompressedSize, compressedSize, 0);

        fprintf(f, "static size_t ficlSoftcoreUncompressedSize = %d; "
            "/* not including trailing null */\n", uncompressedSize);
        fprintf(f, "\n");
        fprintf(f, "#if !FICL_WANT_LZ4_SOFTCORE\n");
        fprintf(f, "\n");
        fprintf(f, "static char ficlSoftcoreUncompressed[] =\n");
        fprintDataAsQuotedString(f, uncompressed);
        fprintf(f, ";\n");
        fprintf(f, "\n");
        fprintf(f, "#else /* !FICL_WANT_LZ4_SOFTCORE */\n");
        fprintf(f, "\n");
        fprintf(f, "extern int lz4_decompress(void *, void *, size_t, "
            "size_t, int);\n\n");
        fprintf(f, "static unsigned char ficlSoftcoreCompressed[%d] = "
            "{\n", compressedSize);
        fprintDataAsHex(f, compressed, compressedSize);
        fprintf(f, "\t};\n");
        fprintf(f, "\n");
        fprintf(f, "#endif /* !FICL_WANT_LZ4_SOFTCORE */\n");
        fprintf(f,
"\n"
"\n"
"void ficlSystemCompileSoftCore(ficlSystem *system)\n"
"{\n"
"    ficlVm *vm = system->vmList;\n"
"    int returnValue;\n"
"    ficlCell oldSourceID = vm->sourceId;\n"
"    ficlString s;\n"
"#if FICL_WANT_LZ4_SOFTCORE\n"
"    char *ficlSoftcoreUncompressed = malloc(ficlSoftcoreUncompressedSize+1);\n"
"    returnValue = lz4_decompress(ficlSoftcoreCompressed, "
"ficlSoftcoreUncompressed, sizeof(ficlSoftcoreCompressed), "
"ficlSoftcoreUncompressedSize+1, 0);\n"
"    FICL_VM_ASSERT(vm, returnValue == 0);\n"
"#endif /* FICL_WANT_LZ4_SOFTCORE */\n"
"    vm->sourceId.i = -1;\n"
"    FICL_STRING_SET_POINTER(s, (char *)(ficlSoftcoreUncompressed));\n"
"    FICL_STRING_SET_LENGTH(s, ficlSoftcoreUncompressedSize);\n"
"    returnValue = ficlVmExecuteString(vm, s);\n"
"    vm->sourceId = oldSourceID;\n"
"#if FICL_WANT_LZ4_SOFTCORE\n"
"    free(ficlSoftcoreUncompressed);\n"
"#endif /* FICL_WANT_LZ4_SOFTCORE */\n"
"    FICL_VM_ASSERT(vm, returnValue != FICL_VM_STATUS_ERROR_EXIT);\n"
"    return;\n"
"}\n\n"
"/* end-of-file */\n");
        free(uncompressed);
        free(compressed);
        return (0);
}