/**

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

#if DEBUG_ASSEMBLY_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;

    int error_count;

    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;

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

{

    if (ptr != NULL)  // check for NULL in case of dumb free() impl.

        ctx->free(ptr, ctx->malloc_data);

} // Free

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;

    int error_position = 0;

    ctx->isfail = 1;

    switch (ctx->parse_phase)

    {

        case MOJOSHADER_PARSEPHASE_NOTSTARTED:

            error_position = -2;

            break;

        case MOJOSHADER_PARSEPHASE_WORKING:

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

            error_position = (int) linenum;

            break;

        case MOJOSHADER_PARSEPHASE_DONE:

            error_position = -1;

            break;

        default:

            assert(0 && "Unexpected value");

            return;

    } // switch

    ErrorList *error = (ErrorList *) Malloc(ctx, sizeof (ErrorList));

    if (error == NULL)

        return;

    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)

        Free(ctx, error);

    else

    {

        va_start(ap, fmt);

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

        va_end(ap);

        error->error.error = failstr;

        error->error.filename = fname ? StrDup(ctx, fname) : NULL;

        error->error.error_position = error_position;

        error->next = NULL;

        ErrorList *prev = NULL;

        ErrorList *item = ctx->errors;

        while (item != NULL)

        {

            prev = item;

            item = item->next;

        } // while

        if (prev == NULL)

            ctx->errors = error;

        else

            prev->next = error;

        ctx->error_count++;

    } // else

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

    printf("ASSEMBLER PUSHBACK\n");

    #endif

    assert(!ctx->pushedback);

    ctx->pushedback = 1;

} // pushback

static Token _nexttoken(Context *ctx)

{

    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

        if (ctx->tokenval == TOKEN_PREPROCESSING_ERROR)

        {

            fail(ctx, ctx->token);

            continue;

        } // else

        break;

    } // while

    return ctx->tokenval;

} // _nexttoken

static Token nexttoken(Context *ctx)

{

    if (ctx->pushedback)

    {

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

        ctx->pushedback = 0;

        return ctx->tokenval;

    } // if

    Token token = _nexttoken(ctx);

    while (token == ((Token) '\n'))

        token = _nexttoken(ctx);  // skip endlines.

    if (token == ((Token) ';'))  // single line comment in assembler.

    {

        do

        {

            token = _nexttoken(ctx);

        } while ((token != ((Token) '\n')) && (token != TOKEN_EOI));

        while (token == ((Token) '\n'))

            token = _nexttoken(ctx);  // skip endlines.

    } // if

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

    return token;

} // nexttoken

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

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

        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)

{

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