/**

 * 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.

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include "mojoshader.h"

#ifdef _WIN32

#define snprintf _snprintf   // !!! FIXME: not a safe replacement!

#endif

static const char **include_paths = NULL;

static unsigned int include_path_count = 0;

#define MOJOSHADER_DEBUG_MALLOC 0

#if MOJOSHADER_DEBUG_MALLOC

static void *Malloc(int len, void *d)

{

    void *ptr = malloc(len + sizeof (int));

    int *store = (int *) ptr;

    printf("malloc() %d bytes (%p)\n", len, ptr);

    if (ptr == NULL) return NULL;

    *store = len;

    return (void *) (store + 1);

} // Malloc

static void Free(void *_ptr, void *d)

{

    int *ptr = (((int *) _ptr) - 1);

    int len = *ptr;

    printf("free() %d bytes (%p)\n", len, ptr);

    free(ptr);

} // Free

#else

#define Malloc NULL

#define Free NULL

#endif

static void fail(const char *err)

{

    printf("%s.\n", err);

    exit(1);

} // fail

static void print_unroll_attr(FILE *io, const int unroll)

{

    // -1 means "unroll at compiler's discretion",

    // -2 means user didn't specify the attribute.

    switch (unroll)

    {

        case 0:

            fprintf(io, "[loop] ");

            break;

        case -1:

            fprintf(io, "[unroll] ");

            break;

        case -2:

            /* no-op. */

            break;

        default:

            assert(unroll > 0);

            fprintf(io, "[unroll(%d)] ", unroll);

            break;

    } // case

} // print_unroll_attr

static void print_ast_datatype(FILE *io, const MOJOSHADER_astDataType *dt)

{

    int i;

    if (dt == NULL)

        return;

    switch (dt->type)

    {

        case MOJOSHADER_AST_DATATYPE_BOOL:

            fprintf(io, "bool");

            return;

        case MOJOSHADER_AST_DATATYPE_INT:

            fprintf(io, "int");

            return;

        case MOJOSHADER_AST_DATATYPE_UINT:

            fprintf(io, "uint");

            return;

        case MOJOSHADER_AST_DATATYPE_FLOAT:

            fprintf(io, "float");

            return;

        case MOJOSHADER_AST_DATATYPE_FLOAT_SNORM:

            fprintf(io, "snorm float");

            return;

        case MOJOSHADER_AST_DATATYPE_FLOAT_UNORM:

            fprintf(io, "unorm float");

            return;

        case MOJOSHADER_AST_DATATYPE_HALF:

            fprintf(io, "half");

            return;

        case MOJOSHADER_AST_DATATYPE_DOUBLE:

            fprintf(io, "double");

            return;

        case MOJOSHADER_AST_DATATYPE_STRING:

            fprintf(io, "string");

            return;

        case MOJOSHADER_AST_DATATYPE_SAMPLER_1D:

            fprintf(io, "sampler1D");

            return;

        case MOJOSHADER_AST_DATATYPE_SAMPLER_2D:

            fprintf(io, "sampler2D");

            return;

        case MOJOSHADER_AST_DATATYPE_SAMPLER_3D:

            fprintf(io, "sampler3D");

            return;

        case MOJOSHADER_AST_DATATYPE_SAMPLER_CUBE:

            fprintf(io, "samplerCUBE");

            return;

        case MOJOSHADER_AST_DATATYPE_SAMPLER_STATE:

            fprintf(io, "sampler_state");

            return;

        case MOJOSHADER_AST_DATATYPE_SAMPLER_COMPARISON_STATE:

            fprintf(io, "SamplerComparisonState");

            return;

        case MOJOSHADER_AST_DATATYPE_STRUCT:

            fprintf(io, "struct { ");

            for (i = 0; i < dt->structure.member_count; i++)

            {

                print_ast_datatype(io, dt->structure.members[i].datatype);

                fprintf(io, " %s; ", dt->structure.members[i].identifier);

            } // for

            fprintf(io, "}");

            return;

        case MOJOSHADER_AST_DATATYPE_ARRAY:

            print_ast_datatype(io, dt->array.base);

            if (dt->array.elements < 0)

                fprintf(io, "[]");

            else

                fprintf(io, "[%d]", dt->array.elements);

            return;

        case MOJOSHADER_AST_DATATYPE_VECTOR:

            fprintf(io, "vector<");

            print_ast_datatype(io, dt->vector.base);

            fprintf(io, ",%d>", dt->vector.elements);

            return;

        case MOJOSHADER_AST_DATATYPE_MATRIX:

            fprintf(io, "matrix<");

            print_ast_datatype(io, dt->matrix.base);

            fprintf(io, ",%d,%d>", dt->matrix.rows, dt->matrix.columns);

            return;

        case MOJOSHADER_AST_DATATYPE_BUFFER:

            fprintf(io, "buffer<");

            print_ast_datatype(io, dt->buffer.base);

            fprintf(io, ">");

            return;

        case MOJOSHADER_AST_DATATYPE_USER:

            fprintf(io, "%s", dt->user.name);

            return;

        // this should only appear if we did semantic analysis on the AST,

        //  so we only print the return value here.

        case MOJOSHADER_AST_DATATYPE_FUNCTION:

            if (!dt->function.retval)

                fprintf(io, "void");

            else

                print_ast_datatype(io, dt->function.retval);

            return;

        //case MOJOSHADER_AST_DATATYPE_NONE:

        default:

            assert(0 && "Unexpected datatype.");

            return;

    } // switch

} // print_ast_datatype

