/**

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <stdarg.h>

#include <assert.h>

#include "mojoshader.h"

#include <malloc.h>

typedef unsigned __int16 uint16;

typedef uint8_t uint8;

typedef uint16_t uint16;

typedef uint32_t uint32;

typedef int32_t int32;

#endif

#else

# define SWAP16(x) (x)

// predeclare.

typedef struct Context Context;

struct ConstantsList;

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

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

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

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

typedef void (*emit_array)(Context *ctx, int base, int size);

// one emit function for uniforms in each profile.

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

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

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

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;

} Profile;

} RastOutType;

} MiscTypeType;

typedef struct OutputListNode

ConstantsList *constant;

int used;

int misc;

const VariableList *array;

} SourceMod;

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

int orig_writemask; // writemask before mojoshader tweaks it.

RegisterType regtype;

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

int regnum;

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

SourceMod src_mod;

RegisterType regtype;

const VariableList *relative_array;

#define SCRATCH_BUFFER_SIZE 128

#define SCRATCH_BUFFERS 32

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

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

struct Context

{

void *malloc_data;

OutputList helpers;

OutputList subroutines;

OutputList mainline_intro;

OutputList mainline;

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

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

int indent;

const char *shader_type_str;

char scratch[SCRATCH_BUFFERS][SCRATCH_BUFFER_SIZE];

const Profile *profile;

MOJOSHADER_shaderType shader_type;

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;

int reps;

int max_reps;

int cmps;

int assigned_vertex_attributes;

int last_address_reg_component;

int determined_constants_arrays:1;

int support_nv3:1;

int support_glsl120:1;

int glsl_generated_lit_opcode:1;

{

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

{

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

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

static inline int shader_version_supported(const uint8 maj, const uint8 min)

static inline char *get_scratch_buffer(Context *ctx)

{

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

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

{

char *scratch = get_scratch_buffer(ctx);

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

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

if (failstr != NULL)