#include <stdio.h>
#include <stdlib.h>

#define SWAP32(x) (x)
typedef unsigned int uint;
typedef unsigned char uint8;
typedef unsigned int uint32;

// This enum complements of Filip Navara's public domain dev-cpp d3d9 header.
typedef enum
{
    OPCODE_NOP = 0,
    OPCODE_MOV = 1,
    OPCODE_ADD = 2,
    OPCODE_SUB = 3,
    OPCODE_MAD = 4,
    OPCODE_MUL = 5,
    OPCODE_RCP = 6,
    OPCODE_RSQ = 7,
    OPCODE_DP3 = 8,
    OPCODE_DP4 = 9,
    OPCODE_MIN = 10,
    OPCODE_MAX = 11,
    OPCODE_SLT = 12,
    OPCODE_SGE = 13,
    OPCODE_EXP = 14,
    OPCODE_LOG = 15,
    OPCODE_LIT = 16,
    OPCODE_DST = 17,
    OPCODE_LRP = 18,
    OPCODE_FRC = 19,
    OPCODE_M4x4 = 20,
    OPCODE_M4x3 = 21,
    OPCODE_M3x4 = 22,
    OPCODE_M3x3 = 23,
    OPCODE_M3x2 = 24,
    OPCODE_CALL = 25,
    OPCODE_CALLNZ = 26,
    OPCODE_LOOP = 27,
    OPCODE_RET = 28,
    OPCODE_ENDLOOP = 29,
    OPCODE_LABEL = 30,
    OPCODE_DCL = 31,
    OPCODE_POW = 32,
    OPCODE_CRS = 33,
    OPCODE_SGN = 34,
    OPCODE_ABS = 35,
    OPCODE_NRM = 36,
    OPCODE_SINCOS = 37,
    OPCODE_REP = 38,
    OPCODE_ENDREP = 39,
    OPCODE_IF = 40,
    OPCODE_IFC = 41,
    OPCODE_ELSE = 42,
    OPCODE_ENDIF = 43,
    OPCODE_BREAK = 44,
    OPCODE_BREAKC = 45,
    OPCODE_MOVA = 46,
    OPCODE_DEFB = 47,
    OPCODE_DEFI = 48,
    OPCODE_TEXCOORD = 64,
    OPCODE_TEXKILL = 65,
    OPCODE_TEX = 66,
    OPCODE_TEXBEM = 67,
    OPCODE_TEXBEML = 68,
    OPCODE_TEXREG2AR = 69,
    OPCODE_TEXREG2GB = 70,
    OPCODE_TEXM3x2PAD = 71,
    OPCODE_TEXM3x2TEX = 72,
    OPCODE_TEXM3x3PAD = 73,
    OPCODE_TEXM3x3TEX = 74,
    OPCODE_RESERVED0 = 75,
    OPCODE_TEXM3x3SPEC = 76,
    OPCODE_TEXM3x3VSPEC = 77,
    OPCODE_EXPP = 78,
    OPCODE_LOGP = 79,
    OPCODE_CND = 80,
    OPCODE_DEF = 81,
    OPCODE_TEXREG2RGB = 82,
    OPCODE_TEXDP3TEX = 83,
    OPCODE_TEXM3x2DEPTH = 84,
    OPCODE_TEXDP3 = 85,
    OPCODE_TEXM3x3 = 86,
    OPCODE_TEXDEPTH = 87,
    OPCODE_CMP = 88,
    OPCODE_BEM = 89,
    OPCODE_DP2ADD = 90,
    OPCODE_DSX = 91,
    OPCODE_DSY = 92,
    OPCODE_TEXLDD = 93,
    OPCODE_SETP = 94,
    OPCODE_TEXLDL = 95,
    OPCODE_BREAKP = 96,
    OPCODE_PHASE = 0xfffd,
} OpcodeVal;


static int parse_version_token(const uint32 *tokens, const uint32 tokencount)
{
    if (tokencount == 0)
        return -1;  // no tokens at all?

    const uint32 token = SWAP32(*tokens);
    const uint32 shadertype = ((token >> 16) & 0xFFFF);
    const uint32 major = ((token >> 8) & 0xFF);
    const uint32 minor = (token & 0xFF);

    if (shadertype == 0xFFFF)
        printf("Pixel shader\n");
    else if (shadertype == 0xFFFE)
        printf("Vertex shader\n");
    else
        return -1;  // geometry shader? Unsupported at the moment. FAIL.

    printf("Version %u.%u\n", (uint) major, (uint) minor);

    return 1;  // ate one token.
} // parse_version_token


static int parse_comment_token(const uint32 *tokens, const uint32 tokencount)
{
    const uint32 token = SWAP32(*tokens);
    if ((token & 0xFFFF) != 0xFFFE)
        return 0;  // not a comment token.
    else if ((token & 0x80000000) != 0)
        return -1;  // msdn docs say high bit must be zero. FAIL.

    const uint32 commenttoks = ((token >> 16) & 0xFFFF);
    const uint32 commentlen = commenttoks * sizeof (uint32);
    printf("Comment (%u tokens, %u bytes): ",
            (uint) commenttoks, (uint) commentlen);

    uint32 i = 0;
    const char *comment = (const char *) (tokens+1);
    while (i < commentlen)
        fputc(comment[i++], stdout);

    printf("\n");

    return commenttoks + 1;  // comment data plus the initial token.
} // parse_comment_token


static int parse_end_token(const uint32 *tokens, const uint32 tokencount)
{
    if (SWAP32(*tokens) != 0x0000FFFF)      // end token is always 0x0000FFFF.
        return 0;  // not us, eat no tokens.

    printf("END\n");

    // we _must_ be last. If so, eat the token. Otherwise: FAIL.
    return (tokencount == 1) ? 1 : -1;
} // parse_end_token