// !!! FIXME: this screws up on order of operations.

static void print_ast(FILE *io, const int substmt, const void *_ast)

{

    const MOJOSHADER_astNode *ast = (const MOJOSHADER_astNode *) _ast;

    const char *nl = substmt ? "" : "\n";

    int typeint = 0;

    static int indent = 0;

    int isblock = 0;

    int i;

    // These _HAVE_ to be in the same order as MOJOSHADER_astNodeType!

    static const char *binary[] =

    {

        ",", "*", "/", "%", "+", "-", "<<", ">>", "<", ">", "<=", ">=", "==",

        "!=", "&", "^", "|", "&&", "||", "=", "*=", "/=", "%=", "+=", "-=",

        "<<=", ">>=", "&=", "^=", "|="

    };

    static const char *pre_unary[] = { "++", "--", "-", "~", "!" };

    static const char *post_unary[] = { "++", "--" };

    static const char *simple_stmt[] = { "", "break", "continue", "discard" };

    static const char *inpmod[] = { "", "in ", "out ", "in out ", "uniform " };

    static const char *fnstorage[] = { "", "inline " };

    static const char *interpmod[] = {

        "", " linear", " centroid", " nointerpolation",

        " noperspective", " sample"

    };

    if (!ast) return;

    typeint = (int) ast->ast.type;

    #define DO_INDENT do { \

        if (!substmt) { for (i = 0; i < indent; i++) fprintf(io, "    "); } \

    } while (0)

    switch (ast->ast.type)

    {

        case MOJOSHADER_AST_OP_PREINCREMENT:

        case MOJOSHADER_AST_OP_PREDECREMENT:

        case MOJOSHADER_AST_OP_NEGATE:

        case MOJOSHADER_AST_OP_COMPLEMENT:

        case MOJOSHADER_AST_OP_NOT:

            fprintf(io, "%s", pre_unary[(typeint-MOJOSHADER_AST_OP_START_RANGE_UNARY)-1]);

            print_ast(io, 0, ast->unary.operand);

            break;

        case MOJOSHADER_AST_OP_POSTINCREMENT:

        case MOJOSHADER_AST_OP_POSTDECREMENT:

            print_ast(io, 0, ast->unary.operand);

            fprintf(io, "%s", post_unary[typeint-MOJOSHADER_AST_OP_POSTINCREMENT]);

            break;

        case MOJOSHADER_AST_OP_MULTIPLY:

        case MOJOSHADER_AST_OP_DIVIDE:

        case MOJOSHADER_AST_OP_MODULO:

        case MOJOSHADER_AST_OP_ADD:

        case MOJOSHADER_AST_OP_SUBTRACT:

        case MOJOSHADER_AST_OP_LSHIFT:

        case MOJOSHADER_AST_OP_RSHIFT:

        case MOJOSHADER_AST_OP_LESSTHAN:

        case MOJOSHADER_AST_OP_GREATERTHAN:

        case MOJOSHADER_AST_OP_LESSTHANOREQUAL:

        case MOJOSHADER_AST_OP_GREATERTHANOREQUAL:

        case MOJOSHADER_AST_OP_EQUAL:

        case MOJOSHADER_AST_OP_NOTEQUAL:

        case MOJOSHADER_AST_OP_BINARYAND:

        case MOJOSHADER_AST_OP_BINARYXOR:

        case MOJOSHADER_AST_OP_BINARYOR:

        case MOJOSHADER_AST_OP_LOGICALAND:

        case MOJOSHADER_AST_OP_LOGICALOR:

        case MOJOSHADER_AST_OP_ASSIGN:

        case MOJOSHADER_AST_OP_MULASSIGN:

        case MOJOSHADER_AST_OP_DIVASSIGN:

        case MOJOSHADER_AST_OP_MODASSIGN:

        case MOJOSHADER_AST_OP_ADDASSIGN:

        case MOJOSHADER_AST_OP_SUBASSIGN:

        case MOJOSHADER_AST_OP_LSHIFTASSIGN:

        case MOJOSHADER_AST_OP_RSHIFTASSIGN:

        case MOJOSHADER_AST_OP_ANDASSIGN:

        case MOJOSHADER_AST_OP_XORASSIGN:

        case MOJOSHADER_AST_OP_ORASSIGN:

        case MOJOSHADER_AST_OP_COMMA:

            print_ast(io, 0, ast->binary.left);

            if (ast->ast.type != MOJOSHADER_AST_OP_COMMA)

                fprintf(io, " ");  // no space before the comma.

            fprintf(io, "%s ", binary[

                (typeint - MOJOSHADER_AST_OP_START_RANGE_BINARY) - 1]);

            print_ast(io, 0, ast->binary.right);

            break;

        case MOJOSHADER_AST_OP_DEREF_ARRAY:

            print_ast(io, 0, ast->binary.left);

            fprintf(io, "[");

            print_ast(io, 0, ast->binary.right);

            fprintf(io, "]");

            break;

        case MOJOSHADER_AST_OP_DEREF_STRUCT:

            print_ast(io, 0, ast->derefstruct.identifier);

            fprintf(io, ".");

            fprintf(io, "%s", ast->derefstruct.member);

            break;

        case MOJOSHADER_AST_OP_CONDITIONAL:

            print_ast(io, 0, ast->ternary.left);

            fprintf(io, " ? ");

            print_ast(io, 0, ast->ternary.center);

            fprintf(io, " : ");

            print_ast(io, 0, ast->ternary.right);

            break;

        case MOJOSHADER_AST_OP_IDENTIFIER:

            fprintf(io, "%s", ast->identifier.identifier);

            break;

        case MOJOSHADER_AST_OP_INT_LITERAL:

            fprintf(io, "%d", ast->intliteral.value);

            break;

        case MOJOSHADER_AST_OP_FLOAT_LITERAL:

        {

            const float f = ast->floatliteral.value;

            const long long flr = (long long) f;

            if (((float) flr) == f)

                fprintf(io, "%lld.0", flr);

            else

                fprintf(io, "%.16g", f);

            break;

        } // case

        case MOJOSHADER_AST_OP_STRING_LITERAL:

            fprintf(io, "\"%s\"", ast->stringliteral.string);

            break;

        case MOJOSHADER_AST_OP_BOOLEAN_LITERAL:

            fprintf(io, "%s", ast->boolliteral.value ? "true" : "false");

            break;

        case MOJOSHADER_AST_ARGUMENTS:

            print_ast(io, 0, ast->arguments.argument);

            if (ast->arguments.next != NULL)

            {

                fprintf(io, ", ");

                print_ast(io, 0, ast->arguments.next);

            } // if

            break;

        case MOJOSHADER_AST_OP_CALLFUNC:

            print_ast(io, 0, ast->callfunc.identifier);

            fprintf(io, "(");

            print_ast(io, 0, ast->callfunc.args);

            fprintf(io, ")");

            break;

        case MOJOSHADER_AST_OP_CONSTRUCTOR:

            print_ast_datatype(io, ast->constructor.datatype);

            fprintf(io, "(");

            print_ast(io, 0, ast->constructor.args);

            fprintf(io, ")");

            break;

        case MOJOSHADER_AST_OP_CAST:

            fprintf(io, "(");

            print_ast_datatype(io, ast->cast.datatype);

            fprintf(io, ") (");

            print_ast(io, 0, ast->cast.operand);

            fprintf(io, ")");

            break;

        case MOJOSHADER_AST_STATEMENT_EXPRESSION:

            DO_INDENT;

            print_ast(io, 0, ast->exprstmt.expr);  // !!! FIXME: This is named badly...

            fprintf(io, ";%s", nl);

            print_ast(io, 0, ast->exprstmt.next);

            break;

        case MOJOSHADER_AST_STATEMENT_IF:

            DO_INDENT;

            fprintf(io, "if (");

            print_ast(io, 0, ast->ifstmt.expr);

            fprintf(io, ")\n");

            isblock = ast->ifstmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;

            if (!isblock) indent++;

            print_ast(io, 0, ast->ifstmt.statement);

            if (!isblock) indent--;

            print_ast(io, 0, ast->ifstmt.next);

            break;

        case MOJOSHADER_AST_STATEMENT_TYPEDEF:

            DO_INDENT;

            print_ast(io, 1, ast->typedefstmt.type_info);

            fprintf(io, "%s", nl);

            print_ast(io, 0, ast->typedefstmt.next);

            break;

        case MOJOSHADER_AST_STATEMENT_SWITCH:

            DO_INDENT;

            switch ( ast->switchstmt.attributes )

            {

                case MOJOSHADER_AST_SWITCHATTR_NONE: break;

                case MOJOSHADER_AST_SWITCHATTR_FLATTEN: fprintf(io, "[flatten] "); break;

                case MOJOSHADER_AST_SWITCHATTR_BRANCH: fprintf(io, "[branch] "); break;

                case MOJOSHADER_AST_SWITCHATTR_FORCECASE: fprintf(io, "[forcecase] "); break;

                case MOJOSHADER_AST_SWITCHATTR_CALL: fprintf(io, "[call] "); break;

            } // switch

            fprintf(io, "switch (");

            print_ast(io, 0, ast->switchstmt.expr);

            fprintf(io, ")\n");

            DO_INDENT;

            fprintf(io, "{\n");

            indent++;

            print_ast(io, 0, ast->switchstmt.cases);

            indent--;

            fprintf(io, "\n");

            DO_INDENT;

            fprintf(io, "}\n");

            print_ast(io, 0, ast->switchstmt.next);

            break;

        case MOJOSHADER_AST_SWITCH_CASE:

            DO_INDENT;

            fprintf(io, "case ");

            print_ast(io, 0, ast->cases.expr);

            fprintf(io, ":\n");

            isblock = ast->cases.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;

            if (!isblock) indent++;

            print_ast(io, 0, ast->cases.statement);

            if (!isblock) indent--;

            print_ast(io, 0, ast->cases.next);

            break;

        case MOJOSHADER_AST_STATEMENT_STRUCT:

            DO_INDENT;

            print_ast(io, 0, ast->structstmt.struct_info);

            fprintf(io, ";%s%s", nl, nl);  // always space these out.

            print_ast(io, 0, ast->structstmt.next);

            break;

        case MOJOSHADER_AST_STATEMENT_VARDECL:

            DO_INDENT;

            print_ast(io, 1, ast->vardeclstmt.declaration);

            fprintf(io, ";%s", nl);

            print_ast(io, 0, ast->vardeclstmt.next);

            break;

        case MOJOSHADER_AST_STATEMENT_BLOCK:

            DO_INDENT;

            fprintf(io, "{\n");

            indent++;

            print_ast(io, 0, ast->blockstmt.statements);

            indent--;

            DO_INDENT;

            fprintf(io, "}\n");

            print_ast(io, 0, ast->blockstmt.next);

            break;

        case MOJOSHADER_AST_STATEMENT_FOR:

            DO_INDENT;

            print_unroll_attr(io, ast->forstmt.unroll);

            fprintf(io, "for (");

            print_ast(io, 1, ast->forstmt.var_decl);

            print_ast(io, 1, ast->forstmt.initializer);

            fprintf(io, "; ");

            print_ast(io, 1, ast->forstmt.looptest);

            fprintf(io, "; ");

            print_ast(io, 1, ast->forstmt.counter);

            fprintf(io, ")\n");

            isblock = ast->forstmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;

            if (!isblock) indent++;

            print_ast(io, 0, ast->forstmt.statement);

            if (!isblock) indent--;

            print_ast(io, 0, ast->forstmt.next);

            break;

        case MOJOSHADER_AST_STATEMENT_DO:

            DO_INDENT;

            print_unroll_attr(io, ast->dostmt.unroll);

            fprintf(io, "do\n");

            isblock = ast->dostmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;

            if (!isblock) indent++;

            print_ast(io, 0, ast->dostmt.statement);

            if (!isblock) indent--;

            DO_INDENT;

            fprintf(io, "while (");

            print_ast(io, 0, ast->dostmt.expr);

            fprintf(io, ");\n");

            print_ast(io, 0, ast->dostmt.next);

            break;

        case MOJOSHADER_AST_STATEMENT_WHILE:

            DO_INDENT;

            print_unroll_attr(io, ast->whilestmt.unroll);