/**

 * 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_profile.h"

#pragma GCC visibility push(hidden)

// Common Utilities

void out_of_memory(Context *ctx)

{

    ctx->isfail = ctx->out_of_memory = 1;

} // out_of_memory

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

char *StrDup(Context *ctx, const char *str)

{

    char *retval = (char *) Malloc(ctx, strlen(str) + 1);

    if (retval != NULL)

        strcpy(retval, str);

    return retval;

} // StrDup

void Free(Context *ctx, void *ptr)

{

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

} // Free

void * MOJOSHADERCALL MallocBridge(int bytes, void *data)

{

    return Malloc((Context *) data, (size_t) bytes);

} // MallocBridge

void MOJOSHADERCALL FreeBridge(void *ptr, void *data)

{

    Free((Context *) data, ptr);

} // FreeBridge

// Jump between output sections in the context...

int set_output(Context *ctx, Buffer **section)

{

    // only create output sections on first use.

    if (*section == NULL)

    {

        *section = buffer_create(256, MallocBridge, FreeBridge, ctx);

        if (*section == NULL)

            return 0;

    } // if

    ctx->output = *section;

    return 1;

} // set_output

void push_output(Context *ctx, Buffer **section)

{

    assert(ctx->output_stack_len < (int) (STATICARRAYLEN(ctx->output_stack)));

    ctx->output_stack[ctx->output_stack_len] = ctx->output;

    ctx->indent_stack[ctx->output_stack_len] = ctx->indent;

    ctx->output_stack_len++;

    if (!set_output(ctx, section))

        return;

    ctx->indent = 0;

} // push_output

void pop_output(Context *ctx)

{

    assert(ctx->output_stack_len > 0);

    ctx->output_stack_len--;

    ctx->output = ctx->output_stack[ctx->output_stack_len];

    ctx->indent = ctx->indent_stack[ctx->output_stack_len];

} // pop_output

// Shader model version magic...

uint32 ver_ui32(const uint8 major, const uint8 minor)

{

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

} // version_ui32

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

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

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

int shader_is_pixel(const Context *ctx)

{

    return (ctx->shader_type == MOJOSHADER_TYPE_PIXEL);

} // shader_is_pixel

int shader_is_vertex(const Context *ctx)

{

    return (ctx->shader_type == MOJOSHADER_TYPE_VERTEX);

} // shader_is_vertex

// Fail...

int isfail(const Context *ctx)

{

    return ctx->isfail;

} // isfail

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

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

{

    ctx->isfail = 1;

    if (ctx->out_of_memory)

        return;

    // no filename at this level (we pass a NULL to errorlist_add_va()...)

    va_list ap;

    va_start(ap, fmt);

    errorlist_add_va(ctx->errors, NULL, ctx->current_position, fmt, ap);

    va_end(ap);

} // failf

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

{

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

} // fail

// Output Lines...

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

void output_line(Context *ctx, const char *fmt, ...)

{

    assert(ctx->output != NULL);

    if (isfail(ctx))

        return;  // we failed previously, don't go on...

    const int indent = ctx->indent;

    if (indent > 0)

    {

        char *indentbuf = (char *) alloca(indent);

        memset(indentbuf, '\t', indent);

        buffer_append(ctx->output, indentbuf, indent);

    } // if

    va_list ap;

    va_start(ap, fmt);

    buffer_append_va(ctx->output, fmt, ap);

    va_end(ap);

    buffer_append(ctx->output, ctx->endline, ctx->endline_len);

} // output_line

void output_blank_line(Context *ctx)

{

    assert(ctx->output != NULL);

    if (!isfail(ctx))

        buffer_append(ctx->output, ctx->endline, ctx->endline_len);

} // output_blank_line

// !!! FIXME: this is sort of nasty.

void floatstr(Context *ctx, char *buf, size_t bufsize, float f,

              int leavedecimal)

{

    const size_t len = MOJOSHADER_printFloat(buf, bufsize, f);

    if ((len+2) >= bufsize)

        fail(ctx, "BUG: internal buffer is too small");

    else

    {

        char *end = buf + len;

        char *ptr = strchr(buf, '.');

        if (ptr == NULL)

        {

            if (leavedecimal)

                strcat(buf, ".0");

            return;  // done.

        } // if

        while (--end != ptr)

        {

            if (*end != '0')

            {

                end++;

                break;

            } // if

        } // while

        if ((leavedecimal) && (end == ptr))

            end += 2;

        *end = '\0';  // chop extra '0' or all decimal places off.

    } // else

} // floatstr

// Deal with register lists...

static inline uint32 reg_to_ui32(const RegisterType regtype, const int regnum)

{

    return ( ((uint32) regnum) | (((uint32) regtype) << 16) );

} // reg_to_uint32

// !!! FIXME: ditch this for a hash table.

RegisterList *reglist_insert(Context *ctx, RegisterList *prev,

                             const RegisterType regtype,

                             const int regnum)

{

    const uint32 newval = reg_to_ui32(regtype, regnum);

    RegisterList *item = prev->next;

    while (item != NULL)

    {

        const uint32 val = reg_to_ui32(item->regtype, item->regnum);

        if (newval == val)

            return item;  // already set, so we're done.

        else if (newval < val)  // insert it here.

            break;

        else // if (newval > val)

        {

            // keep going, we're not to the insertion point yet.

            prev = item;

            item = item->next;

        } // else

    } // while

    // we need to insert an entry after (prev).

    item = (RegisterList *) Malloc(ctx, sizeof (RegisterList));

    if (item != NULL)

    {

        item->regtype = regtype;

        item->regnum = regnum;

        item->usage = MOJOSHADER_USAGE_UNKNOWN;

        item->index = 0;

        item->writemask = 0;

        item->misc = 0;

        item->written = 0;

        item->array = NULL;

        item->next = prev->next;

        prev->next = item;

    } // if

    return item;

} // reglist_insert

RegisterList *reglist_find(const RegisterList *prev,

                           const RegisterType rtype,

                           const int regnum)

{

    const uint32 newval = reg_to_ui32(rtype, regnum);

    RegisterList *item = prev->next;

    while (item != NULL)

    {

        const uint32 val = reg_to_ui32(item->regtype, item->regnum);

        if (newval == val)

            return item;  // here it is.

        else if (newval < val)  // should have been here if it existed.

            return NULL;

        else // if (newval > val)

            item = item->next;

    } // while

    return NULL;  // wasn't in the list.

} // reglist_find

RegisterList *set_used_register(Context *ctx,

                                const RegisterType regtype,

                                const int regnum,

                                const int written)

{

    RegisterList *reg = NULL;

    if ((regtype == REG_TYPE_COLOROUT) && (regnum > 0))

        ctx->have_multi_color_outputs = 1;

    reg = reglist_insert(ctx, &ctx->used_registers, regtype, regnum);

    if (reg && written)

        reg->written = 1;

    return reg;

} // set_used_register

void set_defined_register(Context *ctx, const RegisterType rtype,

                          const int regnum)

{

    reglist_insert(ctx, &ctx->defined_registers, rtype, regnum);

} // set_defined_register

// Writemasks

int writemask_xyzw(const int writemask)

{

    return (writemask == 0xF);  // 0xF == 1111. No explicit mask (full!).

} // writemask_xyzw

int writemask_xyz(const int writemask)

{

    return (writemask == 0x7);  // 0x7 == 0111. (that is: xyz)

} // writemask_xyz

int writemask_xy(const int writemask)

{

    return (writemask == 0x3);  // 0x3 == 0011. (that is: xy)

} // writemask_xy

int writemask_x(const int writemask)

{

    return (writemask == 0x1);  // 0x1 == 0001. (that is: x)

} // writemask_x

int writemask_y(const int writemask)

{

    return (writemask == 0x2);  // 0x2 == 0010. (that is: y)

} // writemask_y

int replicate_swizzle(const int swizzle)

{

    return ( (((swizzle >> 0) & 0x3) == ((swizzle >> 2) & 0x3)) &&

             (((swizzle >> 2) & 0x3) == ((swizzle >> 4) & 0x3)) &&

             (((swizzle >> 4) & 0x3) == ((swizzle >> 6) & 0x3)) );

} // replicate_swizzle

int no_swizzle(const int swizzle)

{

    return (swizzle == 0xE4);  // 0xE4 == 11100100 ... 0 1 2 3. No swizzle.

} // no_swizzle

int vecsize_from_writemask(const int m)

{

    return (m & 1) + ((m >> 1) & 1) + ((m >> 2) & 1) + ((m >> 3) & 1);

} // vecsize_from_writemask

void set_dstarg_writemask(DestArgInfo *dst, const int mask)

{

    dst->writemask = mask;

    dst->writemask0 = ((mask >> 0) & 1);

    dst->writemask1 = ((mask >> 1) & 1);

    dst->writemask2 = ((mask >> 2) & 1);

    dst->writemask3 = ((mask >> 3) & 1);

} // set_dstarg_writemask

// D3D stuff that's used in more than just the d3d profile...

int isscalar(Context *ctx, const MOJOSHADER_shaderType shader_type,

             const RegisterType rtype, const int rnum)

{

    const int uses_psize = ctx->uses_pointsize;

    const int uses_fog = ctx->uses_fog;

    if ( (rtype == REG_TYPE_OUTPUT) && ((uses_psize) || (uses_fog)) )

    {

        const RegisterList *reg = reglist_find(&ctx->attributes, rtype, rnum);

        if (reg != NULL)

        {

            const MOJOSHADER_usage usage = reg->usage;

            return ( (uses_psize && (usage == MOJOSHADER_USAGE_POINTSIZE)) ||

                     (uses_fog && (usage == MOJOSHADER_USAGE_FOG)) );

        } // if

    } // if

    return scalar_register(shader_type, rtype, rnum);

} // isscalar

const char *get_D3D_register_string(Context *ctx,

                                    RegisterType regtype,

                                    int regnum, char *regnum_str,

                                    size_t regnum_size)

{

    const char *retval = NULL;

    int has_number = 1;

    switch (regtype)

    {

        case REG_TYPE_TEMP:

            retval = "r";

            break;

        case REG_TYPE_INPUT:

            retval = "v";

            break;

        case REG_TYPE_CONST:

            retval = "c";

            break;

        case REG_TYPE_ADDRESS:  // (or REG_TYPE_TEXTURE, same value.)

            retval = shader_is_vertex(ctx) ? "a" : "t";

            break;

        case REG_TYPE_RASTOUT:

            switch ((RastOutType) regnum)

            {

                case RASTOUT_TYPE_POSITION: retval = "oPos"; break;

                case RASTOUT_TYPE_FOG: retval = "oFog"; break;

                case RASTOUT_TYPE_POINT_SIZE: retval = "oPts"; break;

            } // switch

            has_number = 0;

            break;

        case REG_TYPE_ATTROUT:

            retval = "oD";

            break;

        case REG_TYPE_OUTPUT: // (or REG_TYPE_TEXCRDOUT, same value.)

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

                retval = "o";

            else

                retval = "oT";

            break;

        case REG_TYPE_CONSTINT:

            retval = "i";

            break;

        case REG_TYPE_COLOROUT:

            retval = "oC";

            break;

        case REG_TYPE_DEPTHOUT:

            retval = "oDepth";

            has_number = 0;

            break;

        case REG_TYPE_SAMPLER:

            retval = "s";

            break;

        case REG_TYPE_CONSTBOOL:

            retval = "b";

            break;

        case REG_TYPE_LOOP:

            retval = "aL";

            has_number = 0;

            break;

        case REG_TYPE_MISCTYPE:

            switch ((const MiscTypeType) regnum)

            {

                case MISCTYPE_TYPE_POSITION: retval = "vPos"; break;

                case MISCTYPE_TYPE_FACE: retval = "vFace"; break;

            } // switch

            has_number = 0;

            break;

        case REG_TYPE_LABEL:

            retval = "l";

            break;

        case REG_TYPE_PREDICATE:

            retval = "p";

            break;

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

        default:

            fail(ctx, "unknown register type");

            retval = "???";

            has_number = 0;

            break;

    } // switch

    if (has_number)

        snprintf(regnum_str, regnum_size, "%u", (uint) regnum);

    else

        regnum_str[0] = '\0';

    return retval;

} // get_D3D_register_string

// !!! FIXME: These should stay in the mojoshader_profile_d3d file

// !!! FIXME: but ARB1 relies on them, so we have to move them here.

// !!! FIXME: If/when we kill off ARB1, we can move these back.

const char *get_D3D_varname_in_buf(Context *ctx, RegisterType rt,

                                   int regnum, char *buf,

                                   const size_t len)

{

    char regnum_str[16];

    const char *regtype_str = get_D3D_register_string(ctx, rt, regnum,

                                              regnum_str, sizeof (regnum_str));

    snprintf(buf,len,"%s%s", regtype_str, regnum_str);

    return buf;

} // get_D3D_varname_in_buf

const char *get_D3D_varname(Context *ctx, RegisterType rt, int regnum)

{

    char buf[64];

    get_D3D_varname_in_buf(ctx, rt, regnum, buf, sizeof (buf));

    return StrDup(ctx, buf);

} // get_D3D_varname

#pragma GCC visibility pop