/**

 * 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

#if DEBUG_LEXER

static Token debug_preprocessor_lexer(IncludeState *s)

{

    const Token retval = preprocessor_lexer(s);

    MOJOSHADER_print_debug_token("LEXER", s->token, s->tokenlen, retval);

    return retval;

} // debug_preprocessor_lexer

#define preprocessor_lexer(s) debug_preprocessor_lexer(s)

#endif

#if DEBUG_TOKENIZER

static void print_debug_lexing_position(IncludeState *s)

{

    if (s != NULL)

        printf("NOW LEXING %s:%d ...\n", s->filename, s->line);

} // print_debug_lexing_position

#else

#define print_debug_lexing_position(s)

#endif

typedef struct Context

{

    int isfail;

    int out_of_memory;

    char failstr[256];

    int recursion_count;

    int asm_comments;

    int parsing_pragma;

    Conditional *conditional_pool;

    IncludeState *include_stack;

    IncludeState *include_pool;

    Define *define_hashtable[256];

    Define *define_pool;

    Define *file_macro;

    Define *line_macro;

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

{

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

} // Free

static void *MallocBridge(int bytes, void *data)

{

    return Malloc((Context *) data, (size_t) bytes);

} // MallocBridge

static void FreeBridge(void *ptr, void *data)

{

    Free((Context *) data, ptr);

} // FreeBridge

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 if (token[i] == '\\')

            printf("\\\\");

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

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

        TOKENCASE(TOKEN_INCOMPLETE_COMMENT);

        TOKENCASE(TOKEN_BAD_CHARS);

        TOKENCASE(TOKEN_SINGLE_COMMENT);

        TOKENCASE(TOKEN_MULTI_COMMENT);

        TOKENCASE(TOKEN_EOI);

        TOKENCASE(TOKEN_PREPROCESSING_ERROR);

        #undef TOKENCASE

        case ((Token) '\n'):

            printf("'\\n'");

            break;

        case ((Token) '\\'):

            printf("'\\\\'");

            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

    WCHAR wpath[MAX_PATH];

    if (!MultiByteToWideChar(CP_UTF8, 0, fname, -1, wpath, MAX_PATH))

        return 0;

    const DWORD share = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;

    const HANDLE handle = CreateFileW(wpath, FILE_GENERIC_READ, share,

                                      NULL, OPEN_EXISTING, NULL, NULL);

    if (handle == INVALID_HANDLE_VALUE)

        return 0;

    const DWORD fileSize = GetFileSize(handle, NULL);

    if (fileSize == INVALID_FILE_SIZE)

    {

        CloseHandle(handle);

        return 0;

    } // if

    char *data = (char *) m(fileSize, d);

    if (data == NULL)

    {

        CloseHandle(handle);

        return 0;

    } // if

    DWORD readLength = 0;

    if (!ReadFile(handle, data, fileSize, &readLength, NULL))

    {

        CloseHandle(handle);

        f(data, d);

        return 0;

    } // if

    CloseHandle(handle);

    if (readLength != fileSize)

    {

        f(data, d);

        return 0;

    } // if

    *outdata = data;

    *outbytes = fileSize;

    return 1;

#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

// !!! FIXME: maybe use these pool magic elsewhere?

// !!! FIXME: maybe just get rid of this? (maybe the fragmentation isn't a big deal?)

// Pool stuff...

// ugh, I hate this macro salsa.

#define FREE_POOL(type, poolname) \

    static void free_##poolname##_pool(Context *ctx) { \

        type *item = ctx->poolname##_pool; \

        while (item != NULL) { \

            type *next = item->next; \

            Free(ctx, item); \

            item = next; \

        } \

    }

#define GET_POOL(type, poolname) \

    static type *get_##poolname(Context *ctx) { \

        type *retval = ctx->poolname##_pool; \

        if (retval != NULL) \

            ctx->poolname##_pool = retval->next; \

        else \

            retval = (type *) Malloc(ctx, sizeof (type)); \

        if (retval != NULL) \

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

        return retval; \

    }

#define PUT_POOL(type, poolname) \

    static void put_##poolname(Context *ctx, type *item) { \

        item->next = ctx->poolname##_pool; \

        ctx->poolname##_pool = item; \

    }

#define IMPLEMENT_POOL(type, poolname) \

    FREE_POOL(type, poolname) \

    GET_POOL(type, poolname) \

    PUT_POOL(type, poolname)

IMPLEMENT_POOL(Conditional, conditional)

IMPLEMENT_POOL(IncludeState, include)

IMPLEMENT_POOL(Define, define)

// Preprocessor define hashtable stuff...

// !!! FIXME: why isn't this using mojoshader_common.c's code?

// this is djb's xor hashing function.

static inline uint32 hash_string_djbxor(const char *sym)

{

    register uint32 hash = 5381;

    while (*sym)

        hash = ((hash << 5) + hash) ^ *(sym++);

    return hash;

} // hash_string_djbxor

static inline uint8 hash_define(const char *sym)

{

    return (uint8) hash_string_djbxor(sym);

} // hash_define

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

                      char **parameters, int paramcount)

{

    const uint8 hash = hash_define(sym);

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

    while (bucket)

    {

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

        {

            failf(ctx, "'%s' already defined", sym); // !!! FIXME: warning?

            // !!! FIXME: gcc reports the location of previous #define here.

            return 0;

        } // if

        bucket = bucket->next;

    } // while

    bucket = get_define(ctx);

    if (bucket == NULL)

        return 0;

    bucket->definition = val;

    bucket->original = NULL;

    bucket->identifier = sym;

    bucket->parameters = (const char **) parameters;

    bucket->paramcount = paramcount;

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

    ctx->define_hashtable[hash] = bucket;

    return 1;

} // add_define

static void free_define(Context *ctx, Define *def)

{

    if (def != NULL)

    {

        int i;

        for (i = 0; i < def->paramcount; i++)

            Free(ctx, (void *) def->parameters[i]);

        Free(ctx, (void *) def->parameters);

        Free(ctx, (void *) def->identifier);

        Free(ctx, (void *) def->definition);

        Free(ctx, (void *) def->original);

        put_define(ctx, def);

    } // if

} // free_define

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

{

    const uint8 hash = hash_define(sym);

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

    Define *prev = NULL;

    while (bucket)

    {

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

        {

            if (prev == NULL)

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

            else

                prev->next = bucket->next;

            free_define(ctx, bucket);

            return 1;

        } // if

        prev = bucket;

        bucket = bucket->next;

    } // while

    return 0;

} // remove_define

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

{

    const uint8 hash = hash_define(sym);

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

    while (bucket)

    {

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

            return bucket;

        bucket = bucket->next;

    } // while

    const uint8 filestrhash = 67;

    assert(hash_define("__FILE__") == filestrhash);

    const uint8 linestrhash = 75;

    assert(hash_define("__LINE__") == linestrhash);

    if ( (hash == filestrhash) && (ctx->file_macro) && (strcmp(sym, "__FILE__") == 0) )

    {

        Free(ctx, (char *) ctx->file_macro->definition);

        const IncludeState *state = ctx->include_stack;

        const char *fname = state ? state->filename : "";

        const size_t len = strlen(fname) + 2;

        char *str = (char *) Malloc(ctx, len);

        if (!str)

            return NULL;

        str[0] = '\"';

        memcpy(str + 1, fname, len - 2);

        str[len - 1] = '\"';

        ctx->file_macro->definition = str;

        return ctx->file_macro;

    } // if

    else if ( (hash == linestrhash) && (ctx->line_macro) && (strcmp(sym, "__LINE__") == 0) )

    {

        Free(ctx, (char *) ctx->line_macro->definition);

        const IncludeState *state = ctx->include_stack;

        const size_t bufsize = 32;

        char *str = (char *) Malloc(ctx, bufsize);

        if (!str)

            return 0;

        const size_t len = snprintf(str, bufsize, "%u", state->line);

        assert(len < bufsize); (void) len;

        ctx->line_macro->definition = str;

        return ctx->line_macro;

    } // else

    return NULL;

} // find_define

static const Define *find_define_by_token(Context *ctx)

{

    IncludeState *state = ctx->include_stack;

    assert(state->tokenval == TOKEN_IDENTIFIER);

    char *sym = (char *) alloca(state->tokenlen+1);

    memcpy(sym, state->token, state->tokenlen);

    sym[state->tokenlen] = '\0';

    return find_define(ctx, sym);

} // find_define_by_token

static const Define *find_macro_arg(const IncludeState *state,

                                    const Define *defines)