/**

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

 */

// !!! FIXME: this needs to be split into separate source files:

// !!! FIXME:  parse, AST, IR, etc. The problem is we need to deal with the

// !!! FIXME:  "Context" struct being passed around everywhere.

#define __MOJOSHADER_INTERNAL__ 1

#include "mojoshader_internal.h"

#if DEBUG_COMPILER_PARSER

#define LEMON_SUPPORT_TRACING 1

#endif

// !!! FIXME: I'd like to lose this. It's really inefficient. Just keep a

// !!! FIXME:  (tail) on these list structures instead?

#define REVERSE_LINKED_LIST(typ, head) { \

    if ((head) && (head->next)) { \

        typ *tmp = NULL; \

        typ *tmp1 = NULL; \

        while (head != NULL) { \

            tmp = head; \

            head = head->next; \

            tmp->next = tmp1; \

            tmp1 = tmp; \

        } \

        head = tmp; \

    } \

}

static inline int operator_is_unary(const MOJOSHADER_astNodeType op)

{

    return ( (op > MOJOSHADER_AST_OP_START_RANGE_UNARY) &&

             (op < MOJOSHADER_AST_OP_END_RANGE_UNARY) );

} // operator_is_unary

static inline int operator_is_binary(const MOJOSHADER_astNodeType op)

{

    return ( (op > MOJOSHADER_AST_OP_START_RANGE_BINARY) &&

             (op < MOJOSHADER_AST_OP_END_RANGE_BINARY) );

} // operator_is_binary

static inline int operator_is_ternary(const MOJOSHADER_astNodeType op)

{

    return ( (op > MOJOSHADER_AST_OP_START_RANGE_TERNARY) &&

             (op < MOJOSHADER_AST_OP_END_RANGE_TERNARY) );

} // operator_is_ternary

typedef union TokenData

{

    int64 i64;

    double dbl;

    const char *string;

    const MOJOSHADER_astDataType *datatype;

} TokenData;

// This tracks data types and variables, and notes when they enter/leave scope.

typedef struct SymbolScope

{

    const char *symbol;

    const MOJOSHADER_astDataType *datatype;

    int index;  // unique positive value within a function, negative if global.

    int referenced;  // non-zero if something looked for this symbol (so we know it's used).

    struct SymbolScope *next;

} SymbolScope;

typedef struct SymbolMap

{

    HashTable *hash;

    SymbolScope *scope;

} SymbolMap;

typedef struct LoopLabels

{

    int start;  // loop's start label during IR build.

    int end;    // loop's end label during IR build.

    struct LoopLabels *prev;

} LoopLabels;

// Compile state, passed around all over the place.

typedef struct Context

{

    int isfail;

    int out_of_memory;

    MOJOSHADER_malloc malloc;

    MOJOSHADER_free free;

    void *malloc_data;

    ErrorList *errors;

    ErrorList *warnings;

    StringCache *strcache;

    const char *sourcefile;  // current source file that we're parsing.

    unsigned int sourceline; // current line in sourcefile that we're parsing.

    SymbolMap usertypes;

    SymbolMap variables;

    MOJOSHADER_astNode *ast;  // Abstract Syntax Tree

    const char *source_profile;

    int is_func_scope; // non-zero if semantic analysis is in function scope.

    int loop_count;

    int switch_count;

    int var_index;  // next variable index for current function.

    int global_var_index;  // next variable index for global scope.

    int user_func_index;  // next function index for user-defined functions.

    int intrinsic_func_index;  // next function index for intrinsic functions.

    MOJOSHADER_irStatement **ir;  // intermediate representation.

    int ir_label_count;  // next unused IR label index.

    int ir_temp_count;  // next unused IR temporary value index.

    int ir_end; // current function's end label during IR build.

    int ir_ret; // temp that holds current function's retval during IR build.

    LoopLabels *ir_loop;  // nested loop boundary labels during IR build.

    // Cache intrinsic types for fast lookup and consistent pointer values.

    MOJOSHADER_astDataType dt_none;

    MOJOSHADER_astDataType dt_bool;

    MOJOSHADER_astDataType dt_int;

    MOJOSHADER_astDataType dt_uint;

    MOJOSHADER_astDataType dt_float;

    MOJOSHADER_astDataType dt_float_snorm;

    MOJOSHADER_astDataType dt_float_unorm;

    MOJOSHADER_astDataType dt_half;

    MOJOSHADER_astDataType dt_double;

    MOJOSHADER_astDataType dt_string;

    MOJOSHADER_astDataType dt_sampler1d;

    MOJOSHADER_astDataType dt_sampler2d;

    MOJOSHADER_astDataType dt_sampler3d;

    MOJOSHADER_astDataType dt_samplercube;

    MOJOSHADER_astDataType dt_samplerstate;

    MOJOSHADER_astDataType dt_samplercompstate;

    MOJOSHADER_astDataType dt_buf_bool;

    MOJOSHADER_astDataType dt_buf_int;

    MOJOSHADER_astDataType dt_buf_uint;

    MOJOSHADER_astDataType dt_buf_half;

    MOJOSHADER_astDataType dt_buf_float;

    MOJOSHADER_astDataType dt_buf_double;

    MOJOSHADER_astDataType dt_buf_float_snorm;

    MOJOSHADER_astDataType dt_buf_float_unorm;

    Buffer *garbage;  // this is sort of hacky.

} Context;

