#ifndef _INCLUDE_MOJOSHADER_INTERNAL_H_

#define _INCLUDE_MOJOSHADER_INTERNAL_H_

#ifndef __MOJOSHADER_INTERNAL__

#error Do not include this header from your applications.

#endif

// Shader bytecode format is described at MSDN:

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

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <stdarg.h>

#include <assert.h>

#include "mojoshader.h"

#define DEBUG_LEXER 0

#define DEBUG_PREPROCESSOR 0

#define DEBUG_ASSEMBLER_PARSER 0

#define DEBUG_COMPILER_PARSER 0

#define DEBUG_TOKENIZER \

    (DEBUG_PREPROCESSOR || DEBUG_ASSEMBLER_PARSER || DEBUG_LEXER)

#if (defined(__APPLE__) && defined(__MACH__))

#define PLATFORM_MACOSX 1

#endif

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

#define MAX_SHADER_MAJOR 3

#define MAX_SHADER_MINOR 255  // vs_3_sw

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

#define SUPPORT_PROFILE_BYTECODE 1

#endif

#ifndef SUPPORT_PROFILE_GLSL

#define SUPPORT_PROFILE_GLSL 1

#endif

#ifndef SUPPORT_PROFILE_ARB1

#define SUPPORT_PROFILE_ARB1 1

#endif

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

#ifdef _WINDOWS

#define ENDLINE_STR "\r\n"

#else

#define ENDLINE_STR "\n"

#endif

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

#ifdef _MSC_VER

#include <malloc.h>

#define snprintf _snprintf

#define strcasecmp stricmp

typedef unsigned __int8 uint8;

typedef unsigned __int16 uint16;

typedef unsigned __int32 uint32;

typedef __int32 int32;

// Warning Level 4 considered harmful.  :)

#pragma warning(disable: 4100)  // "unreferenced formal parameter"

#pragma warning(disable: 4389)  // "signed/unsigned mismatch"

#else

#include <stdint.h>

typedef uint8_t uint8;

typedef uint16_t uint16;

typedef uint32_t uint32;

typedef int32_t int32;

#endif

#ifdef sun

#include <alloca.h>

#endif

#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

    static inline uint16 SWAP16(uint16 x)

    {

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

        return x;

    } // SWAP16

#elif defined(__POWERPC__)

    static inline uint32 SWAP32(uint32 x)

    {

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

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

    } // SWAP32

    static inline uint16 SWAP16(uint16 x)

    {

        return ( (((x) >> 8) & 0x00FF) | (((x) << 8) & 0xFF00) );

    } // SWAP16

#else

#   define SWAP16(x) (x)

#   define SWAP32(x) (x)

#endif

static inline int Min(const int a, const int b)

{

    return ((a < b) ? a : b);

} // Min

// Hashtables...

typedef struct HashTable HashTable;

typedef uint32 (*HashTable_HashFn)(const void *key);

typedef int (*HashTable_KeyMatchFn)(const void *a, const void *b);

typedef void (*HashTable_NukeFn)(const void *key, const void *value);

HashTable *hash_create(const uint32 initial_table_size,

              const HashTable_HashFn hashfn,

              const HashTable_KeyMatchFn keymatchfn,

              const HashTable_NukeFn nukefn,

              const int stackable,

              MOJOSHADER_malloc m, MOJOSHADER_free f, void *d);

void hash_destroy(HashTable *table);

int hash_insert(HashTable *table, const void *key, const void *value);

int hash_remove(HashTable *table, const void *key);

int hash_find(const HashTable *table, const void *key, const void **_value);

uint32 hash_hash_string(const void *sym);

int hash_keymatch_string(const void *a, const void *b);

// This is the ID for a D3DXSHADER_CONSTANTTABLE in the bytecode comments.

#define CTAB_ID 0x42415443  // 0x42415443 == 'CTAB'

#define CTAB_SIZE 28  // sizeof (D3DXSHADER_CONSTANTTABLE).

#define CINFO_SIZE 20  // sizeof (D3DXSHADER_CONSTANTINFO).

#define CTYPEINFO_SIZE 16  // sizeof (D3DXSHADER_TYPEINFO).

#define CMEMBERINFO_SIZE 8  // sizeof (D3DXSHADER_STRUCTMEMBERINFO)

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

#define OPCODE_RET 28

#define OPCODE_IF 40

#define OPCODE_IFC 41

#define OPCODE_BREAK 44

#define OPCODE_BREAKC 45

#define OPCODE_TEXLD 66

#define OPCODE_SETP 94

// TEXLD becomes a different instruction with these instruction controls.

#define CONTROL_TEXLD  0

#define CONTROL_TEXLDP 1

#define CONTROL_TEXLDB 2

// #define this to force app to supply an allocator, so there's no reference

