import util.common.ty_mach;
import util.common.ty_mach_to_str;
import util.common.new_str_hash;
import std._int;
import std._uint;

tag binop {
    PLUS;
    MINUS;
    STAR;
    SLASH;
    PERCENT;
    CARET;
    AND;
    OR;
    LSL;
    LSR;
    ASR;
}

tag token {
    /* Expression-operator symbols. */
    EQ;
    LT;
    LE;
    EQEQ;
    NE;
    GE;
    GT;
    ANDAND;
    OROR;
    NOT;
    TILDE;

    BINOP(binop);
    BINOPEQ(binop);

    AS;
    WITH;

    /* Structural symbols */
    AT;
    DOT;
    COMMA;
    SEMI;
    COLON;
    QUES;
    RARROW;
    SEND;
    LARROW;
    LPAREN;
    RPAREN;
    LBRACKET;
    RBRACKET;
    LBRACE;
    RBRACE;

    /* Module and crate keywords */
    MOD;
    USE;
    AUTH;
    META;

    /* Metaprogramming keywords */
    SYNTAX;
    POUND;

    /* Statement keywords */
    IF;
    ELSE;
    DO;
    WHILE;
    ALT;
    CASE;

    FAIL;
    DROP;

    IN;
    FOR;
    EACH;
    PUT;
    RET;
    BE;

    /* Type and type-state keywords */
    TYPE;
    CHECK;
    CLAIM;
    PROVE;

    /* Effect keywords */
    IO;
    STATE;
    UNSAFE;

    /* Type qualifiers */
    NATIVE;
    AUTO;
    MUTABLE;

    /* Name management */
    IMPORT;
    EXPORT;

    /* Value / stmt declarators */
    LET;
    CONST;

    /* Magic runtime services */
    LOG;
    SPAWN;
    BIND;
    THREAD;
    YIELD;
    JOIN;

    /* Literals */
    LIT_INT(int);
    LIT_UINT(uint);
    LIT_MACH_INT(ty_mach, int);
    LIT_STR(str);
    LIT_CHAR(char);
    LIT_BOOL(bool);

    /* Name components */
    IDENT(str);
    IDX(int);
    UNDERSCORE;

    /* Reserved type names */
    BOOL;
    INT;
    UINT;
    FLOAT;
    CHAR;
    STR;
    MACH(ty_mach);

    /* Algebraic type constructors */
    REC;
    TUP;
    TAG;
    VEC;
    ANY;

    /* Callable type constructors */
    FN;
    ITER;

    /* Object type */
    OBJ;

    /* Comm and task types */
    CHAN;
    PORT;
    TASK;

    BRACEQUOTE(str);
    EOF;
}

fn binop_to_str(binop o) -> str {
    alt (o) {
        case (PLUS) { ret "+"; }
        case (MINUS) { ret "-"; }
        case (STAR) { ret "*"; }
        case (SLASH) { ret "/"; }
        case (PERCENT) { ret "%"; }
        case (CARET) { ret "^"; }
        case (AND) { ret "&"; }
        case (OR) { ret "|"; }
        case (LSL) { ret "<<"; }
        case (LSR) { ret ">>"; }
        case (ASR) { ret ">>>"; }
    }
}

