/**

 * 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

// !!! FIXME: no #define support yet.

typedef struct Context Context;

// Context...this is state that changes as we assemble a shader...

struct Context

{

    MOJOSHADER_malloc malloc;

    MOJOSHADER_free free;

    void *malloc_data;

    const char *failstr;

    const char *source;

    int started_parsing;

    MOJOSHADER_shaderType shader_type;

    uint8 major_ver;

    uint8 minor_ver;

    int on_endline;

    unsigned int linenum;

    char prevchar;

    char token[64];

    char pushedback;

    uint32 tokenbuf[16];

    int tokenbufpos;

    DestArgInfo dest_arg;

    uint32 *output;

    uint32 *token_to_line;

    size_t output_len;

    size_t output_allocation;

};

// Convenience functions for allocators...

static inline int out_of_memory(Context *ctx)

{

    if (ctx->failstr == NULL)

        ctx->failstr = out_of_mem_str;  // fail() would call malloc().

    return FAIL;

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

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

{

    if (ctx->failstr == NULL)  // don't change existing error.

    {

        char scratch = 0;

        va_list ap;

        va_start(ap, fmt);

        const int len = vsnprintf(&scratch, sizeof (scratch), fmt, ap);

        va_end(ap);

        char *failstr = (char *) Malloc(ctx, len + 1);

        if (failstr != NULL)

        {

            va_start(ap, fmt);

            vsnprintf(failstr, len + 1, fmt, ap);  // rebuild it.

            va_end(ap);

            ctx->failstr = failstr;

        } // if

    } // if

    return FAIL;

} // failf

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

{

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

} // fail

static inline int isfail(const Context *ctx)

{

    return (ctx->failstr != NULL);

} // isfail

// Shader model version magic...

static inline uint32 ver_ui32(const uint8 major, const uint8 minor)

{

    return ( (((uint32) major) << 16) | (((minor) == 0xFF) ? 0 : (minor)) );

} // version_ui32

static inline int shader_version_atleast(const Context *ctx, const uint8 maj,

                                         const uint8 min)

{

    return (ver_ui32(ctx->major_ver, ctx->minor_ver) >= ver_ui32(maj, min));

} // shader_version_atleast

static inline int shader_is_pixel(const Context *ctx)

{

    return (ctx->shader_type == MOJOSHADER_TYPE_PIXEL);

} // shader_is_pixel

static inline int shader_is_vertex(const Context *ctx)

{

    return (ctx->shader_type == MOJOSHADER_TYPE_VERTEX);

} // shader_is_vertex

static int ui32fromstr(const char *str, uint32 *ui32)

{

    //*ui32 = (uint32) atoi(minstr);

    char *endptr = NULL;

    const long val = strtol(str, &endptr, 10);

    *ui32 = (uint32) val;

    return ((val >= 0) && (*str != '\0') && (*endptr == '\0'));

} // ui32fromstr

static void output_token_noswap(Context *ctx, const uint32 token)

{

    if (isfail(ctx))

        return;

    if (ctx->output_len >= ctx->output_allocation)

    {

        const size_t output_alloc_bump = 1024;  // that's tokens, not bytes.

        const size_t newsize = ctx->output_allocation + output_alloc_bump;

        void *ptr;

        ptr = Malloc(ctx, newsize * sizeof (uint32));

        if (ptr == NULL)

            return;

        if (ctx->output_len > 0)

            memcpy(ptr, ctx->output, ctx->output_len * sizeof (uint32));

        Free(ctx, ctx->output);

        ctx->output = (uint32 *) ptr;

        ptr = Malloc(ctx, newsize * sizeof (uint32));

        if (ptr == NULL)

            return;

        if (ctx->output_len > 0)

            memcpy(ptr, ctx->token_to_line, ctx->output_len * sizeof (uint32));

        Free(ctx, ctx->token_to_line);

        ctx->token_to_line = (uint32 *) ptr;

        ctx->output_allocation = newsize;

    } // if

    ctx->output[ctx->output_len] = token;

    ctx->token_to_line[ctx->output_len] = ctx->linenum;

    ctx->output_len++;

} // output_token_noswap

static inline void output_token(Context *ctx, const uint32 token)

{

    output_token_noswap(ctx, SWAP32(token));

} // output_token

static void output_comment_bytes(Context *ctx, const uint8 *buf, size_t len)

{

    if (len > (0xFFFF * 4))  // length is stored as token count, in 16 bits.

        fail(ctx, "Comment field is too big");

    else if (!isfail(ctx))

    {

        const uint32 tokencount = (len / 4) + ((len % 4) ? 1 : 0);

        output_token(ctx, 0xFFFE | (tokencount << 16));

        while (len >= 4)

        {

            output_token_noswap(ctx, *((const uint32 *) buf));

            len -= 4;

            buf += 4;

        } // while

        if (len > 0)  // handle spillover...

        {

            union { uint8 ui8[4]; uint32 ui32; } overflow;

            overflow.ui32 = 0;

            memcpy(overflow.ui8, buf, len);

            output_token_noswap(ctx, overflow.ui32);

        } // if

    } // else if

} // output_comment_bytes

static inline void output_comment_string(Context *ctx, const char *str)

{

    output_comment_bytes(ctx, (const uint8 *) str, strlen(str));

} // output_comment_string

static int _tokenize(Context *ctx)

{

    int idx = 0;

    if (isfail(ctx))

        return FAIL;

    if (ctx->pushedback)

    {

        ctx->pushedback = 0;

        return NOFAIL;

    } // if

    if (ctx->on_endline)

    {

        ctx->on_endline = 0;

        ctx->linenum++;  // passed a newline, update.

    } // if

    while (1)

    {

        // !!! FIXME: carefully crafted (but legal) comments can trigger this.

        if (idx >= sizeof (ctx->token))

            return fail(ctx, "buffer overflow");

        char ch = *ctx->source;

        if (ch == '\t')

            ch = ' ';  // collapse tabs into single spaces.

        else if (ch == '\r')

        {

            if (ctx->source[1] == '\n')

               continue;  // ignore '\r' if this is "\r\n" ...

            ch = '\n';

        } // else if

        if ((ch >= '0') && (ch <= '9'))

        {

            // starting a number, but rest of current token was not number.

            if ((idx > 0) && ((ctx->prevchar < '0') || (ctx->prevchar > '9')))

            {

                ctx->token[idx++] = '\0';

                return NOFAIL;

            } // if

        } // if

        else

        {

            // starting a non-number, but rest of current token was numbers.

            if ((idx > 0) && ((ctx->prevchar >= '0') && (ctx->prevchar <= '9')))

            {

                ctx->token[idx++] = '\0';

                return NOFAIL;

            } // if

        } // else

        switch (ch)

        {

            case '/':

            case ';':  // !!! FIXME: comment, right?

                if (idx != 0)  // finish off existing token.

                    ctx->token[idx] = '\0';

                else

                {

                    ctx->token[idx++] = ch;

                    ctx->source++;

                    if ((ch == '/') && (*ctx->source == '/'))

                    {

                        ctx->token[idx++] = '/';

                        ctx->source++;

                    } // if

                    ctx->token[idx++] = '\0';

                } // else

                return NOFAIL;

            case ' ':

                if (ctx->prevchar == ' ')

                    break;   // multiple whitespace collapses into one.

                // intentional fall-through...

            case '_':

            case '[':

            case ']':

            case '(':

            case ')':

            case '!':

            case '+':

            case '-':

            case ',':

            case '.':

            case '\n':

                if (idx != 0)  // finish off existing token.

                    ctx->token[idx] = '\0';

                else  // this is a token in itself.

                {

                    if (ch == '\n')

                        ctx->on_endline = 1;

                    ctx->source++;

                    ctx->token[idx++] = ch;

                    ctx->token[idx++] = '\0';

                } // else

                return NOFAIL;

            case '\0':

                ctx->token[idx] = '\0';

                if (idx != 0)  // had any chars? It's a token.

                    return NOFAIL;

                return END_OF_STREAM;

            default:

                ctx->source++;

                ctx->token[idx++] = ch;

                break;

        } // switch

        ctx->prevchar = ch;

    } // while

    return fail(ctx, "???");  // shouldn't hit this.

} // _tokenize

static inline int tokenize(Context *ctx)

{

    const int rc = _tokenize(ctx);

    #if DEBUG_TOKENIZER

    printf("TOKENIZE: %s '%s'\n",

           (rc == END_OF_STREAM) ? "END_OF_STREAM" :

           (rc == FAIL) ? "FAIL" :

           (rc == NOFAIL) ? "NOFAIL" : "???",

           (ctx->token[0] == '\n') ? "\\n" : ctx->token);

    #endif

    return rc;

} // tokenize

static inline int pushback(Context *ctx)

{

    #if DEBUG_TOKENIZER

    printf("PUSHBACK\n");

    #endif

    if (ctx->pushedback)

        return fail(ctx, "BUG: Double pushback in parser");

    else

        ctx->pushedback = 1;

    return NOFAIL;

} // pushback

static int nexttoken(Context *ctx, const int ignoreeol,

                     const int ignorewhitespace, const int eolok,

                     const int eosok)

{

    int rc = NOFAIL;

    while ((rc = tokenize(ctx)) == NOFAIL)

    {

        if (strcmp(ctx->token, "\n") == 0)

        {

            if (ignoreeol)

                continue;

            else if (!eolok)

                return fail(ctx, "Unexpected EOL");

        } // if

        else if (strcmp(ctx->token, " ") == 0)

        {

            if (ignorewhitespace)

                continue;

        } // else if

        // skip comments...

        else if ((strcmp(ctx->token, "//") == 0) || (strcmp(ctx->token, ";") == 0))

        {

            while ((rc = tokenize(ctx)) == NOFAIL)

            {

                if (strcmp(ctx->token, "\n") == 0)

                {

                    pushback(ctx);

                    break;

                } // if

            } // while

            continue;  // pick up from newline, go again.

        } // if

        break;

    } // while

    #if DEBUG_TOKENIZER

    printf("NEXTTOKEN: %s '%s'\n",

           (rc == END_OF_STREAM) ? "END_OF_STREAM" :

           (rc == FAIL) ? "FAIL" :

           (rc == NOFAIL) ? "NOFAIL" : "???",

           (ctx->token[0] == '\n') ? "\\n" : ctx->token);

    #endif

    if ((rc == END_OF_STREAM) && (!eosok))

        return fail(ctx, "Unexpected EOF");

    return rc;

} // nexttoken

static int require_endline(Context *ctx)

{

    const int rc = nexttoken(ctx, 0, 1, 1, 1);

    if (rc == FAIL)

        return FAIL;

    else if (rc == END_OF_STREAM)

        return NOFAIL;  // we'll call this an EOL.

    else if (strcmp(ctx->token, "\n") != 0)

        return fail(ctx, "Endline expected");

    return NOFAIL;

} // require_endline

static int require_comma(Context *ctx)

{

    const int rc = nexttoken(ctx, 0, 1, 0, 0);

    if (rc == FAIL)

        return FAIL;

    else if (strcmp(ctx->token, ",") != 0)

        return fail(ctx, "Comma expected");

    return NOFAIL;

} // require_comma

static int parse_register_name(Context *ctx, RegisterType *rtype, int *rnum)

{

    if (nexttoken(ctx, 0, 1, 0, 0) == FAIL)

        return FAIL;

    // !!! FIXME: some of these registers are only valid for some shader types.

    int neednum = 1;

    int regnum = 0;

    const char *t = ctx->token;

    RegisterType regtype = REG_TYPE_TEMP;

    if (strcasecmp(t, "r") == 0)

        regtype = REG_TYPE_TEMP;

    else if (strcasecmp(t, "v") == 0)

        regtype = REG_TYPE_INPUT;

    else if (strcasecmp(t, "c") == 0)

        regtype = REG_TYPE_CONST;

    else if (strcasecmp(t, "i") == 0)

        regtype = REG_TYPE_CONSTINT;

    else if (strcasecmp(t, "b") == 0)

        regtype = REG_TYPE_CONSTBOOL;

    else if (strcasecmp(t, "oC") == 0)

        regtype = REG_TYPE_COLOROUT;

    else if (strcasecmp(t, "oDepth") == 0)

        regtype = REG_TYPE_DEPTHOUT;

    else if (strcasecmp(t, "s") == 0)

        regtype = REG_TYPE_SAMPLER;

    else if (strcasecmp(t, "oD") == 0)

        regtype = REG_TYPE_ATTROUT;

    else if (strcasecmp(t, "l") == 0)

        regtype = REG_TYPE_LABEL;

    else if (strcasecmp(t, "p") == 0)

        regtype = REG_TYPE_PREDICATE;

    else if (strcasecmp(t, "aL") == 0)

    {

        regtype = REG_TYPE_LOOP;

        neednum = 0;

    } // else if

    else if (strcasecmp(t, "o") == 0)

    {

        if (!shader_is_vertex(ctx) || !shader_version_atleast(ctx, 3, 0))

            return fail(ctx, "Output register not valid in this shader type");

        regtype = REG_TYPE_OUTPUT;

    } // else if

    else if (strcasecmp(t, "oT") == 0)

    {

        if (shader_is_vertex(ctx) && shader_version_atleast(ctx, 3, 0))

            return fail(ctx, "Output register not valid in this shader type");

        regtype = REG_TYPE_OUTPUT;

    } // else if

    else if (strcasecmp(t, "a") == 0)

    {

        if (!shader_is_vertex(ctx))

            return fail(ctx, "Address register only valid in vertex shaders.");

        regtype = REG_TYPE_ADDRESS;

    } // else if

    else if (strcasecmp(t, "t") == 0)

    {

        if (!shader_is_pixel(ctx))

            return fail(ctx, "Address register only valid in pixel shaders.");

        regtype = REG_TYPE_ADDRESS;

    } // else if

    else if (strcasecmp(t, "vPos") == 0)

    {

        regtype = REG_TYPE_MISCTYPE;

        regnum = (int) MISCTYPE_TYPE_POSITION;

        neednum = 0;

    } // else if

    else if (strcasecmp(t, "vFace") == 0)

    {

        regtype = REG_TYPE_MISCTYPE;

        regnum = (int) MISCTYPE_TYPE_FACE;

        neednum = 0;

    } // else if

    else if (strcasecmp(t, "oPos") == 0)

    {

        regtype = REG_TYPE_RASTOUT;

        regnum = (int) RASTOUT_TYPE_POSITION;

        neednum = 0;

    } // else if

    else if (strcasecmp(t, "oFog") == 0)

    {