// !!! FIXME: cut and paste between every damned source file follows...

// !!! FIXME: We need to make some sort of ContextBase that applies to all

// !!! FIXME:  files and move this stuff to mojoshader_common.c ...

// 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 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 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 void failf(Context *ctx, const char *fmt, ...) ISPRINTF(2,3);

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

{

    ctx->isfail = 1;

    if (ctx->out_of_memory)

        return;

    va_list ap;

    va_start(ap, fmt);

    errorlist_add_va(ctx->errors, ctx->sourcefile, ctx->sourceline, fmt, ap);

    va_end(ap);

} // failf

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

{

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

} // fail

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

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

{

    if (ctx->out_of_memory)

        return;

    va_list ap;

    va_start(ap, fmt);

    errorlist_add_va(ctx->warnings, ctx->sourcefile, ctx->sourceline, fmt, ap);

    va_end(ap);

} // warnf

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

{

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

} // warn

static inline int isfail(const Context *ctx)

{

    return ctx->isfail;

} // isfail

static void symbolmap_nuke(const void *k, const void *v, void *d) {/*no-op*/}

static int create_symbolmap(Context *ctx, SymbolMap *map)

{

    // !!! FIXME: should compare string pointer, with string in cache.

    map->scope = NULL;

    map->hash = hash_create(ctx, hash_hash_string, hash_keymatch_string,

                            symbolmap_nuke, 1, MallocBridge, FreeBridge, ctx);

    return (map->hash != NULL);

} // create_symbolmap

static int datatypes_match(const MOJOSHADER_astDataType *a,

                           const MOJOSHADER_astDataType *b)

{

    int i;

    if (a == b)

        return 1;

    else if (a->type != b->type)

        return 0;

    switch (a->type)

    {

        case MOJOSHADER_AST_DATATYPE_STRUCT:

            if (a->structure.member_count != b->structure.member_count)

                return 0;

            for (i = 0; i < a->structure.member_count; i++)

            {

                if (!datatypes_match(a->structure.members[i].datatype,

                                     b->structure.members[i].datatype))

                    return 0;

                // stringcache'd, pointer compare is safe.

                else if (a->structure.members[i].identifier !=

                         b->structure.members[i].identifier)

                    return 0;

            } // for

            return 1;

        case MOJOSHADER_AST_DATATYPE_ARRAY:

            if (a->array.elements != b->array.elements)

                return 0;

            else if (!datatypes_match(a->array.base, b->array.base))

                return 0;

            return 1;

        case MOJOSHADER_AST_DATATYPE_VECTOR:

            if (a->vector.elements != b->vector.elements)

                return 0;

            else if (!datatypes_match(a->vector.base, b->vector.base))

                return 0;

            return 1;

        case MOJOSHADER_AST_DATATYPE_MATRIX:

            if (a->matrix.rows != b->matrix.rows)

                return 0;

            else if (a->matrix.columns != b->matrix.columns)

                return 0;

            else if (!datatypes_match(a->matrix.base, b->matrix.base))

                return 0;

            return 1;

        case MOJOSHADER_AST_DATATYPE_BUFFER:

            return datatypes_match(a->buffer.base, b->buffer.base);

        case MOJOSHADER_AST_DATATYPE_FUNCTION:

            if (a->function.num_params != b->function.num_params)

                return 0;

            else if (a->function.intrinsic != b->function.intrinsic)

                return 0;

            else if (!datatypes_match(a->function.retval, b->function.retval))

                return 0;

            for (i = 0; i < a->function.num_params; i++)

            {

                if (!datatypes_match(a->function.params[i], b->function.params[i]))

                    return 0;

            } // for

            return 1;

        case MOJOSHADER_AST_DATATYPE_USER:

            return 0;  // pointers must match, this clearly didn't.

        default:

            assert(0 && "unexpected case");

            return 0;

    } // switch

    return 0;

} // datatypes_match

static void push_symbol(Context *ctx, SymbolMap *map, const char *sym,

                        const MOJOSHADER_astDataType *dt, const int index,

                        const int check_dupes)

