/**

 * 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 should probably use a formal grammar and not a hand-written

// !!! FIXME:  pile of C code.

#define __MOJOSHADER_INTERNAL__ 1

#include "mojoshader_internal.h"

#if !SUPPORT_PROFILE_BYTECODE

#error Shader assembler needs bytecode profile. Fix your build.

#endif

#if DEBUG_ASSEMBLER_PARSER

    #define print_debug_token(token, len, val) \

        MOJOSHADER_print_debug_token("ASSEMBLER", token, len, val)

#else

    #define print_debug_token(token, len, val)

#endif

typedef struct SourcePos

{

    const char *filename;

    uint32 line;

} SourcePos;

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

typedef struct Context

{

    int isfail;

    int out_of_memory;

    MOJOSHADER_malloc malloc;

    MOJOSHADER_free free;

    void *malloc_data;

    ErrorList *errors;

    Preprocessor *preprocessor;

    MOJOSHADER_parsePhase parse_phase;

    MOJOSHADER_shaderType shader_type;

    uint8 major_ver;

    uint8 minor_ver;

    int pushedback;

    const char *token;      // assembler token!

    unsigned int tokenlen;  // assembler token!

    Token tokenval;         // assembler token!

    uint32 version_token;   // bytecode token!

    uint32 tokenbuf[16];    // bytecode tokens!

    int tokenbufpos;        // bytecode tokens!

    DestArgInfo dest_arg;

    uint32 *output;

    SourcePos *token_to_source;

    uint8 *ctab;

    uint32 ctab_len;

    uint32 ctab_allocation;

    size_t output_len;

    size_t output_allocation;

} 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

// !!! FIXME: move the errpos calculation into Context, and we can move this

// !!! FIXME:  to mojoshader_common.c

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

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

{

    const char *fname = NULL;

    unsigned int linenum = 0;

    ctx->isfail = 1;

    if (ctx->out_of_memory)

        return;

    int errpos = 0;

    switch (ctx->parse_phase)

    {

        case MOJOSHADER_PARSEPHASE_NOTSTARTED:

            errpos = -2;

            break;

        case MOJOSHADER_PARSEPHASE_WORKING:

            fname = preprocessor_sourcepos(ctx->preprocessor, &linenum);

            errpos = (int) linenum;

            break;

        case MOJOSHADER_PARSEPHASE_DONE:

            errpos = -1;

            break;

        default:

            assert(0 && "Unexpected value");

            return;

    } // switch

    va_list ap;

    va_start(ap, fmt);

    errorlist_add_va(ctx->errors, fname, errpos, fmt, ap);

    va_end(ap);

} // failf

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

{

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

} // fail

static inline int isfail(const Context *ctx)

{

    return ctx->isfail;

} // 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 inline void pushback(Context *ctx)

{

    #if DEBUG_ASSEMBLER_PARSER

    printf("ASSEMBLER PUSHBACK\n");

    #endif

    assert(!ctx->pushedback);

    ctx->pushedback = 1;

} // pushback

static Token nexttoken(Context *ctx)

{

    if (ctx->pushedback)

        ctx->pushedback = 0;

    else

    {

        while (1)

        {

            ctx->token = preprocessor_nexttoken(ctx->preprocessor,

                                                &ctx->tokenlen,

                                                &ctx->tokenval);

            if (preprocessor_outofmemory(ctx->preprocessor))

            {

                out_of_memory(ctx);

                ctx->tokenval = TOKEN_EOI;

                ctx->token = NULL;

                ctx->tokenlen = 0;

                break;

            } // if

            else if (ctx->tokenval == TOKEN_BAD_CHARS)

            {

                fail(ctx, "Bad characters in source file");

                continue;

            } // else if

            else if (ctx->tokenval == TOKEN_PREPROCESSING_ERROR)

            {

                fail(ctx, ctx->token);

                continue;

            } // else if

            break;

        } // while

    } // else

    print_debug_token(ctx->token, ctx->tokenlen, ctx->tokenval);

    return ctx->tokenval;

} // nexttoken

// !!! FIXME: hashmap?

static inline void add_token_sourcepos(Context *ctx, const size_t idx)

{

    unsigned int pos = 0;

    const char *fname = preprocessor_sourcepos(ctx->preprocessor, &pos);

    ctx->token_to_source[idx].line = pos;

    ctx->token_to_source[idx].filename = fname;  // cached in preprocessor!

} // add_token_sourcepos

// !!! FIXME: use BufferList.

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

        if (ptr == NULL)

            return;

        if (ctx->output_len > 0)

            memcpy(ptr, ctx->token_to_source, ctx->output_len * sizeof (SourcePos));

        Free(ctx, ctx->token_to_source);

        ctx->token_to_source = (SourcePos *) ptr;

        ctx->output_allocation = newsize;

    } // if

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

    add_token_sourcepos(ctx, ctx->output_len);

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

        // !!! FIXME: we can probably just use use modulo and do this without

        // !!! FIXME:  a tight loop with BufferList.

        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 require_comma(Context *ctx)

{

    const Token token = nexttoken(ctx);

    if (token != ((Token) ','))

    {

        fail(ctx, "Comma expected");

        return 0;

    } // if

    return 1;

} // require_comma

static int check_token_segment(Context *ctx, const char *str)

{

    // !!! FIXME: these are case-insensitive, right?

    const size_t len = strlen(str);

    if ( (ctx->tokenlen < len) || (strncasecmp(ctx->token, str, len) != 0) )

        return 0;

    ctx->token += len;

    ctx->tokenlen -= len;

    return 1;

} // check_token_segment

static int check_token(Context *ctx, const char *str)

{

    const size_t len = strlen(str);

    if ( (ctx->tokenlen != len) || (strncasecmp(ctx->token, str, len) != 0) )

        return 0;

    ctx->token += len;

    ctx->tokenlen = 0;

    return 1;

} // check_token

static int ui32fromtoken(Context *ctx, uint32 *_val)

{

    unsigned int i;

    for (i = 0; i < ctx->tokenlen; i++)

    {

        if ((ctx->token[i] < '0') || (ctx->token[i] > '9'))

            break;

    } // for

    if (i == 0)

    {

        *_val = 0;

        return 0;

    } // if

    const unsigned int len = i;

    uint32 val = 0;

    uint32 mult = 1;

    while (i--)

    {

        val += ((uint32) (ctx->token[i] - '0')) * mult;

        mult *= 10;

    } // while

    ctx->token += len;

    ctx->tokenlen -= len;

    *_val = val;

    return 1;

} // ui32fromtoken

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

{

    if (nexttoken(ctx) != TOKEN_IDENTIFIER)

    {

        fail(ctx, "Expected register");

        return 0;

    } // if

    int neednum = 1;

    int regnum = 0;

    RegisterType regtype = REG_TYPE_TEMP;

    // Watch out for substrings! oDepth must be checked before oD, since

    //  the latter will match either case.

    if (check_token_segment(ctx, "oDepth"))

    {

        regtype = REG_TYPE_DEPTHOUT;

        neednum = 0;

    } // else if

    else if (check_token_segment(ctx, "vFace"))

    {

        regtype = REG_TYPE_MISCTYPE;

        regnum = (int) MISCTYPE_TYPE_FACE;

        neednum = 0;

    } // else if

    else if (check_token_segment(ctx, "vPos"))

    {

        regtype = REG_TYPE_MISCTYPE;

        regnum = (int) MISCTYPE_TYPE_POSITION;

        neednum = 0;

    } // else if

    else if (check_token_segment(ctx, "oPos"))

    {

        regtype = REG_TYPE_RASTOUT;

        regnum = (int) RASTOUT_TYPE_POSITION;

        neednum = 0;

    } // else if

    else if (check_token_segment(ctx, "oFog"))

    {

        regtype = REG_TYPE_RASTOUT;

        regnum = (int) RASTOUT_TYPE_FOG;

        neednum = 0;

    } // else if

    else if (check_token_segment(ctx, "oPts"))

    {

        regtype = REG_TYPE_RASTOUT;

        regnum = (int) RASTOUT_TYPE_POINT_SIZE;

        neednum = 0;

    } // else if

    else if (check_token_segment(ctx, "aL"))

    {

        regtype = REG_TYPE_LOOP;

        neednum = 0;

    } // else if

    else if (check_token_segment(ctx, "oC"))

        regtype = REG_TYPE_COLOROUT;

    else if (check_token_segment(ctx, "oT"))

        regtype = REG_TYPE_OUTPUT;

    else if (check_token_segment(ctx, "oD"))

        regtype = REG_TYPE_ATTROUT;

    else if (check_token_segment(ctx, "r"))

        regtype = REG_TYPE_TEMP;

    else if (check_token_segment(ctx, "v"))

        regtype = REG_TYPE_INPUT;

    else if (check_token_segment(ctx, "c"))

        regtype = REG_TYPE_CONST;

    else if (check_token_segment(ctx, "i"))

        regtype = REG_TYPE_CONSTINT;

    else if (check_token_segment(ctx, "b"))

        regtype = REG_TYPE_CONSTBOOL;

    else if (check_token_segment(ctx, "s"))

        regtype = REG_TYPE_SAMPLER;

    else if (check_token_segment(ctx, "l"))

        regtype = REG_TYPE_LABEL;

    else if (check_token_segment(ctx, "p"))

        regtype = REG_TYPE_PREDICATE;

    else if (check_token_segment(ctx, "o"))

        regtype = REG_TYPE_OUTPUT;

    else if (check_token_segment(ctx, "a"))

        regtype = REG_TYPE_ADDRESS;

    else if (check_token_segment(ctx, "t"))

        regtype = REG_TYPE_ADDRESS;

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

    else

    {

        fail(ctx, "expected register type");

        regtype = REG_TYPE_CONST;

        regnum = 0;

        neednum = 0;

    } // else

    // "c[5]" is the same as "c5", so if the token is done, see if next is '['.

    if ((neednum) && (ctx->tokenlen == 0))

    {

        if (nexttoken(ctx) == ((Token) '['))

            neednum = 0;  // don't need a number on register name itself.

        pushback(ctx);

    } // if

    if (neednum)

    {

        uint32 ui32 = 0;

        if (!ui32fromtoken(ctx, &ui32))

            fail(ctx, "Invalid register index");

        regnum = (int) ui32;

    } // if

    // split up REG_TYPE_CONST

    if (regtype == REG_TYPE_CONST)

    {