/**

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

    const char *current_file;

    int current_position;

    ErrorList *errors;

    Preprocessor *preprocessor;

    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;

    Buffer *output;

    Buffer *token_to_source;

    Buffer *ctab;

} 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->current_file, ctx->current_position, 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))

            {

                ctx->tokenval = TOKEN_EOI;

                ctx->token = NULL;

                ctx->tokenlen = 0;

                break;

            } // if

            unsigned int line;

            ctx->current_file = preprocessor_sourcepos(ctx->preprocessor,&line);

            ctx->current_position = (int) line;

            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

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

{

    if (!isfail(ctx))

    {

        buffer_append(ctx->output, &token, sizeof (token));

        // We only need a list of these that grows throughout processing, and

        //  is flattened for reference at the end of the run, so we use a

        //  Buffer. It's sneaky!

        unsigned int pos = 0;

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

        SourcePos srcpos;

        memset(&srcpos, '\0', sizeof (SourcePos));

        srcpos.line = pos;

        srcpos.filename = fname;  // cached in preprocessor!

        buffer_append(ctx->token_to_source, &srcpos, sizeof (SourcePos));

    } // if

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

    {

        const int tlen = ctx->tokenlen;  // we need to protect this for later.

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

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

        pushback(ctx);

        ctx->tokenlen = tlen;

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

    {

        if (regnum < 2048)

        {

            regtype = REG_TYPE_CONST;

            regnum -= 0;

        } // if

        else if (regnum < 4096)

        {

            regtype = REG_TYPE_CONST2;

            regnum -= 2048;

        } // if

        else if (regnum < 6144)

        {

            regtype = REG_TYPE_CONST3;

            regnum -= 4096;

        } // if

        else if (regnum < 8192)

        {

            regtype = REG_TYPE_CONST4;

            regnum -= 6144;

        } // if

        else

        {

            fail(ctx, "Invalid const register index");

        } // else

    } // if

    *rtype = regtype;

    *rnum = regnum;

    return 1;

} // parse_register_name

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

{

    if (info->result_shift != 0)

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

    info->result_shift = val;

} // set_result_shift

static inline int tokenbuf_overflow(Context *ctx)

{

    if ( ctx->tokenbufpos >= ((int) (STATICARRAYLEN(ctx->tokenbuf))) )

    {

        fail(ctx, "Too many tokens");

        return 1;

    } // if

    return 0;

} // tokenbuf_overflow