//  to the C runtime's malloc() and free()...

#if MOJOSHADER_FORCE_ALLOCATOR

#define MOJOSHADER_internal_malloc NULL

#define MOJOSHADER_internal_free NULL

#else

void *MOJOSHADER_internal_malloc(int bytes, void *d);

void MOJOSHADER_internal_free(void *ptr, void *d);

#endif

#if MOJOSHADER_FORCE_INCLUDE_CALLBACKS

#define MOJOSHADER_internal_include_open NULL

#define MOJOSHADER_internal_include_close NULL

#else

int MOJOSHADER_internal_include_open(MOJOSHADER_includeType inctype,

                                     const char *fname, const char *parent,

                                     const char **outdata,

                                     unsigned int *outbytes,

                                     MOJOSHADER_malloc m, MOJOSHADER_free f,

                                     void *d);

void MOJOSHADER_internal_include_close(const char *data, MOJOSHADER_malloc m,

                                       MOJOSHADER_free f, void *d);

#endif

// result modifiers.

// !!! FIXME: why isn't this an enum?

#define MOD_SATURATE 0x01

#define MOD_PP 0x02

#define MOD_CENTROID 0x04

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;

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;

// 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 orig_writemask;   // writemask before mojoshader tweaks it.

    int result_mod;

    int result_shift;

    RegisterType regtype;

} DestArgInfo;

static inline int scalar_register(const MOJOSHADER_shaderType shader_type,

                                  const RegisterType regtype, const int regnum)

{

    switch (regtype)

    {

        case REG_TYPE_DEPTHOUT:

        case REG_TYPE_CONSTBOOL:

        case REG_TYPE_LOOP:

            return 1;

        case REG_TYPE_MISCTYPE:

            if ( ((const MiscTypeType) regnum) == MISCTYPE_TYPE_FACE )

                return 1;

            return 0;

        case REG_TYPE_PREDICATE:

            return (shader_type == MOJOSHADER_TYPE_PIXEL) ? 1 : 0;

        default: break;

    } // switch

    return 0;

} // scalar_register

typedef enum

{

    MOJOSHADER_PARSEPHASE_NOTSTARTED,

    MOJOSHADER_PARSEPHASE_WORKING,

    MOJOSHADER_PARSEPHASE_DONE,

} MOJOSHADER_parsePhase;

extern MOJOSHADER_error MOJOSHADER_out_of_mem_error;

extern MOJOSHADER_parseData MOJOSHADER_out_of_mem_data;

// !!! FIXME: unify all the routines in various modules that deal with these.

typedef struct ErrorList

{

    MOJOSHADER_error error;

    struct ErrorList *next;

} ErrorList;

// preprocessor stuff.

typedef enum

{

    TOKEN_UNKNOWN = 256,  // start past ASCII character values.

    // These are all C-like constructs. Tokens < 256 may be single

    //  chars (like '+' or whatever). These are just multi-char sequences

    //  (like "+=" or whatever).

    TOKEN_IDENTIFIER,

    TOKEN_INT_LITERAL,

    TOKEN_FLOAT_LITERAL,

    TOKEN_STRING_LITERAL,

    TOKEN_RSHIFTASSIGN,

    TOKEN_LSHIFTASSIGN,

    TOKEN_ADDASSIGN,

    TOKEN_SUBASSIGN,

    TOKEN_MULTASSIGN,

    TOKEN_DIVASSIGN,

    TOKEN_MODASSIGN,

    TOKEN_XORASSIGN,

    TOKEN_ANDASSIGN,

    TOKEN_ORASSIGN,

    TOKEN_INCREMENT,

    TOKEN_DECREMENT,

    TOKEN_RSHIFT,

    TOKEN_LSHIFT,

    TOKEN_ANDAND,

    TOKEN_OROR,

    TOKEN_LEQ,

    TOKEN_GEQ,

    TOKEN_EQL,

    TOKEN_NEQ,

    TOKEN_HASHHASH,

    // This is returned at the end of input...no more to process.

    TOKEN_EOI,

    // This is returned for char sequences we think are bogus. You'll have

    //  to judge for yourself. In most cases, you'll probably just fail with

    //  bogus syntax without explicitly checking for this token.

    TOKEN_BAD_CHARS,

    // This is returned if there's an error condition (the error is returned

    //  as a NULL-terminated string from preprocessor_nexttoken(), instead

    //  of actual token data). You can continue getting tokens after this

    //  is reported. It happens for things like missing #includes, etc.

    TOKEN_PREPROCESSING_ERROR,

    // These are all caught by the preprocessor. Caller won't ever see them.

    //  They control the preprocessor (#includes new files, etc).

    TOKEN_PP_INCLUDE,

    TOKEN_PP_LINE,

    TOKEN_PP_DEFINE,

    TOKEN_PP_UNDEF,

    TOKEN_PP_IF,

    TOKEN_PP_IFDEF,

    TOKEN_PP_IFNDEF,

    TOKEN_PP_ELSE,

    TOKEN_PP_ELIF,

    TOKEN_PP_ENDIF,

    TOKEN_PP_ERROR,  // caught, becomes TOKEN_PREPROCESSING_ERROR

    TOKEN_INCOMPLETE_COMMENT,  // caught, becomes TOKEN_PREPROCESSING_ERROR

    TOKEN_PP_UNARY_MINUS,  // used internally, never returned.

    TOKEN_PP_UNARY_PLUS,   // used internally, never returned.

} Token;

