/**

 * MojoShader; generate shader programs from bytecode of compiled

 *  Direct3D shaders.

 *

 * Please see the file LICENSE.txt in the source's root directory.

 *

 *  This file written by Ryan C. Gordon.

 */

#define __MOJOSHADER_INTERNAL__ 1

#include "mojoshader_internal.h"

#if DEBUG_PREPROCESSOR

    #define print_debug_token(token, len, val) \

        MOJOSHADER_print_debug_token("PREPROCESSOR", token, len, val)

#else

    #define print_debug_token(token, len, val)

#endif

typedef struct DefineHash

{

    MOJOSHADER_preprocessorDefine define;

    struct DefineHash *next;

} DefineHash;

// Simple linked list to cache source filenames, so we don't have to copy

//  the same string over and over for each opcode.

typedef struct FilenameCache

{

    char *filename;

    struct FilenameCache *next;

} FilenameCache;

typedef struct Context

{

    int isfail;

    int out_of_memory;

    char failstr[256];

    Conditional *conditional_pool;

    IncludeState *include_stack;

    DefineHash *define_hashtable[256];

    FilenameCache *filename_cache;

    MOJOSHADER_includeOpen open_callback;

    MOJOSHADER_includeClose close_callback;

    MOJOSHADER_malloc malloc;

    MOJOSHADER_free free;

    void *malloc_data;

} Context;

// Convenience functions for allocators...

static inline void out_of_memory(Context *ctx)

{

    ctx->out_of_memory = 1;

} // out_of_memory

static inline void *Malloc(Context *ctx, const size_t len)

{

    void *retval = ctx->malloc((int) len, ctx->malloc_data);

    if (retval == NULL)

        out_of_memory(ctx);

    return retval;

} // Malloc

static inline void Free(Context *ctx, void *ptr)

{

    if (ptr != NULL)  // check for NULL in case of dumb free() impl.

        ctx->free(ptr, ctx->malloc_data);

} // Free

static inline char *StrDup(Context *ctx, const char *str)

{

    char *retval = (char *) Malloc(ctx, strlen(str) + 1);

    if (retval != NULL)

        strcpy(retval, str);

    return retval;

} // StrDup

static void failf(Context *ctx, const char *fmt, ...) ISPRINTF(2,3);

static void failf(Context *ctx, const char *fmt, ...)

{

    ctx->isfail = 1;

    va_list ap;

    va_start(ap, fmt);

    vsnprintf(ctx->failstr, sizeof (ctx->failstr), fmt, ap);

    va_end(ap);

} // failf

static inline void fail(Context *ctx, const char *reason)

{

    failf(ctx, "%s", reason);

} // fail

#if DEBUG_TOKENIZER

void MOJOSHADER_print_debug_token(const char *subsystem, const char *token,

                                  const unsigned int tokenlen,

                                  const Token tokenval)

{

    printf("%s TOKEN: \"", subsystem);

    unsigned int i;

    for (i = 0; i < tokenlen; i++)

    {

        if (token[i] == '\n')

            printf("\\n");

        else

            printf("%c", token[i]);

    } // for

    printf("\" (");

    switch (tokenval)

    {

        #define TOKENCASE(x) case x: printf("%s", #x); break

        TOKENCASE(TOKEN_UNKNOWN);

        TOKENCASE(TOKEN_IDENTIFIER);

        TOKENCASE(TOKEN_INT_LITERAL);

        TOKENCASE(TOKEN_FLOAT_LITERAL);

        TOKENCASE(TOKEN_STRING_LITERAL);

        TOKENCASE(TOKEN_ADDASSIGN);

        TOKENCASE(TOKEN_SUBASSIGN);

        TOKENCASE(TOKEN_MULTASSIGN);

        TOKENCASE(TOKEN_DIVASSIGN);

        TOKENCASE(TOKEN_MODASSIGN);

        TOKENCASE(TOKEN_XORASSIGN);

        TOKENCASE(TOKEN_ANDASSIGN);

        TOKENCASE(TOKEN_ORASSIGN);

        TOKENCASE(TOKEN_INCREMENT);

        TOKENCASE(TOKEN_DECREMENT);

        TOKENCASE(TOKEN_RSHIFT);

        TOKENCASE(TOKEN_LSHIFT);

        TOKENCASE(TOKEN_ANDAND);

        TOKENCASE(TOKEN_OROR);

        TOKENCASE(TOKEN_LEQ);

        TOKENCASE(TOKEN_GEQ);

        TOKENCASE(TOKEN_EQL);

        TOKENCASE(TOKEN_NEQ);

        TOKENCASE(TOKEN_HASHHASH);

        TOKENCASE(TOKEN_PP_INCLUDE);

        TOKENCASE(TOKEN_PP_LINE);

        TOKENCASE(TOKEN_PP_DEFINE);

        TOKENCASE(TOKEN_PP_UNDEF);

        TOKENCASE(TOKEN_PP_IF);

        TOKENCASE(TOKEN_PP_IFDEF);

        TOKENCASE(TOKEN_PP_IFNDEF);

        TOKENCASE(TOKEN_PP_ELSE);

        TOKENCASE(TOKEN_PP_ELIF);

        TOKENCASE(TOKEN_PP_ENDIF);

        TOKENCASE(TOKEN_PP_ERROR);

        TOKENCASE(TOKEN_INCOMPLETE_COMMENT);

        TOKENCASE(TOKEN_BAD_CHARS);

        TOKENCASE(TOKEN_EOI);

        TOKENCASE(TOKEN_PREPROCESSING_ERROR);

        #undef TOKENCASE

        case ((Token) '\n'):

            printf("'\\n'");

            break;

        default:

            assert(((int)tokenval) < 256);

            printf("'%c'", (char) tokenval);

            break;

    } // switch

    printf(")\n");

} // MOJOSHADER_print_debug_token

