/**

 * 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"

#define DEBUG_TOKENIZER 0

typedef struct DefineHash

{

    MOJOSHADER_preprocessorDefine define;

    struct DefineHash *next;

} DefineHash;

typedef struct Context

{

    int isfail;

    int out_of_memory;

    char failstr[128];

    IncludeState *include_stack;

    DefineHash *define_hashtable[256];

    int pushedback;

    const char *token;

    unsigned int tokenlen;

    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->isfail = 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);  // rebuild it.

    va_end(ap);

} // failf

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

{

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

} // fail

// 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

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

    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

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 = StrDup(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

    ctx->include_stack = state->next;

    Free(ctx, state->filename);

    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))

        {

            okay = 0;

            break;

        } // if

    } // for

    if ((okay) && (!push_source(ctx, fname, source, sourcelen, 0)))

        okay = 0;

    if (!okay)

    {

        preprocessor_end((Preprocessor *) ctx);

        return NULL;

    } // if

    return (Preprocessor *) ctx;

} // preprocessor_start

void preprocessor_end(Preprocessor *_ctx)

{

    Context *ctx = (Context *) _ctx;

    if (ctx == NULL)

        return;

    while (ctx->include_stack != NULL)

        pop_source(ctx);

    free_all_defines(ctx);

    Free(ctx, ctx);

} // preprocessor_end

const char *preprocessor_error(Preprocessor *_ctx)

{

    Context *ctx = (Context *) _ctx;

    if (ctx->isfail)

    {

        ctx->isfail = 0;

        return ctx->failstr;

    } // if

    return NULL;

} // preprocessor_error

int preprocessor_outofmemory(Preprocessor *_ctx)

{

    Context *ctx = (Context *) _ctx;

    return ctx->out_of_memory;

} // preprocessor_outofmemory

static inline const char *_preprocessor_nexttoken(Preprocessor *_ctx,

                                             unsigned int *_len, Token *_token)

{

    Context *ctx = (Context *) _ctx;

    while (1)

    {

        IncludeState *state = ctx->include_stack;

        if (state == NULL)

        {

            *_token = TOKEN_EOI;

            *_len = 0;

            return NULL;  // we're done!

        } // if

        Token token = preprocessor_internal_lexer(state);

        if (token == TOKEN_EOI)

        {

            assert(state->bytes_left == 0);

            pop_source(ctx);

            continue;  // pick up again after parent's #include line.

        } // if

        else if (token == TOKEN_PP_INCOMPLETE_COMMENT)

        {

            fail(ctx, "Incomplete multiline comment");

            continue;  // !!! FIXME: we should probably return TOKEN_ERROR or something.

        } // else if

        *_token = token;

        *_len = (unsigned int) (state->source - state->token);

        return state->token;

    } // while

    assert(0 && "shouldn't hit this code");

    *_token = TOKEN_UNKNOWN;

    *_len = 0;

    return NULL;

} // _preprocessor_nexttoken

const char *preprocessor_nexttoken(Preprocessor *ctx, unsigned int *len,

                                   Token *token)

{

    const char *retval = _preprocessor_nexttoken(ctx, len, token);

    #if DEBUG_TOKENIZER

    printf("PREPROCESSOR TOKEN: \"");

    unsigned int i;

    for (i = 0; i < *len; i++)

    {

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

            printf("\\n");

        else

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

    } // for

    printf("\" (");

    switch (*token)

    {

        #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_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_PP_INCOMPLETE_COMMENT);

        TOKENCASE(TOKEN_EOI);

        #undef TOKENCASE

        case ((Token) '\n'):

            printf("'\\n'");

            break;

        default:

            assert(((int)*token) < 256);

            printf("'%c'", (char) *token);

            break;

    } // switch

    printf(")\n");

    #endif

    return retval;

} // preprocessor_nexttoken

const char *preprocessor_sourcepos(Preprocessor *_ctx, unsigned int *pos)

{

    Context *ctx = (Context *) _ctx;

    if (ctx->include_stack == NULL)

    {

        *pos = 0;

        return NULL;

    } // if

    *pos = ctx->include_stack->line;

    return ctx->include_stack->filename;

} // preprocessor_sourcepos

// public API...

static const MOJOSHADER_preprocessData out_of_mem_data_preprocessor = {

    1, &MOJOSHADER_out_of_mem_error, 0, 0, 0, 0, 0

};

#define BUFFER_LEN (64 * 1024)

typedef struct BufferList

{

    char buffer[BUFFER_LEN];

    size_t bytes;

    struct BufferList *next;

} BufferList;

typedef struct Buffer

{

    size_t total_bytes;

    BufferList head;

    BufferList *tail;

} Buffer;

static void buffer_init(Buffer *buffer)

{

    buffer->total_bytes = 0;

    buffer->head.bytes = 0;

    buffer->head.next = NULL;

    buffer->tail = &buffer->head;

} // buffer_init

static int add_to_buffer(Buffer *buffer, const char *data,

                         size_t len, MOJOSHADER_malloc m, void *d)

{

    buffer->total_bytes += len;

    while (len > 0)

    {

        const size_t avail = BUFFER_LEN - buffer->tail->bytes;

        const size_t cpy = (avail > len) ? len : avail;

        memcpy(buffer->tail->buffer + buffer->tail->bytes, data, cpy);

        len -= cpy;

        data += cpy;

        buffer->tail->bytes += cpy;

        assert(buffer->tail->bytes <= BUFFER_LEN);

        if (buffer->tail->bytes == BUFFER_LEN)

        {

            BufferList *item = (BufferList *) m(sizeof (BufferList), d);

            if (item == NULL)

                return 0;

            item->bytes = 0;

            item->next = NULL;

            buffer->tail->next = item;

            buffer->tail = item;

        } // if

    } // while

    return 1;

} // add_to_buffer

static int indent_buffer(Buffer *buffer, int n, int newline,