/**

 * 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: I keep changing coding styles for symbols and typedefs.

// !!! FIXME: do DEF* opcodes have to come before instructions?

// !!! FIXME:  my reading of the msdn spec suggests no, but it sounds like

// !!! FIXME:  something they'd require. DCL_* _does_ have to be first.

// Shader bytecode format is described at MSDN:

//  http://msdn2.microsoft.com/en-us/library/ms800307.aspx

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <stdint.h>

#include <stdarg.h>

#include <assert.h>

#include "mojoshader.h"

// This is the highest shader version we currently support.

#define MAX_SHADER_MAJOR 3

#define MAX_SHADER_MINOR 0

// If SUPPORT_PROFILE_* isn't defined, we assume an implicit desire to support.

//  You get all the profiles unless you go out of your way to disable them.

#ifndef SUPPORT_PROFILE_D3D

#define SUPPORT_PROFILE_D3D 1

#endif

#ifndef SUPPORT_PROFILE_PASSTHROUGH

#define SUPPORT_PROFILE_PASSTHROUGH 1

#endif

#ifndef SUPPORT_PROFILE_GLSL

#define SUPPORT_PROFILE_GLSL 1

#endif

// Get basic wankery out of the way here...

typedef unsigned int uint;  // this is a printf() helper. don't use for code.

typedef uint8_t uint8;

typedef uint32_t uint32;

typedef int32_t int32;

#ifdef __GNUC__

#define ISPRINTF(x,y) __attribute__((format (printf, x, y)))

#else

#define ISPRINTF(x,y)

#endif

#define STATICARRAYLEN(x) ( (sizeof ((x))) / (sizeof ((x)[0])) )

#ifdef _WINDOWS  // !!! FIXME: bleh

const char *endline_str = "\r\n";

#else

const char *endline_str = "\n";

#endif

// we need to reference this by explicit value occasionally.

#define OPCODE_RET 28

// Special-case return values from the parsing pipeline...

#define FAIL (-1)

#define NOFAIL (-2)

#define END_OF_STREAM (-3)

// Byteswap magic...

#if ((defined __GNUC__) && (defined __POWERPC__))

    static inline uint32 SWAP32(uint32 x)

    {

        __asm__ __volatile__("lwbrx %0,0,%1" : "=r" (x) : "r" (&x));

        return x;

    } // SWAP32

#elif defined(__POWERPC__)

    static inline uint32 SWAP32(uint32 x)

    {

        return ( (((x) >> 24) & 0x000000FF) | (((x) >>  8) & 0x0000FF00) |

                 (((x) <<  8) & 0x00FF0000) | (((x) << 24) & 0xFF000000) );

    } // SWAP32

#else

#   define SWAP32(x) (x)

#endif

typedef enum

{

    REG_TYPE_TEMP = 0,

    REG_TYPE_INPUT = 1,

    REG_TYPE_CONST = 2,

    REG_TYPE_ADDRESS = 3,

    REG_TYPE_TEXTURE = 3,  // ALSO 3!

    REG_TYPE_RASTOUT = 4,

    REG_TYPE_ATTROUT = 5,

    REG_TYPE_TEXCRDOUT = 6,

    REG_TYPE_OUTPUT = 6,  // ALSO 6!

    REG_TYPE_CONSTINT = 7,

    REG_TYPE_COLOROUT = 8,

    REG_TYPE_DEPTHOUT = 9,

    REG_TYPE_SAMPLER = 10,

    REG_TYPE_CONST2 = 11,

    REG_TYPE_CONST3 = 12,

    REG_TYPE_CONST4 = 13,

    REG_TYPE_CONSTBOOL = 14,

    REG_TYPE_LOOP = 15,

    REG_TYPE_TEMPFLOAT16 = 16,

    REG_TYPE_MISCTYPE = 17,

    REG_TYPE_LABEL = 18,

    REG_TYPE_PREDICATE = 19,

    REG_TYPE_MAX = 19

} RegisterType;

typedef enum

{

    TEXTURE_TYPE_2D = 2,

    TEXTURE_TYPE_CUBE = 3,

    TEXTURE_TYPE_VOLUME = 4,

} TextureType;

// predeclare.

typedef struct Context Context;

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

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

typedef void (*emit_end)(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 uniforms in each profile.

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

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

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

typedef struct

{

    const char *name;

    emit_start start_emitter;

    emit_end end_emitter;

    emit_global global_emitter;

    emit_uniform uniform_emitter;

    emit_sampler sampler_emitter;

    emit_attribute attribute_emitter;

    emit_finalize finalize_emitter;

} Profile;

typedef enum

{

    RASTOUT_TYPE_POSITION = 0,

    RASTOUT_TYPE_FOG = 1,

    RASTOUT_TYPE_POINT_SIZE = 2,

    RASTOUT_TYPE_MAX = 2

} RastOutType;

typedef enum

{

    MISCTYPE_TYPE_POSITION = 0,

    MISCTYPE_TYPE_FACE = 1,

    MISCTYPE_TYPE_MAX = 1

} MiscTypeType;

// A simple linked list of strings, so we can build the final output without

//  realloc()ing for each new line, and easily insert lines into the middle

//  of the output without much trouble.

typedef struct OutputListNode

{

    char *str;

    struct OutputListNode *next;

} OutputListNode;

typedef struct OutputList

{

    OutputListNode head;

    OutputListNode *tail;

} OutputList;

typedef struct RegisterList

{

    RegisterType regtype;

    int regnum;

    MOJOSHADER_usage usage;

    int index;

    int writemask;

    struct RegisterList *next;

} RegisterList;

// result modifiers.

#define MOD_SATURATE 0x01

#define MOD_PP 0x02

#define MOD_CENTROID 0x04

// source modifiers.

typedef enum

{

    SRCMOD_NONE,

    SRCMOD_NEGATE,

    SRCMOD_BIAS,

    SRCMOD_BIASNEGATE,

    SRCMOD_SIGN,

    SRCMOD_SIGNNEGATE,

    SRCMOD_COMPLEMENT,

    SRCMOD_X2,

    SRCMOD_X2NEGATE,

    SRCMOD_DZ,

    SRCMOD_DW,

    SRCMOD_ABS,

    SRCMOD_ABSNEGATE,

    SRCMOD_NOT,

    SRCMOD_TOTAL

} SourceMod;

typedef struct

{

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

    int regnum;

    int relative;

    int writemask;   // xyzw or rgba (all four, not split out).

    int writemask0;  // x or red

    int writemask1;  // y or green

    int writemask2;  // z or blue

    int writemask3;  // w or alpha

    int result_mod;

    int result_shift;

    RegisterType regtype;

} DestArgInfo;

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;

} SourceArgInfo;

typedef enum

{

    // Specific to GLSL profile...

    CTX_FLAGS_GLSL_LIT_OPCODE = (1 << 0),

    CTX_FLAGS_MASK = 0xFFFFFFFF

} ContextFlags;

#define SCRATCH_BUFFER_SIZE 128

#define SCRATCH_BUFFERS 16

// !!! FIXME: the scratch buffers make Context pretty big.

// !!! FIXME:  might be worth having one set of static scratch buffers that

// !!! FIXME:  are mutex protected?

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

struct Context

{

    MOJOSHADER_malloc malloc;

    MOJOSHADER_free free;

    void *malloc_data;

    const uint32 *tokens;

    uint32 tokencount;

    OutputList *output;

    OutputList globals;

    OutputList helpers;

    OutputList subroutines;

    OutputList mainline_intro;

    OutputList mainline;

    OutputList ignore;

    OutputList *output_stack[2];

    uint8 *output_bytes;  // can be used instead of the OutputLists.

    int indent_stack[2];

    int output_stack_len;

    int output_len; // total strlen; prevents walking the lists just to malloc.

    int indent;

    const char *endline;

    int endline_len;

    const char *failstr;

    char scratch[SCRATCH_BUFFERS][SCRATCH_BUFFER_SIZE];

    int scratchidx;  // current scratch buffer.

    int profileid;

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

    int instruction_count;

    uint32 instruction_controls;

    uint32 previous_opcode;

    ContextFlags flags;

    int predicated;

    int loops;

    int reps;

    int cmps;

    RegisterList used_registers;

    RegisterList defined_registers;

    int uniform_count;

    RegisterList uniforms;

    int attribute_count;

    RegisterList attributes;

    int sampler_count;

    RegisterList samplers;

};

// Convenience functions for allocators...

static MOJOSHADER_parseData out_of_mem_data = {

    "Out of memory", 0, 0, 0, 0, MOJOSHADER_TYPE_UNKNOWN, 0, 0, 0, 0

};

static const char *out_of_mem_str = "Out of memory";

static inline int out_of_memory(Context *ctx)

{

    if (ctx->failstr == NULL)

        ctx->failstr = out_of_mem_str;  // fail() would call malloc().

    return FAIL;

} // out_of_memory

static inline void *Malloc(Context *ctx, const int len)

{

    void *retval = ctx->malloc(len, ctx->malloc_data);

    if (retval == NULL)

        out_of_memory(ctx);

    return retval;

} // Malloc

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

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

static inline void push_output(Context *ctx, OutputList *section)

{

    assert(ctx->output_stack_len < 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++;

    ctx->output = section;

    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) ? 0 : (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_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

// Bit arrays (for storing large arrays of booleans...

static inline char *get_scratch_buffer(Context *ctx)

{

    ctx->scratchidx = (ctx->scratchidx + 1) % SCRATCH_BUFFERS;

    return ctx->scratch[ctx->scratchidx];

} // get_scratch_buffer

static inline int isfail(const Context *ctx)

{

    return (ctx->failstr != NULL);

} // isfail

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

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

{

    if (ctx->failstr == NULL)  // don't change existing error.

    {

        char *scratch = get_scratch_buffer(ctx);

        va_list ap;

        va_start(ap, fmt);

        const int len = vsnprintf(scratch, SCRATCH_BUFFER_SIZE, fmt, ap);

        va_end(ap);

        char *failstr = (char *) Malloc(ctx, len + 1);

        if (failstr != NULL)

        {

            // see comments about scratch buffer overflow in output_line().

            if (len < SCRATCH_BUFFER_SIZE)

                strcpy(failstr, scratch);  // copy it over.

            else

            {

                va_start(ap, fmt);

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

                va_end(ap);

            } // else

            ctx->failstr = failstr;

        } // if

    } // if

    return FAIL;

} // failf

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

{

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

} // fail

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

static int output_line(Context *ctx, const char *fmt, ...)