fn to_str(token t) -> str {
    alt (t) {

        case (EQ) { ret "="; }
        case (LT) { ret "<"; }
        case (LE) { ret "<="; }
        case (EQEQ) { ret "=="; }
        case (NE) { ret "!="; }
        case (GE) { ret ">="; }
        case (GT) { ret ">"; }
        case (NOT) { ret "!"; }
        case (TILDE) { ret "~"; }
        case (OROR) { ret "||"; }
        case (ANDAND) { ret "&&"; }

        case (BINOP(?op)) { ret binop_to_str(op); }
        case (BINOPEQ(?op)) { ret binop_to_str(op) + "="; }

        case (AS) { ret "as"; }
        case (WITH) { ret "with"; }


        /* Structural symbols */
        case (AT) { ret "@"; }
        case (DOT) { ret "."; }
        case (COMMA) { ret ","; }
        case (SEMI) { ret ";"; }
        case (COLON) { ret ":"; }
        case (QUES) { ret "?"; }
        case (RARROW) { ret "->"; }
        case (SEND) { ret "<|"; }
        case (LARROW) { ret "<-"; }
        case (LPAREN) { ret "("; }
        case (RPAREN) { ret ")"; }
        case (LBRACKET) { ret "["; }
        case (RBRACKET) { ret "]"; }
        case (LBRACE) { ret "{"; }
        case (RBRACE) { ret "}"; }

        /* Module and crate keywords */
        case (MOD) { ret "mod"; }
        case (USE) { ret "use"; }
        case (AUTH) { ret "auth"; }
        case (META) { ret "meta"; }

        /* Metaprogramming keywords */
        case (SYNTAX) { ret "syntax"; }
        case (POUND) { ret "#"; }

        /* Statement keywords */
        case (IF) { ret "if"; }
        case (ELSE) { ret "else"; }
        case (DO) { ret "do"; }
        case (WHILE) { ret "while"; }
        case (ALT) { ret "alt"; }
        case (CASE) { ret "case"; }

        case (FAIL) { ret "fail"; }
        case (DROP) { ret "drop"; }

        case (IN) { ret "in"; }
        case (FOR) { ret "for"; }
        case (EACH) { ret "each"; }
        case (PUT) { ret "put"; }
        case (RET) { ret "ret"; }
        case (BE) { ret "be"; }

        /* Type and type-state keywords */
        case (TYPE) { ret "type"; }
        case (CHECK) { ret "check"; }
        case (CLAIM) { ret "claim"; }
        case (PROVE) { ret "prove"; }

        /* Effect keywords */
        case (IO) { ret "io"; }
        case (STATE) { ret "state"; }
        case (UNSAFE) { ret "unsafe"; }

        /* Type qualifiers */
        case (NATIVE) { ret "native"; }
        case (AUTO) { ret "auto"; }
        case (MUTABLE) { ret "mutable"; }

        /* Name management */
        case (IMPORT) { ret "import"; }
        case (EXPORT) { ret "export"; }

        /* Value / stmt declarators */
        case (LET) { ret "let"; }
        case (CONST) { ret "const"; }

        /* Magic runtime services */
        case (LOG) { ret "log"; }
        case (SPAWN) { ret "spawn"; }
        case (BIND) { ret "bind"; }
        case (THREAD) { ret "thread"; }
        case (YIELD) { ret "yield"; }
        case (JOIN) { ret "join"; }

        /* Literals */
        case (LIT_INT(?i)) { ret _int.to_str(i, 10u); }
        case (LIT_UINT(?u)) { ret _uint.to_str(u, 10u); }
        case (LIT_MACH_INT(?tm, ?i)) {
            ret  _int.to_str(i, 10u)
                + "_" + ty_mach_to_str(tm);
        }

        case (LIT_STR(?s)) {
            // FIXME: escape.
            ret "\"" + s + "\"";
        }
        case (LIT_CHAR(?c)) {
            // FIXME: escape and encode.
            auto tmp = "'";
            tmp += c as u8;
            tmp += '\'' as u8;
            ret tmp;
        }

        case (LIT_BOOL(?b)) {
            if (b) { ret "true"; } else { ret "false"; }
        }

        /* Name components */
        case (IDENT(?s)) { auto si = "ident:"; si += s; ret si; }
        case (IDX(?i)) { ret "_" + _int.to_str(i, 10u); }
        case (UNDERSCORE) { ret "_"; }

        /* Reserved type names */
        case (BOOL) { ret "bool"; }
        case (INT) { ret "int"; }
        case (UINT) { ret "uint"; }
        case (FLOAT) { ret "float"; }
        case (CHAR) { ret "char"; }
        case (STR) { ret "str"; }
        case (MACH(?tm)) { ret ty_mach_to_str(tm); }

        /* Algebraic type constructors */
        case (REC) { ret "rec"; }
        case (TUP) { ret "tup"; }
        case (TAG) { ret "tag"; }
        case (VEC) { ret "vec"; }
        case (ANY) { ret "any"; }

        /* Callable type constructors */
        case (FN) { ret "fn"; }
        case (ITER) { ret "iter"; }

        /* Object type */
        case (OBJ) { ret "obj"; }

        /* Comm and task types */
        case (CHAN) { ret "chan"; }
        case (PORT) { ret "port"; }
        case (TASK) { ret "task"; }

        case (BRACEQUOTE(_)) { ret "<bracequote>"; }
        case (EOF) { ret "<eof>"; }
    }
}



// Local Variables:
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// compile-command: "make -k -C ../.. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
// End: