/**

 * 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 file really needs to be split up.

// !!! FIXME: I keep changing coding styles for symbols and typedefs.

// !!! FIXME: rules from MSDN about temp registers we probably don't check.

// - There are limited temporaries: vs_1_1 has 12 (ps_1_1 has _2_!).

// - SM2 apparently was variable, between 12 and 32. Shader Model 3 has 32.

// - A maximum of three temp registers can be used in a single instruction.

#define __MOJOSHADER_INTERNAL__ 1

#include "mojoshader_internal.h"

typedef struct ConstantsList

{

    MOJOSHADER_constant constant;

    struct ConstantsList *next;

} ConstantsList;

typedef struct VariableList

{

    MOJOSHADER_uniformType type;

    int index;

    int count;

    ConstantsList *constant;

    int used;

    int emit_position;  // used in some profiles.

    struct VariableList *next;

} VariableList;

typedef struct RegisterList

{

    RegisterType regtype;

    int regnum;

    MOJOSHADER_usage usage;

    unsigned int index;

    int writemask;

    int misc;

    int written;

    const VariableList *array;

    struct RegisterList *next;

} RegisterList;

typedef struct

{

    const uint32 *token;   // this is the unmolested token in the stream.

    int regnum;

    int swizzle;  // xyzw (all four, not split out).

    int swizzle_x;

    int swizzle_y;

    int swizzle_z;

    int swizzle_w;

    SourceMod src_mod;

    RegisterType regtype;

    int relative;

    RegisterType relative_regtype;

    int relative_regnum;

    int relative_component;

    const VariableList *relative_array;

} SourceArgInfo;

struct Profile;  // predeclare.

typedef struct CtabData

{

    int have_ctab;

    int symbol_count;

    MOJOSHADER_symbol *symbols;

} CtabData;

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

typedef struct Context

{

    int isfail;

    int out_of_memory;

    MOJOSHADER_malloc malloc;

    MOJOSHADER_free free;

    void *malloc_data;

    int current_position;

    const uint32 *orig_tokens;

    const uint32 *tokens;

    uint32 tokencount;

    const MOJOSHADER_swizzle *swizzles;

    unsigned int swizzles_count;

    Buffer *output;

    Buffer *preflight;

    Buffer *globals;

    Buffer *helpers;

    Buffer *subroutines;

    Buffer *mainline_intro;

    Buffer *mainline;

    Buffer *ignore;

    Buffer *output_stack[2];

    int indent_stack[2];

    int output_stack_len;

    int indent;

    const char *shader_type_str;

    const char *endline;

    int endline_len;

    int profileid;

    const struct Profile *profile;

    MOJOSHADER_shaderType shader_type;

    uint8 major_ver;

    uint8 minor_ver;

    DestArgInfo dest_arg;

    SourceArgInfo source_args[5];

    SourceArgInfo predicate_arg;  // for predicated instructions.

    uint32 dwords[4];

    uint32 version_token;

    int instruction_count;

    uint32 instruction_controls;

    uint32 previous_opcode;

    int loops;

    int reps;

    int max_reps;

    int cmps;

    int scratch_registers;

    int max_scratch_registers;

    int branch_labels_stack_index;

    int branch_labels_stack[32];

    int assigned_branch_labels;

    int assigned_vertex_attributes;

    int last_address_reg_component;

    RegisterList used_registers;

    RegisterList defined_registers;

    ErrorList *errors;

    int constant_count;

    ConstantsList *constants;

    int uniform_count;

    int uniform_float4_count;

    int uniform_int4_count;

    int uniform_bool_count;

    RegisterList uniforms;

    int attribute_count;

    RegisterList attributes;

    int sampler_count;

    RegisterList samplers;

    VariableList *variables;  // variables to register mapping.

    int centroid_allowed;

    CtabData ctab;

    int have_relative_input_registers;

    int have_multi_color_outputs;

    int determined_constants_arrays;

    int predicated;

    int uses_pointsize;

    int uses_fog;

    int glsl_generated_lit_opcode;

    int glsl_generated_texldd_setup;

    int arb1_wrote_position;

    int have_preshader;

    int ignores_ctab;

    MOJOSHADER_preshader *preshader;

#if SUPPORT_PROFILE_ARB1_NV

    int profile_supports_nv2;

    int profile_supports_nv3;

    int profile_supports_nv4;

#endif

#if SUPPORT_PROFILE_GLSL120

    int profile_supports_glsl120;

#endif

} Context;

// Use these macros so we can remove all bits of these profiles from the build.

#if SUPPORT_PROFILE_ARB1_NV

#define support_nv2(ctx) ((ctx)->profile_supports_nv2)

#define support_nv3(ctx) ((ctx)->profile_supports_nv3)

#define support_nv4(ctx) ((ctx)->profile_supports_nv4)

#else

#define support_nv2(ctx) (0)

#define support_nv3(ctx) (0)

#define support_nv4(ctx) (0)

#endif

#if SUPPORT_PROFILE_GLSL120

#define support_glsl120(ctx) ((ctx)->profile_supports_glsl120)

#else

#define support_glsl120(ctx) (0)

#endif

// Profile entry points...

// one emit function for each opcode in each profile.

typedef void (*emit_function)(Context *ctx);

// one emit function for starting output in each profile.

typedef void (*emit_start)(Context *ctx, const char *profilestr);

// one emit function for ending output in each profile.

typedef void (*emit_end)(Context *ctx);

// one emit function for phase opcode output in each profile.

typedef void (*emit_phase)(Context *ctx);

// one emit function for finalizing output in each profile.

typedef void (*emit_finalize)(Context *ctx);

// one emit function for global definitions in each profile.

typedef void (*emit_global)(Context *ctx, RegisterType regtype, int regnum);

// one emit function for relative uniform arrays in each profile.

typedef void (*emit_array)(Context *ctx, VariableList *var);

// one emit function for relative constants arrays in each profile.

typedef void (*emit_const_array)(Context *ctx,

                                 const struct ConstantsList *constslist,

                                 int base, int size);

// one emit function for uniforms in each profile.

typedef void (*emit_uniform)(Context *ctx, RegisterType regtype, int regnum,

                             const VariableList *var);

// one emit function for samplers in each profile.

typedef void (*emit_sampler)(Context *ctx, int stage, TextureType ttype);

// one emit function for attributes in each profile.

typedef void (*emit_attribute)(Context *ctx, RegisterType regtype, int regnum,

                               MOJOSHADER_usage usage, int index, int wmask,

                               int flags);

// one args function for each possible sequence of opcode arguments.

typedef int (*args_function)(Context *ctx);

// one state function for each opcode where we have state machine updates.

typedef void (*state_function)(Context *ctx);

// one function for varnames in each profile.

typedef const char *(*varname_function)(Context *c, RegisterType t, int num);

// one function for const var array in each profile.

typedef const char *(*const_array_varname_function)(Context *c, int base, int size);

typedef struct Profile

{

    const char *name;

    emit_start start_emitter;

    emit_end end_emitter;

    emit_phase phase_emitter;

    emit_global global_emitter;

    emit_array array_emitter;

    emit_const_array const_array_emitter;

    emit_uniform uniform_emitter;

    emit_sampler sampler_emitter;

    emit_attribute attribute_emitter;

    emit_finalize finalize_emitter;

    varname_function get_varname;

    const_array_varname_function get_const_array_varname;

} Profile;

// Convenience functions for allocators...

#if !MOJOSHADER_FORCE_ALLOCATOR

void *MOJOSHADER_internal_malloc(int bytes, void *d) { return malloc(bytes); }

void MOJOSHADER_internal_free(void *ptr, void *d) { free(ptr); }

#endif

MOJOSHADER_error MOJOSHADER_out_of_mem_error = {

    "Out of memory", NULL, MOJOSHADER_POSITION_NONE

};

MOJOSHADER_parseData MOJOSHADER_out_of_mem_data = {

    1, &MOJOSHADER_out_of_mem_error, 0, 0, 0, 0,

    MOJOSHADER_TYPE_UNKNOWN, 0, 0, 0, 0

};

// !!! 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 ...

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

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

static 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

static 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

static inline 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...

static inline uint32 ver_ui32(const uint8 major, const uint8 minor)

{

    return ( (((uint32) major) << 16) | (((minor) == 0xFF) ? 1 : (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

static inline int isfail(const Context *ctx)

{

    return ctx->isfail;

} // isfail

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;

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

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

{

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

} // fail

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

static 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

static inline 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.

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

                     int leavedecimal)

{

    const size_t len = snprintf(buf, bufsize, "%f", 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...  !!! FIXME: I sort of hate this.

static void free_reglist(MOJOSHADER_free f, void *d, RegisterList *item)

{