// This is opaque.

struct Preprocessor;

typedef struct Preprocessor Preprocessor;

typedef struct Conditional

{

    Token type;

    int linenum;

    int skipping;

    int chosen;

    struct Conditional *next;

} Conditional;

typedef struct Define

{

    const char *identifier;

    const char *definition;

    const char **parameters;

    int paramcount;

    struct Define *next;

} Define;

typedef struct IncludeState

{

    const char *filename;

    int included;

    const char *source_base;

    const char *source;

    const char *token;

    unsigned int tokenlen;

    Token tokenval;

    int pushedback;

    const unsigned char *lexer_marker;

    int report_whitespace;

    int asm_comments;

    unsigned int orig_length;

    unsigned int bytes_left;

    unsigned int line;

    Conditional *conditional_stack;

    Define *defines;  // temp defines for macros with parameters.

    MOJOSHADER_includeClose close_callback;

    struct IncludeState *next;

} IncludeState;

Token preprocessor_lexer(IncludeState *s);

// This will only fail if the allocator fails, so it doesn't return any

//  error code...NULL on failure.

Preprocessor *preprocessor_start(const char *fname, const char *source,

                            unsigned int sourcelen,

                            MOJOSHADER_includeOpen open_callback,

                            MOJOSHADER_includeClose close_callback,

                            const MOJOSHADER_preprocessorDefine *defines,

                            unsigned int define_count, int asm_comments,

                            MOJOSHADER_malloc m, MOJOSHADER_free f, void *d);

void preprocessor_end(Preprocessor *pp);

int preprocessor_outofmemory(Preprocessor *pp);

const char *preprocessor_nexttoken(Preprocessor *_ctx,

                                   unsigned int *_len, Token *_token);

const char *preprocessor_sourcepos(Preprocessor *pp, unsigned int *pos);

void MOJOSHADER_print_debug_token(const char *subsystem, const char *token,

                                  const unsigned int tokenlen,

                                  const Token tokenval);

#endif  // _INCLUDE_MOJOSHADER_INTERNAL_H_

#if MOJOSHADER_DO_INSTRUCTION_TABLE

// These have to be in the right order! Arrays are indexed by the value

//  of the instruction token.

// INSTRUCTION_STATE means this opcode has to update the state machine

//  (we're entering an ELSE block, etc). INSTRUCTION means there's no

//  state, just go straight to the emitters.

// !!! FIXME: Some of these MOJOSHADER_TYPE_ANYs need to have their scope

// !!! FIXME:  reduced to just PIXEL or VERTEX.

INSTRUCTION(NOP, "NOP", 1, NULL, MOJOSHADER_TYPE_ANY)

INSTRUCTION(MOV, "MOV", 1, DS, MOJOSHADER_TYPE_ANY)

INSTRUCTION(ADD, "ADD", 1, DSS, MOJOSHADER_TYPE_ANY)

INSTRUCTION(SUB, "SUB", 1, DSS, MOJOSHADER_TYPE_ANY)

INSTRUCTION(MAD, "MAD", 1, DSSS, MOJOSHADER_TYPE_ANY)

INSTRUCTION(MUL, "MUL", 1, DSS, MOJOSHADER_TYPE_ANY)

INSTRUCTION_STATE(RCP, "RCP", 1, DS, MOJOSHADER_TYPE_ANY)

INSTRUCTION(RSQ, "RSQ", 1, DS, MOJOSHADER_TYPE_ANY)

INSTRUCTION(DP3, "DP3", 1, DSS, MOJOSHADER_TYPE_ANY)

INSTRUCTION_STATE(DP4, "DP4", 1, DSS, MOJOSHADER_TYPE_ANY)

INSTRUCTION(MIN, "MIN", 1, DSS, MOJOSHADER_TYPE_ANY)

INSTRUCTION(MAX, "MAX", 1, DSS, MOJOSHADER_TYPE_ANY)

INSTRUCTION(SLT, "SLT", 1, DSS, MOJOSHADER_TYPE_ANY)