static int parse_instruction_token(const uint32 *tokens, const uint32 tokencount)
{
    const uint32 token = SWAP32(*tokens);
    const uint32 opcode = (token & 0xFFFF);
    const uint32 controls = ((token >> 16) & 0xFF);
    const uint32 insttoks = ((token >> 24) & 0x0F);
    const int coissue = (token & 0x40000000) ? 1 : 0;
    const int predicated = (token & 0x10000000) ? 1 : 0;

    if ((token & 0x80000000) != 0)
        return -1;  // msdn docs say high bit must be zero. FAIL.

    #define PARSE_OP(op) printf("OPCODE %s\n", #op);
    //case OPCODE_##op:
    //    parse_op_##op(tokens+1, opcode, controls, insttoks, coissue, predicated);
    //    break;

    PARSE_OP(NOP);
    PARSE_OP(MOV);
    PARSE_OP(ADD);
    PARSE_OP(SUB);
    PARSE_OP(MAD);
    PARSE_OP(MUL);
    PARSE_OP(RCP);
    PARSE_OP(RSQ);
    PARSE_OP(DP3);
    PARSE_OP(DP4);
    PARSE_OP(MIN);
    PARSE_OP(MAX);
    PARSE_OP(SLT);
    PARSE_OP(SGE);
    PARSE_OP(EXP);
    PARSE_OP(LOG);
    PARSE_OP(LIT);
    PARSE_OP(DST);
    PARSE_OP(LRP);
    PARSE_OP(FRC);
    PARSE_OP(M4x4);
    PARSE_OP(M4x3);
    PARSE_OP(M3x4);
    PARSE_OP(M3x3);
    PARSE_OP(M3x2);
    PARSE_OP(CALL);
    PARSE_OP(CALLNZ);
    PARSE_OP(LOOP);
    PARSE_OP(RET);
    PARSE_OP(ENDLOOP);
    PARSE_OP(LABEL);
    PARSE_OP(DCL);
    PARSE_OP(POW);
    PARSE_OP(CRS);
    PARSE_OP(SGN);
    PARSE_OP(ABS);
    PARSE_OP(NRM);
    PARSE_OP(SINCOS);
    PARSE_OP(REP);
    PARSE_OP(ENDREP);
    PARSE_OP(IF);
    PARSE_OP(IFC);
    PARSE_OP(ELSE);
    PARSE_OP(ENDIF);
    PARSE_OP(BREAK);
    PARSE_OP(BREAKC);
    PARSE_OP(MOVA);
    PARSE_OP(DEFB);
    PARSE_OP(DEFI);
    PARSE_OP(TEXCOORD);
    PARSE_OP(TEXKILL);
    PARSE_OP(TEX);
    PARSE_OP(TEXBEM);
    PARSE_OP(TEXBEML);
    PARSE_OP(TEXREG2AR);
    PARSE_OP(TEXREG2GB);
    PARSE_OP(TEXM3x2PAD);
    PARSE_OP(TEXM3x2TEX);
    PARSE_OP(TEXM3x3PAD);
    PARSE_OP(TEXM3x3TEX);
    PARSE_OP(RESERVED0);
    PARSE_OP(TEXM3x3SPEC);
    PARSE_OP(TEXM3x3VSPEC);
    PARSE_OP(EXPP);
    PARSE_OP(LOGP);
    PARSE_OP(CND);
    PARSE_OP(DEF);
    PARSE_OP(TEXREG2RGB);
    PARSE_OP(TEXDP3TEX);
    PARSE_OP(TEXM3x2DEPTH);
    PARSE_OP(TEXDP3);
    PARSE_OP(TEXM3x3);
    PARSE_OP(TEXDEPTH);
    PARSE_OP(CMP);
    PARSE_OP(BEM);
    PARSE_OP(DP2ADD);
    PARSE_OP(DSX);
    PARSE_OP(DSY);
    PARSE_OP(TEXLDD);
    PARSE_OP(SETP);
    PARSE_OP(TEXLDL);
    PARSE_OP(BREAKP);
    PARSE_OP(PHASE);

    #undef PARSE_OP
} // parse_instruction_token


static int parse_token(const uint32 *tokens, const uint32 tokencount)
{
    int retval = -1;
    int rc = 0;

    if (tokencount == 0)
        return -1;  // shouldn't happen, but just in case...

    if ((rc = parse_comment_token(tokens, tokencount)) != 0)
        return rc;

    if ((rc = parse_end_token(tokens, tokencount)) != 0)
        return rc;

    if ((rc = parse_instruction_token(tokens, tokencount)) != 0)
        return rc;

    return -1;  // nothing handled this? FAIL.
} // parse_token


int D3D2GLSL_parse(const uint8 *tokenbuf, const uint32 bufsize)
{
    const uint32 *tokens = (const uint32 *) tokenbuf;
    uint32 tokencount = bufsize / sizeof (uint32);
    int rc = parse_version_token(tokens, tokencount);

    // parse out the rest of the tokens after the version token...
    while ((rc > 0) && (tokencount > 0))
    {
        tokens += rc;
        tokencount -= rc;
        rc = parse_token(tokens, tokencount);
    } // while

    return ((rc <= 0) || (tokencount > 0)) ? 0 : 1;
} // D3D2GLSL_parse


int main(int argc, char **argv)
{
    if (argv[1] != NULL)
    {
        FILE *io = fopen(argv[1], "rb");
        if (io != NULL)
        {
            uint8 *buf = (uint8 *) malloc(1000000);
            int rc = fread(buf, 1, 1000000, io);
            fclose(io);
            D3D2GLSL_parse(buf, rc);
            free(buf);
        } // if
    } // if

    return 0;
} // main

// end of parse.c ...