#endif

#if !MOJOSHADER_FORCE_INCLUDE_CALLBACKS

// !!! FIXME: most of these _MSC_VER should probably be _WINDOWS?

#ifdef _MSC_VER

#define WIN32_LEAN_AND_MEAN 1

#include <windows.h>  // GL headers need this for WINGDIAPI definition.

#else

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#endif

int MOJOSHADER_internal_include_open(MOJOSHADER_includeType inctype,

                                     const char *fname, const char *parent,

                                     const char **outdata,

                                     unsigned int *outbytes,

                                     MOJOSHADER_malloc m, MOJOSHADER_free f,

                                     void *d)

{

#ifdef _MSC_VER

#error Write me.

#else

    struct stat statbuf;

    if (stat(fname, &statbuf) == -1)

        return 0;

    char *data = (char *) m(statbuf.st_size, d);

    if (data == NULL)

        return 0;

    const int fd = open(fname, O_RDONLY);

    if (fd == -1)

    {

        f(data, d);

        return 0;

    } // if

    if (read(fd, data, statbuf.st_size) != statbuf.st_size)

    {

        f(data, d);

        close(fd);

        return 0;

    } // if

    close(fd);

    *outdata = data;

    *outbytes = (unsigned int) statbuf.st_size;

    return 1;

#endif

} // MOJOSHADER_internal_include_open

void MOJOSHADER_internal_include_close(const char *data, MOJOSHADER_malloc m,

                                       MOJOSHADER_free f, void *d)

{

    f((void *) data, d);

} // MOJOSHADER_internal_include_close

#endif  // !MOJOSHADER_FORCE_INCLUDE_CALLBACKS

// Conditional pool stuff...

static void free_conditional_pool(Context *ctx)

{

    Conditional *item = ctx->conditional_pool;

    while (item != NULL)

    {

        Conditional *next = item->next;

        Free(ctx, item);

        item = next;

    } // while

} // free_conditional_pool

static Conditional *get_conditional(Context *ctx)

{

    Conditional *retval = ctx->conditional_pool;

    if (retval != NULL)

        ctx->conditional_pool = retval->next;

    else

        retval = (Conditional *) Malloc(ctx, sizeof (Conditional));

    if (retval != NULL)

        memset(retval, '\0', sizeof (Conditional));

    return retval;

} // get_conditional

static void put_conditionals(Context *ctx, Conditional *item)

{

    while (item != NULL)

    {

        Conditional *next = item->next;

        item->next = ctx->conditional_pool;

        ctx->conditional_pool = item;

        item = next;

    } // while

} // put_conditionals

// Preprocessor define hashtable stuff...

static unsigned char hash_define(const char *sym)

{

    unsigned char retval = 0;

    while (*sym)

        retval += *(sym++);

    return retval;

} // hash_define

static int add_define(Context *ctx, const char *sym, const char *val)

{

    char *identifier = NULL;

    char *definition = NULL;

    const unsigned char hash = hash_define(sym);

    DefineHash *bucket = ctx->define_hashtable[hash];

    while (bucket)

    {

        if (strcmp(bucket->define.identifier, sym) == 0)

        {

            failf(ctx, "'%s' already defined", sym);

            return 0;

        } // if

        bucket = bucket->next;

    } // while

    bucket = (DefineHash *) Malloc(ctx, sizeof (DefineHash));

    if (bucket == NULL)

        return 0;

    identifier = (char *) Malloc(ctx, strlen(sym) + 1);

    definition = (char *) Malloc(ctx, strlen(val) + 1);

    if ((identifier == NULL) || (definition == NULL))

    {

        Free(ctx, identifier);

        Free(ctx, definition);

        Free(ctx, bucket);

        return 0;

    } // if

    strcpy(identifier, sym);

    strcpy(definition, val);

    bucket->define.identifier = identifier;

    bucket->define.definition = definition;

    bucket->next = ctx->define_hashtable[hash];

    ctx->define_hashtable[hash] = bucket;

    return 1;

} // add_define

static int remove_define(Context *ctx, const char *sym)

