/**

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

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;

    MOJOSHADER_shaderType shader_type;

    uint8 major_ver;

    uint8 minor_ver;

    unsigned int instruction_count;

    unsigned int linenum;

    char prevchar;

    char token[64];

    char pushedback;

    char pushback_token[64];

    uint32 tokenbuf[16];

    int tokenbufpos;

    int centroid_allowed;

    DestArgInfo dest_arg;

};

// Convenience functions for allocators...

static MOJOSHADER_assembleData out_of_mem_data = {

    "Out of memory", 0, 0, 0, MOJOSHADER_TYPE_UNKNOWN, 0, 0, 0, 0, 0

};

static const char *out_of_mem_str = "Out of memory";

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_supported(const uint8 maj, const uint8 min)

{

    return (ver_ui32(maj,min) <= ver_ui32(MAX_SHADER_MAJOR, MAX_SHADER_MINOR));

} // shader_version_supported

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_version_exactly(const Context *ctx, const uint8 maj,

                                         const uint8 min)

{

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

} // shader_version_exactly

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

extern void writeme(void);

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

{

    if (isfail(ctx))

        return;

    writeme();

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

    while (1)

    {

        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[1] == '/'))

                    {

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

                        ctx->source++;

                    } // if

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

                } // else

                return NOFAIL;

            case ' ':

                if (ctx->prevch == ' ')

                    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->linenum++;

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

    #endif

    return rc;

} // tokenize

static inline void pushback(Context *ctx)

{

    #if DEBUG_TOKENIZER

    printf("PUSHBACK\n");

    #endif

    if (ctx->pushedback)

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

    else

        ctx->pushedback = 1;

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

                    break;

            } // while

        } // 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);

    #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

// !!! FIXME: merge parse_* into mojoshader.c to reduce cut-and-paste.

// !!! FIXME:  we need to merge Context, which is the nastiest part.

static int set_result_shift(Context *ctx, DestArgInfo *info, const int val)

{

    if (info->result_shift != 0)

        return fail(ctx, "Multiple result shift modifiers");

    info->result_shift = val;

    return NOFAIL;

} // set_result_shift

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)

    {

        regtype = REG_TYPE_RASTOUT;

        regnum = (int) RASTOUT_TYPE_FOG;

        neednum = 0;

    } // else if

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

    {

        regtype = REG_TYPE_RASTOUT;

        regnum = (int) RASTOUT_TYPE_POINT_SIZE;

        neednum = 0;

    } // else if

    //case REG_TYPE_TEMPFLOAT16:  // !!! FIXME: don't know this asm string

    else

    {

        return fail(ctx, "expected register type");

    } // else

    if (neednum)

    {

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

            return FAIL;

        //minor = atoi(ctx->token);

        char *endptr = NULL;

        const long val = strtol(ctx->token, &endptr, 10);

        regnum = (int) val;

        if ((*ctx->token == '\0') || (*endptr != '\0'))

            return fail(ctx, "Invalid version string");

    } // if

    // split up REG_TYPE_CONST

    if (regtype == REG_TYPE_CONST)

    {

        if (regnum < 2048)

        {

            regtype = REG_TYPE_CONST;

            regnum -= 0;

        } // if

        else if (regnum < 4096)

        {

            regtype = REG_TYPE_CONST2;

            regnum -= 2048;