Translate a bunch of the material (lltrans, llasm, abi) from rustboot to rustc, and move files around.

1 files changed, 0 insertions, 348 deletions

diff --git a/src/comp/fe/token.rs b/src/comp/fe/token.rs
deleted file mode 100644
index b9b2fa07..00000000
--- a/src/comp/fe/token.rs
+++ /dev/null
@@ -1,348 +0,0 @@
-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: