#include <assert.h>

#ifndef _WIN32

#define stricmp(a,b) strcasecmp(a,b)

#endif

static void print_unroll_attr(const int unroll)

{

    if (unroll == 0)

        printf("[loop] ");

    else if (unroll < 0)

        printf("[unroll] ");

    else

        printf("[unroll(%d)] ", unroll);

} // print_unroll_attr

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

static void print_ast(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++) printf("    "); } \

    } 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:

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

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

            break;

        case MOJOSHADER_AST_OP_POSTINCREMENT:

        case MOJOSHADER_AST_OP_POSTDECREMENT:

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

            printf("%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:

            printf(" ");  // then fall through! (no space before the comma).

        case MOJOSHADER_AST_OP_COMMA:

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

            printf("%s ", binary[

                (typeint - MOJOSHADER_AST_OP_START_RANGE_BINARY) - 1]);

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

            break;

        case MOJOSHADER_AST_OP_DEREF_ARRAY:

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

            printf("[");

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

            printf("]");

            break;

        case MOJOSHADER_AST_OP_DEREF_STRUCT:

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

            printf(".");

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

            break;

        case MOJOSHADER_AST_OP_CONDITIONAL:

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

            printf(" ? ");

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

            printf(" : ");

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

            break;

        case MOJOSHADER_AST_OP_IDENTIFIER:

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

            break;

        case MOJOSHADER_AST_OP_INT_LITERAL:

            printf("%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)

                printf("%lld.0", flr);

            else

                printf("%.16g", f);

            break;

        } // case

        case MOJOSHADER_AST_OP_STRING_LITERAL:

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

            break;

        case MOJOSHADER_AST_OP_BOOLEAN_LITERAL:

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

            break;

        case MOJOSHADER_AST_ARGUMENTS:

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

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

            {

                printf(", ");

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

            } // if

            break;

        case MOJOSHADER_AST_OP_CALLFUNC:

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

            printf("(");

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

            printf(")");

            break;

        case MOJOSHADER_AST_OP_CONSTRUCTOR:

            printf("%s(", ast->constructor.datatype);

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

            printf(")");

            break;

        case MOJOSHADER_AST_OP_CAST:

            printf("(%s) (", ast->cast.datatype);

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

            printf(")");

            break;

        case MOJOSHADER_AST_STATEMENT_EXPRESSION:

            DO_INDENT;

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

            printf(";%s", nl);

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

            break;

        case MOJOSHADER_AST_STATEMENT_IF:

            DO_INDENT;

            printf("if (");

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

            printf(")\n");

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

            if (!isblock) indent++;

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

            if (!isblock) indent--;

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

            break;

        case MOJOSHADER_AST_STATEMENT_TYPEDEF:

            DO_INDENT;

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

            printf("%s", nl);

            print_ast(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: printf("[flatten] "); break;

                case MOJOSHADER_AST_SWITCHATTR_BRANCH: printf("[branch] "); break;

                case MOJOSHADER_AST_SWITCHATTR_FORCECASE: printf("[forcecase] "); break;

                case MOJOSHADER_AST_SWITCHATTR_CALL: printf("[call] "); break;

            } // switch

            printf("switch (");

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

            printf(")\n");

            DO_INDENT;

            printf("{\n");

            indent++;

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

            indent--;

            printf("\n");

            DO_INDENT;

            printf("}\n");

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

            break;

        case MOJOSHADER_AST_SWITCH_CASE:

            DO_INDENT;

            printf("case ");

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

            printf(":\n");

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

            if (!isblock) indent++;

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

            if (!isblock) indent--;

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

            break;

        case MOJOSHADER_AST_STATEMENT_STRUCT:

            DO_INDENT;

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

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

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

            break;

        case MOJOSHADER_AST_STATEMENT_VARDECL:

            DO_INDENT;

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

            printf(";%s", nl);

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

            break;

        case MOJOSHADER_AST_STATEMENT_BLOCK:

            DO_INDENT;

            printf("{\n");

            indent++;

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

            indent--;

            DO_INDENT;

            printf("}\n");

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

            break;

        case MOJOSHADER_AST_STATEMENT_FOR:

            DO_INDENT;

            print_unroll_attr(ast->forstmt.unroll);

            printf("for (");

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

            if (ast->forstmt.initializer != NULL)

            {

                printf(" = ");

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

            } // if

            printf("; ");

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

            printf("; ");

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

            printf(")\n");

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

            if (!isblock) indent++;

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

            if (!isblock) indent--;

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

            break;

        case MOJOSHADER_AST_STATEMENT_DO:

            DO_INDENT;

            print_unroll_attr(ast->dostmt.unroll);

            printf("do\n");

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

            if (!isblock) indent++;

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

            if (!isblock) indent--;

            DO_INDENT;

            printf("while (");

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

            printf(");\n");

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

            break;

        case MOJOSHADER_AST_STATEMENT_WHILE:

            DO_INDENT;

            print_unroll_attr(ast->whilestmt.unroll);

            printf("while (");

            print_ast(0, ast->whilestmt.expr);

            printf(")\n");

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

            if (!isblock) indent++;

            print_ast(0, ast->whilestmt.statement);

            if (!isblock) indent--;

            print_ast(0, ast->whilestmt.next);

            break;

        case MOJOSHADER_AST_STATEMENT_RETURN:

            DO_INDENT;

            printf("return");

            if (ast->returnstmt.expr)

            {

                printf(" ");

                print_ast(0, ast->returnstmt.expr);

            } // if

            printf(";%s", nl);

            print_ast(0, ast->returnstmt.next);

            break;

        case MOJOSHADER_AST_STATEMENT_EMPTY:

        case MOJOSHADER_AST_STATEMENT_BREAK:

        case MOJOSHADER_AST_STATEMENT_CONTINUE:

        case MOJOSHADER_AST_STATEMENT_DISCARD:

            DO_INDENT;

            printf("%s;%s",

                simple_stmt[(typeint-MOJOSHADER_AST_STATEMENT_START_RANGE)-1],

                nl);

            print_ast(0, ast->stmt.next);

            break;

        case MOJOSHADER_AST_COMPUNIT_FUNCTION:

            DO_INDENT;

            print_ast(0, ast->funcunit.declaration);

            if (ast->funcunit.definition == NULL)

                printf(";%s", nl);

            else

            {

                printf("%s", nl);

                print_ast(0, ast->funcunit.definition);

                printf("%s", nl);

            } // else

            print_ast(0, ast->funcunit.next);

            break;

        case MOJOSHADER_AST_COMPUNIT_TYPEDEF:

            DO_INDENT;

            print_ast(0, ast->typedefunit.type_info);

            printf("%s", nl);

            print_ast(0, ast->typedefunit.next);

            break;

        case MOJOSHADER_AST_COMPUNIT_STRUCT:

            DO_INDENT;

            print_ast(0, ast->structunit.struct_info);

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

            print_ast(0, ast->structunit.next);

            break;

        case MOJOSHADER_AST_COMPUNIT_VARIABLE:

            DO_INDENT;

            print_ast(1, ast->varunit.declaration);

            printf(";%s", nl);

            if (ast->varunit.next &&

                ast->varunit.next->ast.type!=MOJOSHADER_AST_COMPUNIT_VARIABLE)

            {

                printf("%s", nl);  // group vars together, and space out other things.

            } // if

            print_ast(0, ast->varunit.next);

            break;

        case MOJOSHADER_AST_SCALAR_OR_ARRAY:

            printf("%s", ast->soa.identifier);

            if (ast->soa.isarray)

            {

                printf("[");

                print_ast(0, ast->soa.dimension);

                printf("]");

            } // if

            break;

        case MOJOSHADER_AST_TYPEDEF:

            DO_INDENT;

            printf("typedef %s%s ",

                   ast->typdef.isconst ? "const " : "", ast->typdef.datatype);

            print_ast(0, ast->typdef.details);

            printf(";%s", nl);

            break;

        case MOJOSHADER_AST_FUNCTION_PARAMS:

            printf("%s", inpmod[(int) ast->params.input_modifier]);

            printf("%s %s", ast->params.datatype, ast->params.identifier);

            if (ast->params.semantic)

                printf(" : %s", ast->params.semantic);

            printf("%s", interpmod[(int) ast->params.interpolation_modifier]);

            if (ast->params.initializer)

            {

                printf(" = ");

                print_ast(0, ast->params.initializer);

            } // if

            if (ast->params.next)

            {

                printf(", ");

                print_ast(0, ast->params.next);

            } // if

            break;

        case MOJOSHADER_AST_FUNCTION_SIGNATURE:

            printf("%s", fnstorage[(int) ast->funcsig.storage_class]);

            printf("%s %s(",

                    ast->funcsig.datatype ? ast->funcsig.datatype : "void",

                    ast->funcsig.identifier);

            print_ast(0, ast->funcsig.params);

            printf(")");

            if (ast->funcsig.semantic)

                printf(" : %s", ast->funcsig.semantic);

            break;

        case MOJOSHADER_AST_STRUCT_DECLARATION:

            printf("struct %s\n", ast->structdecl.name);

            DO_INDENT;

            printf("{\n");

            indent++;