{

    if (ctx->out_of_memory)

        return;

    // Decide if this symbol is defined, and if it's in the current scope.

    SymbolScope *item = NULL;

    const void *value = NULL;

    if ((check_dupes) && (sym != NULL) && (hash_find(map->hash, sym, &value)))

    {

        // check the current scope for a dupe.

        // !!! FIXME: note current scope's starting index, see if found

        // !!! FIXME:  item is < index (and thus, a previous scope).

        item = map->scope;

        while ((item) && (item->symbol))

        {

            if ( ((const void *) item) == value )

            {

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

                return;

            } // if

            item = item->next;

        } // while

    } // if

    // Add the symbol to our map and scope stack.

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

    if (item == NULL)

        return;

    if (sym != NULL)  // sym can be NULL if we're pushing a new scope.

    {

        if (hash_insert(map->hash, sym, item) == -1)

        {

            Free(ctx, item);

            return;

        } // if

    } // if

    item->symbol = sym;  // cached strings, don't copy.

    item->index = index;

    item->datatype = dt;

    item->referenced = 0;

    item->next = map->scope;

    map->scope = item;

} // push_symbol

static void push_usertype(Context *ctx, const char *sym, const MOJOSHADER_astDataType *dt)

{

    if (sym != NULL)

    {

        MOJOSHADER_astDataType *userdt;

        userdt = (MOJOSHADER_astDataType *) Malloc(ctx, sizeof (*userdt));

        if (userdt != NULL)

        {

            // !!! FIXME: this is hacky.

            if (!buffer_append(ctx->garbage, &userdt, sizeof (userdt)))

            {

                Free(ctx, userdt);

                return;

            } // if

            userdt->type = MOJOSHADER_AST_DATATYPE_USER;

            userdt->user.details = dt;

            userdt->user.name = sym;

            dt = userdt;

        } // if

    } // if

    push_symbol(ctx, &ctx->usertypes, sym, dt, 0, 1);

} // push_usertype

static inline void push_variable(Context *ctx, const char *sym, const MOJOSHADER_astDataType *dt)

{

    int idx = 0;

    if (sym != NULL)

    {

        // leave space for individual member indexes. The IR will need this.

        int additional = 0;

        if (dt->type == MOJOSHADER_AST_DATATYPE_STRUCT)

            additional = dt->structure.member_count;

        if (ctx->is_func_scope)

        {

            idx = ++ctx->var_index;  // these are positive.

            ctx->var_index += additional;

        } // if

        else

        {

            idx = --ctx->global_var_index;  // these are negative.

            ctx->global_var_index -= additional;

        } // else

    } // if

    push_symbol(ctx, &ctx->variables, sym, dt, idx, 1);

} // push_variable

static int push_function(Context *ctx, const char *sym,

                          const MOJOSHADER_astDataType *dt,

                          const int just_declare)

{

    // we don't have any reason to support nested functions at the moment,

    //  so this would be a bug.

    assert(!ctx->is_func_scope);

    assert(dt->type == MOJOSHADER_AST_DATATYPE_FUNCTION);

    // Functions are always global, so no need to search scopes.

    //  Functions overload, though, so we have to continue iterating to

    //  see if it matches anything.

    const void *value = NULL;

    void *iter = NULL;

    while (hash_iter(ctx->variables.hash, sym, &value, &iter))

    {

        // !!! FIXME: this breaks if you predeclare a function.

        // !!! FIXME:  (a declare AFTER defining works, though.)

        // there's already something called this.

        SymbolScope *item = (SymbolScope *) value;

        if (datatypes_match(dt, item->datatype))

        {

            if (!just_declare)

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

            return item->index;

        } // if

    } // while

    int idx = 0;

    if ((sym != NULL) && (dt != NULL))

    {

        if (!dt->function.intrinsic)

            idx = ++ctx->user_func_index;  // these are positive.

        else

            idx = --ctx->intrinsic_func_index;  // these are negative.

    } // if

    // push_symbol() doesn't check dupes, because we just did.

    push_symbol(ctx, &ctx->variables, sym, dt, idx, 0);

    return idx;

} // push_function

static inline void push_scope(Context *ctx)

{

    push_usertype(ctx, NULL, NULL);

    push_variable(ctx, NULL, NULL);

} // push_scope

static void pop_symbol(Context *ctx, SymbolMap *map)

{

    SymbolScope *item = map->scope;

    if (!item)

        return;

    if (item->symbol)

        hash_remove(map->hash, item->symbol);

    map->scope = item->next;

    Free(ctx, item);

} // pop_symbol

static void pop_symbol_scope(Context *ctx, SymbolMap *map)

{

    while ((map->scope) && (map->scope->symbol))

        pop_symbol(ctx, map);