{

    const unsigned char hash = hash_define(sym);

    DefineHash *bucket = ctx->define_hashtable[hash];

    DefineHash *prev = NULL;

    while (bucket)

    {

        if (strcmp(bucket->define.identifier, sym) == 0)

        {

            if (prev == NULL)

                ctx->define_hashtable[hash] = bucket->next;

            else

                prev->next = bucket->next;

            Free(ctx, (void *) bucket->define.identifier);

            Free(ctx, (void *) bucket->define.definition);

            Free(ctx, bucket);

            return 1;

        } // if

        prev = bucket;

        bucket = bucket->next;

    } // while

    return 0;

} // remove_define

static const char *find_define(Context *ctx, const char *sym)

{

    const unsigned char hash = hash_define(sym);

    DefineHash *bucket = ctx->define_hashtable[hash];

    while (bucket)

    {

        if (strcmp(bucket->define.identifier, sym) == 0)

            return bucket->define.definition;

        bucket = bucket->next;

    } // while

    return NULL;

} // find_define

static void free_all_defines(Context *ctx)

{

    int i;

    for (i = 0; i < STATICARRAYLEN(ctx->define_hashtable); i++)

    {

        DefineHash *bucket = ctx->define_hashtable[i];

        ctx->define_hashtable[i] = NULL;

        while (bucket)

        {

            DefineHash *next = bucket->next;

            Free(ctx, (void *) bucket->define.identifier);

            Free(ctx, (void *) bucket->define.definition);

            Free(ctx, bucket);

            bucket = next;

        } // while

    } // for

} // find_define

// filename cache stuff...

static const char *cache_filename(Context *ctx, const char *fname)

{

    if (fname == NULL)

        return NULL;

    // !!! FIXME: this could be optimized into a hash table, but oh well.

    FilenameCache *item = ctx->filename_cache;

    while (item != NULL)

    {

        if (strcmp(item->filename, fname) == 0)

            return item->filename;

        item = item->next;

    } // while

    // new cache item.

    item = (FilenameCache *) Malloc(ctx, sizeof (FilenameCache));

    if (item == NULL)

        return NULL;

    item->filename = StrDup(ctx, fname);

    if (item->filename == NULL)

    {

        Free(ctx, item);

        return NULL;

    } // if

    item->next = ctx->filename_cache;

    ctx->filename_cache = item;

    return item->filename;

} // cache_filename

static void free_filename_cache(Context *ctx)

{

    FilenameCache *item = ctx->filename_cache;

    while (item != NULL)

    {

        FilenameCache *next = item->next;

        Free(ctx, item->filename);

        Free(ctx, item);

        item = next;

    } // while

} // free_filename_cache

static int push_source(Context *ctx, const char *fname, const char *source,

                       unsigned int srclen, int included)

{

    IncludeState *state = (IncludeState *) Malloc(ctx, sizeof (IncludeState));

    if (state == NULL)

        return 0;

    memset(state, '\0', sizeof (IncludeState));

    if (fname != NULL)

    {

        state->filename = cache_filename(ctx, fname);

        if (state->filename == NULL)

        {

            Free(ctx, state);

            return 0;

        } // if

    } // if

    state->included = included;

    state->source_base = source;

    state->source = source;

    state->token = source;

    state->bytes_left = srclen;

    state->line = 1;

    state->next = ctx->include_stack;

    ctx->include_stack = state;

    return 1;

} // push_source

static void pop_source(Context *ctx)

{

    IncludeState *state = ctx->include_stack;

    if (state == NULL)

        return;

    if (state->included)

    {

        ctx->close_callback(state->source_base, ctx->malloc,

                            ctx->free, ctx->malloc_data);

    } // if

    // state->filename is a pointer to the filename cache; don't free it here!

    put_conditionals(ctx, state->conditional_stack);

    ctx->include_stack = state->next;

    Free(ctx, state);

} // pop_source

Preprocessor *preprocessor_start(const char *fname, const char *source,

                            unsigned int sourcelen,

                            MOJOSHADER_includeOpen open_callback,

                            MOJOSHADER_includeClose close_callback,

                            const MOJOSHADER_preprocessorDefine **defines,

                            unsigned int define_count,

                            MOJOSHADER_malloc m, MOJOSHADER_free f, void *d)

{

    int okay = 1;

    int i = 0;

    // the preprocessor is internal-only, so we verify all these are != NULL.

    assert(m != NULL);

    assert(f != NULL);

    assert(open_callback != NULL);

    assert(close_callback != NULL);

    Context *ctx = (Context *) m(sizeof (Context), d);

    if (ctx == NULL)

        return 0;

    memset(ctx, '\0', sizeof (Context));

    ctx->malloc = m;

    ctx->free = f;

    ctx->malloc_data = d;

    ctx->open_callback = open_callback;

    ctx->close_callback = close_callback;

    for (i = 0; i < define_count; i++)

    {

        if (!add_define(ctx, defines[i]->identifier, defines[i]->definition))