/**

 * d3d2glsl; generate GLSL 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.

// 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 "d3d2glsl.h"

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

#define MAX_SHADER_MAJOR 3

#define MAX_SHADER_MINOR 0

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

#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])) )

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

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

#define SHADER_VERSION_SUPPORTED(maj, min) \

    (ver_ui32(maj, min) <= ver_ui32(MAX_SHADER_MAJOR, MAX_SHADER_MINOR))

// predeclare.

typedef struct Context Context;

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

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

// one emit function for comments in each profile.

typedef void (*emit_comment)(Context *ctx, const char *str);

// 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 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 int (*state_function)(Context *ctx);

typedef struct

{

    const char *name;

    emit_start start_emitter;

    emit_end end_emitter;

    emit_comment comment_emitter;

} D3D2GLSL_profile;

typedef enum

{

    SHADER_TYPE_UNKNOWN = -1,

    SHADER_TYPE_PIXEL,

    SHADER_TYPE_VERTEX,

    SHADER_TYPE_TOTAL

} D3D2GLSL_shaderType;

typedef enum

{

    REGISTER_TYPE_TEMP = 0,

    REGISTER_TYPE_INPUT = 1,

    REGISTER_TYPE_CONST = 2,

    REGISTER_TYPE_ADDR = 3,

    REGISTER_TYPE_TEXTURE = 3,  // ALSO 3!

    REGISTER_TYPE_RASTOUT = 4,

    REGISTER_TYPE_ATTROUT = 5,

    REGISTER_TYPE_TEXCRDOUT = 6,

    REGISTER_TYPE_OUTPUT =  6, // ALSO 6!

    REGISTER_TYPE_CONSTINT =  7,

    REGISTER_TYPE_COLOROUT =  8,

    REGISTER_TYPE_DEPTHOUT =  9,

    REGISTER_TYPE_SAMPLER = 10,

    REGISTER_TYPE_CONST2 = 11,

    REGISTER_TYPE_CONST3 = 12,

    REGISTER_TYPE_CONST4 = 13,

    REGISTER_TYPE_CONSTBOOL = 14,

    REGISTER_TYPE_LOOP = 15,

    REGISTER_TYPE_TEMPFLOAT16 = 16,

    REGISTER_TYPE_MISCTYPE = 17,

    REGISTER_TYPE_LABEL = 18,

    REGISTER_TYPE_PREDICATE = 19,

    REGISTER_TYPE_MAX = 19

} D3D2GLSL_registerType;

typedef enum

{

    RASTOUT_TYPE_POSITION = 0,

    RASTOUT_TYPE_FOG = 1,

    RASTOUT_TYPE_POINT_SIZE = 2,

    RASTOUT_TYPE_MAX = 2

} D3D2GLSL_rastoutType;

typedef enum

{

    MISCTYPE_TYPE_POSITION = 0,

    MISCTYPE_TYPE_FACE = 1,

    MISCTYPE_TYPE_MAX = 1

} D3D2GLSL_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 OutputList

{

    char *str;

    struct OutputList *next;

} OutputList;

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

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

    int regtype;

} DestArgInfo;

typedef struct

{

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

    int regnum;

    int relative;

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

    int swizzle_x;

    int swizzle_y;

    int swizzle_z;

    int swizzle_w;

    int src_mod;

    int regtype;

} SourceArgInfo;

#define D3D2GLSL_SCRATCH_BUFFER_SIZE 256

#define D3D2GLSL_SCRATCH_BUFFERS 10

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

struct Context

{

    D3D2GLSL_malloc malloc;

    D3D2GLSL_free free;

    const uint32 *tokens;

    uint32 tokencount;

    OutputList output;

    OutputList *output_tail;

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

    const char *endline;

    int endline_len;

    const char *failstr;

    char scratch[D3D2GLSL_SCRATCH_BUFFERS][D3D2GLSL_SCRATCH_BUFFER_SIZE];

    int scratchidx;  // current scratch buffer.

    int profileid;

    const D3D2GLSL_profile *profile;

    D3D2GLSL_shaderType shader_type;

    uint32 major_ver;

    uint32 minor_ver;

    DestArgInfo dest_args[1];

    SourceArgInfo source_args[4];

    uint32 instruction_count;

};

static inline char *get_scratch_buffer(Context *ctx)

{

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

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

} // get_scratch_buffer

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

#define FAIL (-1)

#define END_OF_STREAM (-2)

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

static inline int out_of_memory(Context *ctx)

{

    if (ctx->failstr == NULL)

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

    return FAIL;

} // out_of_memory

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,D3D2GLSL_SCRATCH_BUFFER_SIZE,fmt,ap);

        va_end(ap);

        char *failstr = (char *) ctx->malloc(len + 1);

        if (failstr == NULL)

            out_of_memory(ctx);

        else

        {

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

            if (len < D3D2GLSL_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;

        } // else

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

{

    if (ctx->failstr != NULL)

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

    OutputList *item = (OutputList *) ctx->malloc(sizeof (OutputList));

    if (item == NULL)

        return out_of_memory(ctx);

    char *scratch = get_scratch_buffer(ctx);

    va_list ap;

    va_start(ap, fmt);

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

    va_end(ap);

    item->str = (char *) ctx->malloc(len + 1);

    if (item->str == NULL)

    {

        free(item);

        return out_of_memory(ctx);

    } // if

    // If we overflowed our scratch buffer, that's okay. We were going to

    //  allocate anyhow...the scratch buffer just lets us avoid a second

    //  run of vsnprintf().

    if (len < D3D2GLSL_SCRATCH_BUFFER_SIZE)

        strcpy(item->str, scratch);  // copy it over.

    else

    {

        va_start(ap, fmt);

        vsnprintf(item->str, len + 1, fmt, ap);  // rebuild it.

        va_end(ap);

    } // else

    item->next = NULL;

    ctx->output_tail->next = item;

    ctx->output_tail = item;

    ctx->output_len += len + ctx->endline_len;

    return 0;

} // output_line

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

#define AT_LEAST_ONE_PROFILE 0

#if !SUPPORT_PROFILE_D3D

#define PROFILE_EMITTER_D3D(op)

#else

#undef AT_LEAST_ONE_PROFILE

#define AT_LEAST_ONE_PROFILE 1

#define PROFILE_EMITTER_D3D(op) emit_D3D_##op,

static const char *get_D3D_register_string(Context *ctx,

                                           D3D2GLSL_registerType regtype,

                                           int regnum, char *regnum_str,

                                           size_t regnum_size)

{

    const char *retval = NULL;

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

    switch (regtype)

    {

        case REGISTER_TYPE_TEMP:

            retval = "r";

            break;

        case REGISTER_TYPE_INPUT:

            retval = "v";

            break;

        case REGISTER_TYPE_CONST:

        case REGISTER_TYPE_CONST2:

        case REGISTER_TYPE_CONST3:

        case REGISTER_TYPE_CONST4:

            retval = "c";

            break;

        case REGISTER_TYPE_ADDR:  // (or REGISTER_TYPE_TEXTURE, same value.)

            retval = (ctx->shader_type == SHADER_TYPE_VERTEX) ? "a" : "t";

            break;

        case REGISTER_TYPE_RASTOUT:

            switch ((D3D2GLSL_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

            regnum_str[0] = '\0';  // no number for this register type.

            break;

        case REGISTER_TYPE_ATTROUT:

            retval = "oD";

            break;

        case REGISTER_TYPE_TEXCRDOUT: // (or REGISTER_TYPE_OUTPUT, same value.)

            if ((ctx->shader_type==SHADER_TYPE_VERTEX) && (ctx->major_ver>=3))

                retval = "o";

            else

                retval = "oT";

            break;

        case REGISTER_TYPE_CONSTINT:

            retval = "i";

            break;

        case REGISTER_TYPE_COLOROUT:

            retval = "oC";

            break;

        case REGISTER_TYPE_DEPTHOUT:

            retval = "oDepth";

            regnum_str[0] = '\0';  // no number for this register type.

            break;

        case REGISTER_TYPE_SAMPLER:

            retval = "s";

            break;

        case REGISTER_TYPE_CONSTBOOL:

            retval = "b";

            break;

        case REGISTER_TYPE_LOOP:

            retval = "aL";

            regnum_str[0] = '\0';  // no number for this register type.

            break;

        // !!! FIXME: don't know what the asm string is for this..

        // case REGISTER_TYPE_TEMPFLOAT16:

        case REGISTER_TYPE_MISCTYPE:

            switch ((D3D2GLSL_misctypeType) regnum)

            {

                case MISCTYPE_TYPE_POSITION: retval = "vPos"; break;

                case MISCTYPE_TYPE_FACE: retval = "vFace"; break;

            } // switch

            regnum_str[0] = '\0';  // no number for this register type.

            break;

        case REGISTER_TYPE_LABEL:

            retval = "l";

            break;

        case REGISTER_TYPE_PREDICATE:

            retval = "p";

            break;

    } // switch

    return retval;

} // get_D3D_register_string

static char *make_D3D_destarg_string(Context *ctx, const int idx)

{

    if (idx >= STATICARRAYLEN(ctx->dest_args))

    {

        fail(ctx, "Too many destination args");

        return "";

    } // if

    const DestArgInfo *arg = &ctx->dest_args[idx];

    const char *result_shift_str = "";

    switch (arg->result_shift)

    {

        case 0x1: result_shift_str = "_x2"; break;

        case 0x2: result_shift_str = "_x4"; break;