ensure size of longs and ints

Compiler.c

@@ -16,8 +16,8 @@
 #define BREAK_BUFFER 32
 
 #define DT_OPERATION(op)                                                       \
-    case DT_INT: cAddOperation(OP_##op##_INT); break;                          \
-    case DT_LONG: cAddOperation(OP_##op##_LONG); break;                        \
+    case DT_INT32: cAddOperation(OP_##op##_INT32); break;                      \
+    case DT_INT64: cAddOperation(OP_##op##_INT64); break;                      \
     case DT_BOOL: cAddOperation(OP_##op##_BOOL); break;                        \
     case DT_FLOAT: cAddOperation(OP_##op##_FLOAT); break;
 
@@ -58,27 +58,28 @@ typedef struct {
 #define TYPE_OP(NAME, INT, LONG, FLOAT, BOOL, POINTER, text)                   \
     static const TypedOp TYPED_##NAME = {OP_##INT,  OP_##LONG,    OP_##FLOAT,  \
                                          OP_##BOOL, OP_##POINTER, text};
-TYPE_OP(MUL, MUL_INT, MUL_LONG, MUL_FLOAT, NOTHING, NOTHING, "*")
-TYPE_OP(DIV, DIV_INT, DIV_LONG, DIV_FLOAT, NOTHING, NOTHING, "/")
-TYPE_OP(MOD, MOD_INT, MOD_LONG, NOTHING, NOTHING, NOTHING, "%")
-TYPE_OP(ADD, ADD_INT, ADD_LONG, ADD_FLOAT, NOTHING, NOTHING, "+")
-TYPE_OP(SUB, SUB_INT, SUB_LONG, SUB_FLOAT, NOTHING, NOTHING, "-")
-TYPE_OP(LESS, LESS_INT, LESS_LONG, LESS_FLOAT, NOTHING, NOTHING, "<")
-TYPE_OP(LESS_EQUAL, GREATER_INT, GREATER_LONG, GREATER_FLOAT, NOTHING, NOTHING,
-        "<=")
-TYPE_OP(GREATER, GREATER_INT, GREATER_LONG, GREATER_FLOAT, NOTHING, NOTHING,
+TYPE_OP(MUL, MUL_INT32, MUL_INT64, MUL_FLOAT, NOTHING, NOTHING, "*")
+TYPE_OP(DIV, DIV_INT32, DIV_INT64, DIV_FLOAT, NOTHING, NOTHING, "/")
+TYPE_OP(MOD, MOD_INT32, MOD_INT64, NOTHING, NOTHING, NOTHING, "%")
+TYPE_OP(ADD, ADD_INT32, ADD_INT64, ADD_FLOAT, NOTHING, NOTHING, "+")
+TYPE_OP(SUB, SUB_INT32, SUB_INT64, SUB_FLOAT, NOTHING, NOTHING, "-")
+TYPE_OP(LESS, LESS_INT32, LESS_INT64, LESS_FLOAT, NOTHING, NOTHING, "<")
+TYPE_OP(LESS_EQUAL, GREATER_INT32, GREATER_INT64, GREATER_FLOAT, NOTHING,
+        NOTHING, "<=")
+TYPE_OP(GREATER, GREATER_INT32, GREATER_INT64, GREATER_FLOAT, NOTHING, NOTHING,
         ">")
-TYPE_OP(GREATER_EQUAL, LESS_INT, LESS_LONG, LESS_FLOAT, NOTHING, NOTHING, ">=")
-TYPE_OP(EQUAL, EQUAL_INT, EQUAL_LONG, EQUAL_FLOAT, EQUAL_BOOL, EQUAL_POINTER,
+TYPE_OP(GREATER_EQUAL, LESS_INT32, LESS_INT64, LESS_FLOAT, NOTHING, NOTHING,
+        ">=")
+TYPE_OP(EQUAL, EQUAL_INT32, EQUAL_INT64, EQUAL_FLOAT, EQUAL_BOOL, EQUAL_POINTER,
         "==")
-TYPE_OP(NOT_EQUAL, EQUAL_INT, EQUAL_LONG, EQUAL_FLOAT, EQUAL_BOOL,
+TYPE_OP(NOT_EQUAL, EQUAL_INT32, EQUAL_INT64, EQUAL_FLOAT, EQUAL_BOOL,
         EQUAL_POINTER, "!=")
-TYPE_OP(BIT_OR, BIT_OR_INT, BIT_OR_LONG, NOTHING, NOTHING, NOTHING, "|")
-TYPE_OP(BIT_XOR, BIT_XOR_INT, BIT_XOR_LONG, NOTHING, NOTHING, NOTHING, "^")
-TYPE_OP(BIT_AND, BIT_AND_INT, BIT_AND_LONG, NOTHING, NOTHING, NOTHING, "&")
-TYPE_OP(LEFT_SHIFT, LEFT_SHIFT_INT, LEFT_SHIFT_LONG, NOTHING, NOTHING, NOTHING,
-        "<<")
-TYPE_OP(RIGHT_SHIFT, RIGHT_SHIFT_INT, RIGHT_SHIFT_LONG, NOTHING, NOTHING,
+TYPE_OP(BIT_OR, BIT_OR_INT32, BIT_OR_INT64, NOTHING, NOTHING, NOTHING, "|")
+TYPE_OP(BIT_XOR, BIT_XOR_INT32, BIT_XOR_INT64, NOTHING, NOTHING, NOTHING, "^")
+TYPE_OP(BIT_AND, BIT_AND_INT32, BIT_AND_INT64, NOTHING, NOTHING, NOTHING, "&")
+TYPE_OP(LEFT_SHIFT, LEFT_SHIFT_INT32, LEFT_SHIFT_INT64, NOTHING, NOTHING,
+        NOTHING, "<<")
+TYPE_OP(RIGHT_SHIFT, RIGHT_SHIFT_INT32, RIGHT_SHIFT_INT64, NOTHING, NOTHING,
         NOTHING, ">>")
 
 static void cError(const char* format, ...) {
@@ -118,30 +119,30 @@ static void cAddOperation(Operation token) {
     bcAddBytes(code, &c, 1);
 }
 
-static int cReserveInt() {
-    return bcReserveBytes(code, sizeof(int));
+static int32 cReserveInt32() {
+    return bcReserveBytes(code, sizeof(int32));
 }
 
-static void cSetInt(int p, int i) {
-    bcSetBytes(code, p, &i, sizeof(int));
+static void cSetInt32(int p, int32 i) {
+    bcSetBytes(code, p, &i, sizeof(int32));
 }
 
-static void cAddInt(int i) {
-    bcAddBytes(code, &i, sizeof(int));
+static void cAddInt32(int32 i) {
+    bcAddBytes(code, &i, sizeof(int32));
 }
 
-static void cAddLong(long l) {
-    bcAddBytes(code, &l, sizeof(long));
+static void cAddInt64(int64 i) {
+    bcAddBytes(code, &i, sizeof(int64));
 }
 
-static void cAddIntOperation(Operation token, int i) {
+static void cAddInt32Operation(Operation token, int32 i) {
     cAddOperation(token);
-    cAddInt(i);
+    cAddInt32(i);
 }
 
-static void cAddByteOperation(Operation token, char c) {
+static void cAddByteOperation(Operation token, int8 i) {
     cAddOperation(token);
-    bcAddBytes(code, &c, sizeof(char));
+    bcAddBytes(code, &i, sizeof(int8));
 }
 
 static void cAddLine(int16 i) {
@@ -169,21 +170,21 @@ static bool cConsumeTokenIf(Token t) {
     return tPeekToken() == t && cReadTokenAndLine() == t;
 }
 
-static void cConstantInt() {
-    int value;
-    if(!tReadInt(&value)) {
+static void cConstantInt32() {
+    int32 value;
+    if(!tReadInt32(&value)) {
         cError("int token without an int");
     }
-    cAddIntOperation(OP_PUSH_INT, value);
+    cAddInt32Operation(OP_PUSH_INT32, value);
 }
 
-static void cConstantLong() {
-    long value;
-    if(!tReadLong(&value)) {
+static void cConstantInt64() {
+    int64 value;
+    if(!tReadInt64(&value)) {
         cError("long token without an long");
     }
-    cAddOperation(OP_PUSH_LONG);
-    cAddLong(value);
+    cAddOperation(OP_PUSH_INT64);
+    cAddInt64(value);
 }
 
 static void cConstantFloat() {
@@ -223,8 +224,8 @@ static DataType cExtendType(DataType dt) {
 
 static DataType cReadType(Token t) {
     switch(t) {
-        case T_INT: return cExtendType(dtInt());
-        case T_LONG: return cExtendType(dtLong());
+        case T_INT32: return cExtendType(dtInt32());
+        case T_INT64: return cExtendType(dtInt64());
         case T_BOOL: return cExtendType(dtBool());
         case T_FLOAT: return cExtendType(dtFloat());
         case T_LITERAL:
@@ -248,7 +249,7 @@ static void cLoadRef(DataType type) {
     }
     switch(type.type) {
         DT_OPERATION(LOAD);
-        case DT_STRUCT: cAddIntOperation(OP_LOAD, cGetSize(type)); break;
+        case DT_STRUCT: cAddInt32Operation(OP_LOAD, cGetSize(type)); break;
         default: cError("cannot load type %s", cGetName(type));
     }
 }
@@ -291,20 +292,20 @@ static DataType cCallFunction(const char* name) {
     if(found == NULL) {
         cError("unknown function");
     } else if(found->global) {
-        cAddIntOperation(OP_CALL, found->line);
+        cAddInt32Operation(OP_CALL, found->line);
         return found->returnType;
     }
-    char push[1 + sizeof(int)] = {OP_PUSH_INT};
-    bcInsertBytes(code, push, 5, returnAddress);
+    char push[1 + sizeof(int32)] = {OP_PUSH_INT32};
+    bcInsertBytes(code, push, sizeof(push), returnAddress);
     cAddOperation(OP_GOSUB);
     if(found->address == -1) {
         f.returnType = found->returnType;
-        f.address = cReserveInt();
+        f.address = cReserveInt32();
         fsAdd(&functionQueue, &f);
     } else {
-        cAddInt(found->address);
+        cAddInt32(found->address);
     }
-    cAddInt(found->size);
+    cAddInt32(found->size);
     return found->returnType;
 }
 
@@ -334,7 +335,7 @@ static DataType cLiteral() {
     if(vsSearch(&vars, &v, literal)) {
         cNotDeclared(literal);
     }
-    cAddIntOperation(OP_DEREFERENCE_VAR, v.address);
+    cAddInt32Operation(OP_DEREFERENCE_VAR, v.address);
     return dtToVariable(v.type);
 }
 
@@ -345,7 +346,7 @@ static DataType cBracketPrimary() {
 }
 
 static void cArrayIndex(const char* name) {
-    if(!dtIsInt(cUnpackedExpression())) {
+    if(!dtIsInt32(cUnpackedExpression())) {
         cError("array %s must be an int", name);
     }
 }
@@ -355,7 +356,7 @@ static DataType cAllocArray() {
     cConsumeToken(T_OPEN_SQUARE_BRACKET);
     cArrayIndex("size");
     cConsumeToken(T_CLOSE_SQUARE_BRACKET);
-    cAddIntOperation(OP_NEW, cGetSize(dt));
+    cAddInt32Operation(OP_NEW, cGetSize(dt));
     return cDereference(dt);
 }
 
@@ -365,14 +366,14 @@ static DataType cLength() {
         cError("length expects a pointer");
     }
     cAddOperation(OP_LENGTH);
-    return dtInt();
+    return dtInt32();
 }
 
 static DataType cPrimary() {
     Token t = cReadTokenAndLine();
     switch(t) {
-        case T_CONST_INT: cConstantInt(); return dtInt();
-        case T_CONST_LONG: cConstantLong(); return dtLong();
+        case T_CONST_INT32: cConstantInt32(); return dtInt32();
+        case T_CONST_INT64: cConstantInt64(); return dtInt64();
         case T_CONST_FLOAT: cConstantFloat(); return dtFloat();
         case T_TRUE: cAddOperation(OP_PUSH_TRUE); return dtBool();
         case T_FALSE: cAddOperation(OP_PUSH_FALSE); return dtBool();
@@ -409,10 +410,10 @@ static void cChangeType(DataType* dt, Operation op, Operation pushOp,
 
 static void cPostChange(DataType* dt, int change, const char* name) {
     cRemoveReference(dt, name);
-    if(dtCompare(*dt, dtInt())) {
-        cChangeType(dt, OP_CHANGE_INT, OP_PUSH_POST_CHANGE_INT, change);
-    } else if(dtCompare(*dt, dtLong())) {
-        cChangeType(dt, OP_CHANGE_LONG, OP_PUSH_POST_CHANGE_LONG, change);
+    if(dtCompare(*dt, dtInt32())) {
+        cChangeType(dt, OP_CHANGE_INT32, OP_PUSH_POST_CHANGE_INT32, change);
+    } else if(dtCompare(*dt, dtInt64())) {
+        cChangeType(dt, OP_CHANGE_INT64, OP_PUSH_POST_CHANGE_INT64, change);
     } else {
         cError("%s needs an int or long not %s", name, cGetName(*dt));
     }
@@ -429,8 +430,8 @@ static DataType cStructAccess(DataType dt, int pointers) {
     if(vSearchStruct(&inner, &structs, st, name)) {
         cError("%s has no member %s", st->name, name);
     } else if(inner.address > 0) {
-        cAddIntOperation(OP_PUSH_INT, inner.address);
-        cAddIntOperation(OP_ADD_REFERENCE, 1);
+        cAddInt32Operation(OP_PUSH_INT32, inner.address);
+        cAddInt32Operation(OP_ADD_REFERENCE, 1);
     }
     return dtToVariable(inner.type);
 }
@@ -455,7 +456,7 @@ static DataType cAccess() {
             cArrayIndex("index");
             cConsumeToken(T_CLOSE_SQUARE_BRACKET);
             dt = dtReference(dt);
-            cAddIntOperation(OP_ADD_REFERENCE, cGetSize(dt));
+            cAddInt32Operation(OP_ADD_REFERENCE, cGetSize(dt));
             dt = dtToVariable(dt);
         } else {
             return dt;
@@ -465,10 +466,10 @@ static DataType cAccess() {
 
 static DataType cPreChange(DataType dt, int change, const char* name) {
     cRemoveReference(&dt, name);
-    if(dtCompare(dt, dtInt())) {
-        cChangeType(&dt, OP_CHANGE_INT, OP_PUSH_PRE_CHANGE_INT, change);
-    } else if(dtCompare(dt, dtLong())) {
-        cChangeType(&dt, OP_CHANGE_LONG, OP_PUSH_PRE_CHANGE_LONG, change);
+    if(dtCompare(dt, dtInt32())) {
+        cChangeType(&dt, OP_CHANGE_INT32, OP_PUSH_PRE_CHANGE_INT32, change);
+    } else if(dtCompare(dt, dtInt64())) {
+        cChangeType(&dt, OP_CHANGE_INT64, OP_PUSH_PRE_CHANGE_INT64, change);
     } else {
         cError("%s needs an int or long not %s", name, cGetName(dt));
     }
@@ -476,10 +477,10 @@ static DataType cPreChange(DataType dt, int change, const char* name) {
 }
 
 static DataType cInvertSign(DataType dt) {
-    if(dtIsInt(dt)) {
-        cAddOperation(OP_INVERT_SIGN_INT);
-    } else if(dtIsLong(dt)) {
-        cAddOperation(OP_INVERT_SIGN_LONG);
+    if(dtIsInt32(dt)) {
+        cAddOperation(OP_INVERT_SIGN_INT32);
+    } else if(dtIsInt64(dt)) {
+        cAddOperation(OP_INVERT_SIGN_INT64);
     } else if(dtIsFloat(dt)) {
         cAddOperation(OP_INVERT_SIGN_FLOAT);
     } else {
@@ -504,14 +505,16 @@ static DataType cPreUnary() {
     int marker = tGetMarker();
     if(cConsumeTokenIf(T_OPEN_BRACKET)) {
         if(cConsumeTokenIf(T_FLOAT) && cConsumeTokenIf(T_CLOSE_BRACKET)) {
-            return cCast(cUnpack(cPreUnary()), dtInt(), OP_INT_TO_FLOAT,
-                         dtLong(), OP_LONG_TO_FLOAT, dtFloat());
-        } else if(cConsumeTokenIf(T_INT) && cConsumeTokenIf(T_CLOSE_BRACKET)) {
-            return cCast(cUnpack(cPreUnary()), dtFloat(), OP_FLOAT_TO_INT,
-                         dtLong(), OP_LONG_TO_INT, dtInt());
-        } else if(cConsumeTokenIf(T_LONG) && cConsumeTokenIf(T_CLOSE_BRACKET)) {
-            return cCast(cUnpack(cPreUnary()), dtInt(), OP_INT_TO_LONG,
-                         dtFloat(), OP_FLOAT_TO_LONG, dtLong());
+            return cCast(cUnpack(cPreUnary()), dtInt32(), OP_INT32_TO_FLOAT,
+                         dtInt64(), OP_INT64_TO_FLOAT, dtFloat());
+        } else if(cConsumeTokenIf(T_INT32) &&
+                  cConsumeTokenIf(T_CLOSE_BRACKET)) {
+            return cCast(cUnpack(cPreUnary()), dtFloat(), OP_FLOAT_TO_INT32,
+                         dtInt64(), OP_INT64_TO_INT32, dtInt32());
+        } else if(cConsumeTokenIf(T_INT64) &&
+                  cConsumeTokenIf(T_CLOSE_BRACKET)) {
+            return cCast(cUnpack(cPreUnary()), dtInt32(), OP_INT32_TO_INT64,
+                         dtFloat(), OP_FLOAT_TO_INT64, dtInt64());
         }
     }
     tReset(marker);
@@ -528,10 +531,10 @@ static DataType cPreUnary() {
         return dt;
     } else if(cConsumeTokenIf(T_BIT_NOT)) {
         DataType dt = cPreUnary();
-        if(dtCompare(dt, dtInt())) {
-            cAddOperation(OP_BIT_NOT_INT);
-        } else if(dtCompare(dt, dtLong())) {
-            cAddOperation(OP_BIT_NOT_LONG);
+        if(dtCompare(dt, dtInt32())) {
+            cAddOperation(OP_BIT_NOT_INT32);
+        } else if(dtCompare(dt, dtInt64())) {
+            cAddOperation(OP_BIT_NOT_INT64);
         } else {
             cError("~ needs an int or long not %s", cGetName(dt));
         }
@@ -561,9 +564,9 @@ static void cAddTypeOperation(DataType* a, Parser bf, const TypedOp* op) {
     DataType b = cUnpack(bf());
     if(!dtCompare(*a, b)) {
         cInvalidOperation(*a, b, op->name);
-    } else if(dtIsInt(*a) && op->intOp != OP_NOTHING) {
+    } else if(dtIsInt32(*a) && op->intOp != OP_NOTHING) {
         cAddOperation(op->intOp);
-    } else if(dtIsLong(*a) && op->longOp != OP_NOTHING) {
+    } else if(dtIsInt64(*a) && op->longOp != OP_NOTHING) {
         cAddOperation(op->longOp);
     } else if(dtIsFloat(*a) && op->floatOp != OP_NOTHING) {
         cAddOperation(op->floatOp);
@@ -681,13 +684,13 @@ static DataType cLogical(Parser f, Token t, Operation jump, Operation op) {
     while(cConsumeTokenIf(t)) {
         a = cUnpack(a);
         cAddOperation(jump);
-        int p = cReserveInt();
+        int32 p = cReserveInt32();
         DataType b = cUnpack(f());
         if(!dtIsBool(a) || !dtIsBool(b)) {
             cInvalidOperation(a, b, tGetName(t));
         }
         cAddOperation(op);
-        cSetInt(p, code->length);
+        cSetInt32(p, code->length);
     }
     return a;
 }
@@ -725,7 +728,7 @@ static void cAddReturn(Operation op) {
         cError("too much returns in function");
     }
     cAddOperation(op);
-    returns[returnIndex++] = cReserveInt();
+    returns[returnIndex++] = cReserveInt32();
 }
 
 static void cReturn() {
@@ -738,10 +741,10 @@ static void cReturn() {
     DataType dt = cUnpackedExpression();
     if(!cCompare(returnType, dt)) {
         cError("wrong return type, should be %s", cGetName(returnType));
-    } else if(dtIsInt(dt)) {
-        cAddReturn(OP_RETURN_INT);
-    } else if(dtIsLong(dt)) {
-        cAddReturn(OP_RETURN_LONG);
+    } else if(dtIsInt32(dt)) {
+        cAddReturn(OP_RETURN_INT32);
+    } else if(dtIsInt64(dt)) {
+        cAddReturn(OP_RETURN_INT64);
     } else if(dtIsBool(dt)) {
         cAddReturn(OP_RETURN_BOOL);
     } else if(dtIsFloat(dt)) {
@@ -760,27 +763,27 @@ static void cIf() {
     cExpectType(cUnpackedExpression(), dtBool(), "if");
     cConsumeToken(T_CLOSE_BRACKET);
     cAddOperation(OP_IF_GOTO);
-    int ifP = cReserveInt();
+    int32 ifP = cReserveInt32();
     cConsumeToken(T_OPEN_CURVED_BRACKET);
     cConsumeScope();
-    cSetInt(ifP, code->length);
+    cSetInt32(ifP, code->length);
     if(cConsumeTokenIf(T_ELSE)) {
         cAddOperation(OP_GOTO);
-        int elseP = cReserveInt();
-        cSetInt(ifP, code->length);
+        int32 elseP = cReserveInt32();
+        cSetInt32(ifP, code->length);
         if(cConsumeTokenIf(T_IF)) {
             cIf();
         } else {
             cConsumeToken(T_OPEN_CURVED_BRACKET);
             cConsumeScope();
         }
-        cSetInt(elseP, code->length);
+        cSetInt32(elseP, code->length);
     }
 }
 
 static void cConsumeBreaks(int start, int address) {
     for(int i = start; i < breakIndex; i++) {
-        cSetInt(breaks[i], address);
+        cSetInt32(breaks[i], address);
     }
     breakIndex = start;
 }
@@ -791,7 +794,7 @@ static void cWhile() {
     cExpectType(cUnpackedExpression(), dtBool(), "while");
     cConsumeToken(T_CLOSE_BRACKET);
     cAddOperation(OP_IF_GOTO);
-    int ifP = cReserveInt();
+    int32 ifP = cReserveInt32();
     int breakStart = breakIndex;
     forWhileStack++;
     int oldContinue = continueAt;
@@ -800,8 +803,8 @@ static void cWhile() {
     cConsumeScope();
     continueAt = oldContinue;
     forWhileStack--;
-    cAddIntOperation(OP_GOTO, start);
-    cSetInt(ifP, code->length);
+    cAddInt32Operation(OP_GOTO, start);
+    cSetInt32(ifP, code->length);
     cConsumeBreaks(breakStart, code->length);
 }
 
@@ -855,7 +858,7 @@ static void cDeclare(DataType dt) {
     Variable* v = vsAdd(&vars, var, dt, &structs);
     if(dt.type != DT_STRUCT || dtIsPointer(dt)) {
         cConsumeToken(T_SET);
-        cAddIntOperation(OP_DEREFERENCE_VAR, v->address);
+        cAddInt32Operation(OP_DEREFERENCE_VAR, v->address);
         cStore(v->type, cUnpackedExpression(), "=");
     }
 }
@@ -872,8 +875,8 @@ static void cLineExpression() {
         }
     }
     switch(t) {
-        case T_INT: cDeclare(dtInt()); break;
-        case T_LONG: cDeclare(dtLong()); break;
+        case T_INT32: cDeclare(dtInt32()); break;
+        case T_INT64: cDeclare(dtInt64()); break;
         case T_BOOL: cDeclare(dtBool()); break;
         case T_FLOAT: cDeclare(dtFloat()); break;
         case T_DELETE: cDelete(); break;
@@ -892,14 +895,14 @@ static void cFor() {
     cExpectType(cUnpackedExpression(), dtBool(), "for");
     cConsumeToken(T_SEMICOLON);
     cAddOperation(OP_IF_GOTO);
-    int end = cReserveInt();
+    int32 end = cReserveInt32();
     cAddOperation(OP_GOTO);
-    int beginBody = cReserveInt();
+    int32 beginBody = cReserveInt32();
     int startPerLoop = code->length;
     cLineExpression();
-    cAddIntOperation(OP_GOTO, startCheck);
+    cAddInt32Operation(OP_GOTO, startCheck);
     cConsumeToken(T_CLOSE_BRACKET);
-    cSetInt(beginBody, code->length);
+    cSetInt32(beginBody, code->length);
     int breakStart = breakIndex;
     forWhileStack++;
     int oldContinue = continueAt;
@@ -908,8 +911,8 @@ static void cFor() {
     cConsumeBody();
     continueAt = oldContinue;
     forWhileStack--;
-    cAddIntOperation(OP_GOTO, startPerLoop);
-    cSetInt(end, code->length);
+    cAddInt32Operation(OP_GOTO, startPerLoop);
+    cSetInt32(end, code->length);
     cConsumeBreaks(breakStart, code->length);
 
     vsLeaveScope(&vars, &scope);
@@ -922,7 +925,7 @@ static void cBreak() {
         cError("too much breaks");
     }
     cAddOperation(OP_GOTO);
-    breaks[breakIndex++] = cReserveInt();
+    breaks[breakIndex++] = cReserveInt32();
     cConsumeToken(T_SEMICOLON);
 }
 
@@ -930,7 +933,7 @@ static void cContinue() {
     if(forWhileStack == 0) {
         cError("continue without for or while");
     }
-    cAddIntOperation(OP_GOTO, continueAt);
+    cAddInt32Operation(OP_GOTO, continueAt);
     cConsumeToken(T_SEMICOLON);
 }
 
@@ -996,17 +999,17 @@ static void cAddFunction(Function* found, Function* f) {
 static void cInnerFunction(Function* f) {
     cConsumeToken(T_OPEN_CURVED_BRACKET);
     cAddOperation(OP_RESERVE);
-    int p = cReserveInt();
-    cAddInt(f->size);
+    int32 p = cReserveInt32();
+    cAddInt32(f->size);
     returnIndex = 0;
     cConsumeScope();
     if(!dtIsVoid(returnType) && hasReturn <= 0) {
         cError("missing return");
     }
-    cAddIntOperation(OP_RETURN, vars.maxAddress);
-    cSetInt(p, vars.maxAddress);
+    cAddInt32Operation(OP_RETURN, vars.maxAddress);
+    cSetInt32(p, vars.maxAddress);
     for(int i = 0; i < returnIndex; i++) {
-        cSetInt(returns[i], vars.maxAddress);
+        cSetInt32(returns[i], vars.maxAddress);
     }
     returnIndex = 0;
 }
@@ -1022,12 +1025,12 @@ static void cFunction(DataType rType) {
     }
     cAddLine(line);
     cAddOperation(OP_GOTO);
-    int end = cReserveInt();
+    int32 end = cReserveInt32();
     f.address = code->length;
     cAddFunction(found, &f);
     returnType = rType;
     cInnerFunction(&f);
-    cSetInt(end, code->length);
+    cSetInt32(end, code->length);
 }
 
 static void cStruct() {
@@ -1064,9 +1067,9 @@ static void cCallMain() {
     fInit(&f, "main", line);
     Function* found = fsSearch(&functions, &f);
     if(found != NULL && dtIsVoid(found->returnType)) {
-        cAddIntOperation(OP_PUSH_INT, 0);
-        cAddIntOperation(OP_GOSUB, found->address);
-        cAddInt(found->size);
+        cAddInt32Operation(OP_PUSH_INT32, 0);
+        cAddInt32Operation(OP_GOSUB, found->address);
+        cAddInt32(found->size);
     }
 }
 
@@ -1089,7 +1092,7 @@ static void cLinkQueuedFunctions() {
             line = f->line;
             cError("unknown function");
         }
-        cSetInt(f->address, found->address);
+        cSetInt32(f->address, found->address);
     }
 }
 

DataType.c

@@ -24,8 +24,8 @@ const char* dtGetName(Structs* sts, DataType dt) {
     typeNameSwap = !typeNameSwap;
     typeNameIndex = 0;
     switch(dt.type) {
-        case DT_INT: dtAppend("int"); break;
-        case DT_LONG: dtAppend("long"); break;
+        case DT_INT32: dtAppend("int"); break;
+        case DT_INT64: dtAppend("long"); break;
         case DT_FLOAT: dtAppend("float"); break;
         case DT_BOOL: dtAppend("bool"); break;
         case DT_NULL: dtAppend("null"); break;
@@ -44,8 +44,8 @@ int dtGetSize(DataType dt, Structs* sts) {
         return sizeof(Pointer);
     }
     switch(dt.type) {
-        case DT_INT: return sizeof(int);
-        case DT_LONG: return sizeof(long);
+        case DT_INT32: return sizeof(int32);
+        case DT_INT64: return sizeof(int64);
         case DT_FLOAT: return sizeof(float);
         case DT_BOOL: return sizeof(bool);
         case DT_STRUCT:
@@ -61,13 +61,13 @@ int dtGetSize(DataType dt, Structs* sts) {
     }
 }
 
-DataType dtInt() {
-    DataType dt = {DT_INT, 0, 0};
+DataType dtInt32() {
+    DataType dt = {DT_INT32, 0, 0};
     return dt;
 }
 
-DataType dtLong() {
-    DataType dt = {DT_LONG, 0, 0};
+DataType dtInt64() {
+    DataType dt = {DT_INT64, 0, 0};
     return dt;
 }
 
@@ -114,12 +114,12 @@ bool dtCompare(DataType a, DataType b) {
            a.type == b.type;
 }
 
-bool dtIsInt(DataType dt) {
-    return dtCompare(dt, dtInt());
+bool dtIsInt32(DataType dt) {
+    return dtCompare(dt, dtInt32());
 }
 
-bool dtIsLong(DataType dt) {
-    return dtCompare(dt, dtLong());
+bool dtIsInt64(DataType dt) {
+    return dtCompare(dt, dtInt64());
 }
 
 bool dtIsFloat(DataType dt) {

DataType.h

@@ -3,8 +3,10 @@
 
 #include <stdbool.h>
 
-#define DT_INT 0
-#define DT_LONG 1
+#include "Types.h"
+
+#define DT_INT32 0
+#define DT_INT64 1
 #define DT_FLOAT 2
 #define DT_BOOL 3
 #define DT_NULL 4
@@ -36,14 +38,14 @@ typedef struct {
 } Structs;
 
 typedef struct {
-    int array;
-    int offset;
+    int32 array;
+    int32 offset;
 } Pointer;
 
 int dtGetSize(DataType dt, Structs* sts);
 
-DataType dtInt();
-DataType dtLong();
+DataType dtInt32();
+DataType dtInt64();
 DataType dtFloat();
 DataType dtBool();
 DataType dtNull();
@@ -57,8 +59,8 @@ DataType dtToVariable(DataType dt);
 bool dtRemoveVariable(DataType* dt);
 
 bool dtCompare(DataType a, DataType b);
-bool dtIsInt(DataType dt);
-bool dtIsLong(DataType dt);
+bool dtIsInt32(DataType dt);
+bool dtIsInt64(DataType dt);
 bool dtIsFloat(DataType dt);
 bool dtIsBool(DataType dt);
 bool dtIsNull(DataType dt);

Test.c

@@ -33,17 +33,17 @@ static void tsPrintToBuffer(const char* format, ...) {
     va_end(args);
 }
 
-static void tsIntPrinter(Script* sc) {
-    int i;
-    if(sPopInt(sc, &i)) {
+static void tsInt32Printer(Script* sc) {
+    int32 i;
+    if(sPopInt32(sc, &i)) {
         tsPrintToBuffer("%d\n", i);
     }
 }
 
-static void tsLongPrinter(Script* sc) {
-    long l;
-    if(sPopLong(sc, &l)) {
-        tsPrintToBuffer("%ld\n", l);
+static void tsInt64Printer(Script* sc) {
+    int64 i;
+    if(sPopInt64(sc, &i)) {
+        tsPrintToBuffer("%ld\n", i);
     }
 }
 
@@ -174,8 +174,8 @@ static void tsAddPrinter(Structs* sts, DataType in, ScriptFunction sf) {
 void tsStart(const char* path) {
     Structs sts;
     stsInit(&sts);
-    tsAddPrinter(&sts, dtInt(), tsIntPrinter);
-    tsAddPrinter(&sts, dtLong(), tsLongPrinter);
+    tsAddPrinter(&sts, dtInt32(), tsInt32Printer);
+    tsAddPrinter(&sts, dtInt64(), tsInt64Printer);
     tsAddPrinter(&sts, dtFloat(), tsFloatPrinter);
     tsAddPrinter(&sts, dtBool(), tsBoolPrinter);
 

Types.h

@@ -0,0 +1,11 @@
+#ifndef TYPES_H
+#define TYPES_H
+
+#include <stdint.h>
+
+typedef int8_t int8;
+typedef int16_t int16;
+typedef int32_t int32;
+typedef int64_t int64;
+
+#endif

libraries/Time.c

@@ -11,7 +11,7 @@ static void lTimeGetMillis(Script* sc) {
         sError(sc, "cannot get clock time: %s", strerror(errno));
         return;
     }
-    sPushLong(sc, time.tv_nsec / 1000000L + time.tv_sec * 1000L);
+    sPushInt64(sc, time.tv_nsec / 1000000L + time.tv_sec * 1000L);
 }
 
 static void lTimeGetNanos(Script* sc) {
@@ -20,7 +20,7 @@ static void lTimeGetNanos(Script* sc) {
         sError(sc, "cannot get clock time: %s", strerror(errno));
         return;
     }
-    sPushLong(sc, time.tv_nsec + time.tv_sec * 1000000000L);
+    sPushInt64(sc, time.tv_nsec + time.tv_sec * 1000000000L);
 }
 
 void lTimeRegister() {
@@ -28,9 +28,9 @@ void lTimeRegister() {
     stsInit(&sts);
 
     Function f;
-    gfInit(&f, "getMillis", dtLong(), lTimeGetMillis);
+    gfInit(&f, "getMillis", dtInt64(), lTimeGetMillis);
     gfsAdd(&f);
 
-    gfInit(&f, "getNanos", dtLong(), lTimeGetNanos);
+    gfInit(&f, "getNanos", dtInt64(), lTimeGetNanos);
     gfsAdd(&f);
 }

tokenizer/Token.c

@@ -6,12 +6,12 @@
 const char* tGetName(Token token) {
     switch(token) {
         case T_VOID: return "void";
-        case T_INT: return "int";
-        case T_LONG: return "long";
+        case T_INT32: return "int";
+        case T_INT64: return "long";
         case T_BOOL: return "bool";
         case T_FLOAT: return "float";
-        case T_CONST_INT: return "const int";
-        case T_CONST_LONG: return "const long";
+        case T_CONST_INT32: return "const int";
+        case T_CONST_INT64: return "const long";
         case T_CONST_FLOAT: return "const float";
         case T_TEXT: return "text";
         case T_NULLPTR: return "nullptr";
@@ -93,8 +93,8 @@ Token tFromName(const char* name) {
     MATCH_TOKEN("for", T_FOR);
     MATCH_TOKEN("break", T_BREAK);
     MATCH_TOKEN("continue", T_CONTINUE);
-    MATCH_TOKEN("int", T_INT);
-    MATCH_TOKEN("long", T_LONG);
+    MATCH_TOKEN("int", T_INT32);
+    MATCH_TOKEN("long", T_INT64);
     MATCH_TOKEN("void", T_VOID);
     MATCH_TOKEN("bool", T_BOOL);
     MATCH_TOKEN("float", T_FLOAT);

tokenizer/Token.h

@@ -3,12 +3,12 @@
 
 typedef enum {
     T_VOID,
-    T_INT,
-    T_LONG,
+    T_INT32,
+    T_INT64,
     T_BOOL,
     T_FLOAT,
-    T_CONST_INT,
-    T_CONST_LONG,
+    T_CONST_INT32,
+    T_CONST_INT64,
     T_CONST_FLOAT,
     T_TEXT,
     T_NULLPTR,

tokenizer/Tokenizer.c

@@ -70,6 +70,22 @@ static void tParseLiteral(int c) {
     }
 }
 
+static bool tParseInt(char* s, int length, long long* l) {
+    *l = 0;
+    for(int i = 0; i < length; i++) {
+        if(*l > (LLONG_MAX / 10)) {
+            return true;
+        }
+        *l *= 10;
+        int digit = s[i] - '0';
+        if(*l > LLONG_MAX - digit) {
+            return true;
+        }
+        *l += digit;
+    }
+    return false;
+}
+
 static void tParseNumber(int c) {
     int index = 1;
     char buffer[64];
@@ -92,13 +108,13 @@ static void tParseNumber(int c) {
         if(point) {
             tError("invalid mix of long and float", line);
         }
-        char* end = NULL;
-        long l = strtol(buffer, &end, 10);
-        if(end[0] != '\0' || l > LONG_MAX) {
+        long long l;
+        if(tParseInt(buffer, index, &l) || l > INT64_MAX) {
             tError("invalid long on line %d", line);
         }
-        tAddToken(T_CONST_LONG);
-        tAdd(&l, sizeof(long));
+        int64 i = l;
+        tAddToken(T_CONST_INT64);
+        tAdd(&i, sizeof(int64));
     } else if(point) {
         char* end = NULL;
         float f = strtof(buffer, &end);
@@ -108,14 +124,13 @@ static void tParseNumber(int c) {
         tAddToken(T_CONST_FLOAT);
         tAdd(&f, sizeof(float));
     } else {
-        char* end = NULL;
-        long l = strtol(buffer, &end, 10);
-        if(end[0] != '\0' || l > INT_MAX) {
+        long long l;
+        if(tParseInt(buffer, index, &l) || l > INT32_MAX) {
             tError("invalid int on line %d", line);
         }
-        int i = l;
-        tAddToken(T_CONST_INT);
-        tAdd(&i, sizeof(int));
+        int32 i = l;
+        tAddToken(T_CONST_INT32);
+        tAdd(&i, sizeof(int32));
     }
 }
 
@@ -141,7 +156,7 @@ static void tAddString() {
 }
 
 static void tAddUnicode() {
-    int c = fRead();
+    int32 c = fRead();
     if((c & 0xE0) == 0xC0) {
         c = ((c & 0x1F) << 6) | (fRead() & 0x3F);
     } else if((c & 0xF0) == 0xE0) {
@@ -152,8 +167,8 @@ static void tAddUnicode() {
         c |= (fRead() & 0x3F) << 6;
         c |= fRead() & 0x3F;
     }
-    tAddToken(T_CONST_INT);
-    tAdd(&c, sizeof(int));
+    tAddToken(T_CONST_INT32);
+    tAdd(&c, sizeof(int32));
     if(fRead() != '\'') {
         tError("expecting unicode end");
     }
@@ -314,32 +329,20 @@ Token tReadToken() {
     return tokenBuffer[readIndex++];
 }
 
-bool tReadInt(int* i) {
-    if(tReadTokens(i, sizeof(int))) {
-        return true;
-    }
-    return false;
+bool tReadInt16(int16* i) {
+    return tReadTokens(i, sizeof(int16));
 }
 
-bool tReadLong(long* l) {
-    if(tReadTokens(l, sizeof(long))) {
-        return true;
-    }
-    return false;
+bool tReadInt32(int32* i) {
+    return tReadTokens(i, sizeof(int32));
 }
 
-bool tReadInt16(int16* i) {
-    if(tReadTokens(i, sizeof(int16))) {
-        return true;
-    }
-    return false;
+bool tReadInt64(int64* i) {
+    return tReadTokens(i, sizeof(int64));
 }
 
 bool tReadFloat(float* f) {
-    if(tReadTokens(f, sizeof(float))) {
-        return true;
-    }
-    return false;
+    return tReadTokens(f, sizeof(float));
 }
 
 const char* tReadString() {

tokenizer/Tokenizer.h

@@ -2,12 +2,10 @@
 #define TOKENIZER_H
 
 #include <stdbool.h>
-#include <stdint.h>
 
+#include "Types.h"
 #include "tokenizer/Token.h"
 
-typedef int16_t int16;
-
 bool tTokenize(const char* path);
 const char* tGetError();
 int tGetLine();
@@ -15,9 +13,9 @@ int tGetLine();
 void tResetReader();
 Token tPeekToken();
 Token tReadToken();
-bool tReadInt(int* i);
-bool tReadLong(long* l);
 bool tReadInt16(int16* i);
+bool tReadInt32(int32* i);
+bool tReadInt64(int64* i);
 bool tReadFloat(float* f);
 const char* tReadString();
 int tGetMarker();

utils/ByteCodePrinter.c

@@ -2,6 +2,7 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "Types.h"
 #include "utils/ByteCodePrinter.h"
 
 #define LINE_LENGTH 80
@@ -45,22 +46,22 @@ static void btAddOperation(const char* s) {
     btAdd(" %20s |", s);
 }
 
-static void btAddInt() {
-    int value = 0;
-    btRead(&value, sizeof(int));
+static void btAddInt32() {
+    int32 value = 0;
+    btRead(&value, sizeof(int32));
     btAdd(" %10d |", value);
 }
 
-static void btAddLong() {
-    long value = 0;
-    btRead(&value, sizeof(long));
-    btAdd(" %10d |", value);
+static void btAddInt64() {
+    int64 value = 0;
+    btRead(&value, sizeof(int64));
+    btAdd(" %10ld |", value);
 }
 
-static void btAddByte() {
-    char value = 0;
-    btRead(&value, sizeof(char));
-    btAdd(" %10d |", (int)value);
+static void btAddInt8() {
+    int8 value = 0;
+    btRead(&value, sizeof(int8));
+    btAdd(" %10d |", (int32)value);
 }
 
 static void btAddFloat() {
@@ -87,35 +88,35 @@ static void btPrintOp(const char* op) {
     puts(buffer);
 }
 
-static void btPrintInt(const char* op) {
+static void btPrintInt32(const char* op) {
     btFillBase();
     btAddOperation(op);
-    btAddInt();
+    btAddInt32();
     btAddFiller();
     puts(buffer);
 }
 
-static void btPrintLong(const char* op) {
+static void btPrintInt64(const char* op) {
     btFillBase();
     btAddOperation(op);
-    btAddLong();
+    btAddInt64();
     btAddFiller();
     puts(buffer);
 }
 
-static void btPrintByte(const char* op) {
+static void btPrintInt8(const char* op) {
     btFillBase();
     btAddOperation(op);
-    btAddByte();
+    btAddInt8();
     btAddFiller();
     puts(buffer);
 }
 
-static void btPrintInt2(const char* op) {
+static void btPrint2Int32(const char* op) {
     btFillBase();
     btAddOperation(op);
-    btAddInt();
-    btAddInt();
+    btAddInt32();
+    btAddInt32();
     puts(buffer);
 }
 
@@ -132,28 +133,29 @@ static void btPrintFloat(const char* op) {
         btPrint##name(#op);                                                    \
         break;
 #define PRINT_OP(op) PRINT_OP_BASE(op, Op)
-#define PRINT_OP_BYTE(op) PRINT_OP_BASE(op, Byte)
-#define PRINT_OP_INT(op) PRINT_OP_BASE(op, Int)
-#define PRINT_OP_INT2(op) PRINT_OP_BASE(op, Int2)
-#define PRINT_OP_LONG(op) PRINT_OP_BASE(op, Long)
-#define PRINT_INTEGRAL_OP(op) PRINT_OP(OP_##op##_INT) PRINT_OP(OP_##op##_LONG)
+#define PRINT_OP_INT8(op) PRINT_OP_BASE(op, Int8)
+#define PRINT_OP_INT32(op) PRINT_OP_BASE(op, Int32)
+#define PRINT_OP_2INT32(op) PRINT_OP_BASE(op, 2Int32)
+#define PRINT_OP_INT64(op) PRINT_OP_BASE(op, Int64)
+#define PRINT_INTEGRAL_OP(op)                                                  \
+    PRINT_OP(OP_##op##_INT32) PRINT_OP(OP_##op##_INT64)
 #define PRINT_NUMBER_OP(op) PRINT_INTEGRAL_OP(op) PRINT_OP(OP_##op##_FLOAT)
 #define PRINT_TYPES(TYPE)                                                      \
     PRINT_OP(OP_STORE_##TYPE);                                                 \
     PRINT_OP(OP_LOAD_##TYPE);                                                  \
-    PRINT_OP_INT(OP_RETURN_##TYPE);                                            \
+    PRINT_OP_INT32(OP_RETURN_##TYPE);                                          \
     PRINT_OP(OP_EQUAL_##TYPE);
 
 static void btConsumeOperation() {
     Operation op = code->code[readIndex++];
     switch(op) {
-        PRINT_TYPES(INT);
-        PRINT_TYPES(LONG);
+        PRINT_TYPES(INT32);
+        PRINT_TYPES(INT64);
         PRINT_TYPES(BOOL);
         PRINT_TYPES(FLOAT);
         PRINT_OP(OP_NOTHING);
-        PRINT_OP_LONG(OP_PUSH_LONG);
-        PRINT_OP_INT(OP_PUSH_INT);
+        PRINT_OP_INT32(OP_PUSH_INT32);
+        PRINT_OP_INT64(OP_PUSH_INT64);
         PRINT_OP_BASE(OP_PUSH_FLOAT, Float);
         PRINT_OP(OP_PUSH_TRUE);
         PRINT_OP(OP_PUSH_FALSE);
@@ -162,8 +164,8 @@ static void btConsumeOperation() {
         PRINT_NUMBER_OP(SUB);
         PRINT_NUMBER_OP(MUL);
         PRINT_NUMBER_OP(DIV);
-        PRINT_OP(OP_MOD_INT);
-        PRINT_OP(OP_MOD_LONG);
+        PRINT_OP(OP_MOD_INT32);
+        PRINT_OP(OP_MOD_INT64);
         PRINT_NUMBER_OP(INVERT_SIGN);
         PRINT_NUMBER_OP(LESS);
         PRINT_NUMBER_OP(GREATER);
@@ -176,37 +178,37 @@ static void btConsumeOperation() {
         PRINT_INTEGRAL_OP(BIT_XOR);
         PRINT_INTEGRAL_OP(LEFT_SHIFT);
         PRINT_INTEGRAL_OP(RIGHT_SHIFT);
-        PRINT_OP_INT(OP_GOTO);
-        PRINT_OP_INT(OP_IF_GOTO);
-        PRINT_OP_INT(OP_PEEK_FALSE_GOTO);
-        PRINT_OP_INT(OP_PEEK_TRUE_GOTO);
-        PRINT_OP_INT2(OP_GOSUB);
-        PRINT_OP_INT(OP_RETURN);
-        PRINT_OP_INT(OP_RETURN_POINTER);
-        PRINT_OP_INT2(OP_RESERVE);
-        PRINT_OP_INT(OP_DEREFERENCE_VAR);
+        PRINT_OP_INT32(OP_GOTO);
+        PRINT_OP_INT32(OP_IF_GOTO);
+        PRINT_OP_INT32(OP_PEEK_FALSE_GOTO);
+        PRINT_OP_INT32(OP_PEEK_TRUE_GOTO);
+        PRINT_OP_2INT32(OP_GOSUB);
+        PRINT_OP_INT32(OP_RETURN);
+        PRINT_OP_INT32(OP_RETURN_POINTER);
+        PRINT_OP_2INT32(OP_RESERVE);
+        PRINT_OP_INT32(OP_DEREFERENCE_VAR);
         PRINT_OP(OP_REFERENCE);
         PRINT_OP(OP_DUPLICATE_REFERENCE);
-        PRINT_OP_INT(OP_ADD_REFERENCE);
-        PRINT_OP_INT(OP_NEW);
+        PRINT_OP_INT32(OP_ADD_REFERENCE);
+        PRINT_OP_INT32(OP_NEW);
         PRINT_OP(OP_DELETE);
         PRINT_OP(OP_LENGTH);
-        PRINT_OP_INT(OP_LOAD);
+        PRINT_OP_INT32(OP_LOAD);
         PRINT_OP(OP_STORE_POINTER);
         PRINT_OP(OP_EQUAL_POINTER);
-        PRINT_OP_BYTE(OP_PUSH_PRE_CHANGE_INT);
-        PRINT_OP_BYTE(OP_PUSH_POST_CHANGE_INT);
-        PRINT_OP_BYTE(OP_CHANGE_INT);
-        PRINT_OP_BYTE(OP_PUSH_PRE_CHANGE_LONG);
-        PRINT_OP_BYTE(OP_PUSH_POST_CHANGE_LONG);
-        PRINT_OP_BYTE(OP_CHANGE_LONG);
-        PRINT_OP(OP_INT_TO_FLOAT);
-        PRINT_OP(OP_FLOAT_TO_INT);
-        PRINT_OP(OP_INT_TO_LONG);
-        PRINT_OP(OP_LONG_TO_INT);
-        PRINT_OP(OP_FLOAT_TO_LONG);
-        PRINT_OP(OP_LONG_TO_FLOAT);
-        PRINT_OP_INT(OP_CALL);
+        PRINT_OP_INT8(OP_PUSH_PRE_CHANGE_INT32);
+        PRINT_OP_INT8(OP_PUSH_POST_CHANGE_INT32);
+        PRINT_OP_INT8(OP_CHANGE_INT32);
+        PRINT_OP_INT8(OP_PUSH_PRE_CHANGE_INT64);
+        PRINT_OP_INT8(OP_PUSH_POST_CHANGE_INT64);
+        PRINT_OP_INT8(OP_CHANGE_INT64);
+        PRINT_OP(OP_INT32_TO_FLOAT);
+        PRINT_OP(OP_FLOAT_TO_INT32);
+        PRINT_OP(OP_INT32_TO_INT64);
+        PRINT_OP(OP_INT64_TO_INT32);
+        PRINT_OP(OP_FLOAT_TO_INT64);
+        PRINT_OP(OP_INT64_TO_FLOAT);
+        PRINT_OP_INT32(OP_CALL);
         case OP_LINE: sPrintLine(); break;
     }
 }

vm/ByteCode.h

@@ -1,7 +1,7 @@
 #ifndef BYTECODE_H
 #define BYTECODE_H
 
-#include "Operation.h"
+#include "vm/Operation.h"
 
 typedef struct {
     int capacity;

vm/Operation.h

@@ -1,7 +1,7 @@
 #ifndef OPERATION_H
 #define OPERATION_H
 
-#define OP_INTEGRAL(TYPE) OP_##TYPE##_INT, OP_##TYPE##_LONG
+#define OP_INTEGRAL(TYPE) OP_##TYPE##_INT32, OP_##TYPE##_INT64
 #define OP_NUMBER(TYPE) OP_INTEGRAL(TYPE), OP_##TYPE##_FLOAT
 #define OP_TYPE(TYPE) OP_NUMBER(TYPE), OP_##TYPE##_BOOL
 #define OP_CHANGE_NUMBER(TYPE)                                                 \
@@ -18,8 +18,8 @@ typedef enum Operation {
     OP_NUMBER(SUB),
     OP_NUMBER(MUL),
     OP_NUMBER(DIV),
-    OP_MOD_INT,
-    OP_MOD_LONG,
+    OP_MOD_INT32,
+    OP_MOD_INT64,
     OP_NUMBER(INVERT_SIGN),
     OP_NUMBER(LESS),
     OP_NUMBER(GREATER),
@@ -59,12 +59,12 @@ typedef enum Operation {
     OP_INTEGRAL(PUSH_PRE_CHANGE),
     OP_INTEGRAL(PUSH_POST_CHANGE),
     OP_INTEGRAL(CHANGE),
-    OP_FLOAT_TO_INT,
-    OP_INT_TO_FLOAT,
-    OP_INT_TO_LONG,
-    OP_LONG_TO_INT,
-    OP_FLOAT_TO_LONG,
-    OP_LONG_TO_FLOAT,
+    OP_FLOAT_TO_INT32,
+    OP_INT32_TO_FLOAT,
+    OP_INT32_TO_INT64,
+    OP_INT64_TO_INT32,
+    OP_FLOAT_TO_INT64,
+    OP_INT64_TO_FLOAT,
     OP_CALL
 } Operation;
 

vm/Script.c

@@ -125,8 +125,8 @@ static bool sPeek(Script* sc, void* data, int length) {
 #define MODULE(type, Type)                                                     \
     CHECKED_NUMBER_OP(type, Type, %, ZERO_CHECK("module"));
 
-READ_POP_PUSH(int, Int)
-READ_POP_PUSH(long, Long)
+READ_POP_PUSH(int32, Int32)
+READ_POP_PUSH(int64, Int64)
 READ_POP_PUSH(float, Float)
 POP_PUSH(bool, Bool)
 
@@ -143,14 +143,6 @@ static void sPushNullPointer(Script* sc) {
     sPushPointer(sc, &p);
 }
 
-#define PRINT(type, Type, printer)                                             \
-    {                                                                          \
-        type value;                                                            \
-        if(sPop##Type(sc, &value)) {                                           \
-            printer(value);                                                    \
-        }                                                                      \
-    }
-
 #define INVERT_SIGN(type, Type)                                                \
     {                                                                          \
         type value = 0;                                                        \
@@ -160,13 +152,13 @@ static void sPushNullPointer(Script* sc) {
     }
 
 static void sReserveBytes(Script* sc) {
-    int bytes = 0;
-    int offset = 0;
-    if(sReadInt(sc, &bytes) && sReadInt(sc, &offset)) {
-        int oldIndex = sc->stackVarIndex;
+    int32 bytes = 0;
+    int32 offset = 0;
+    if(sReadInt32(sc, &bytes) && sReadInt32(sc, &offset)) {
+        int32 oldIndex = sc->stackVarIndex;
         sc->stackVarIndex = sc->stackIndex - offset;
         sReserve(sc, bytes - offset);
-        sPushInt(sc, oldIndex);
+        sPushInt32(sc, oldIndex);
     }
 }
 
@@ -196,17 +188,17 @@ static void sNot(Script* sc) {
     }
 }
 
-static void sBitNotInt(Script* sc) {
-    int value = 0;
-    if(sPopInt(sc, &value)) {
-        sPushInt(sc, ~value);
+static void sBitNotInt32(Script* sc) {
+    int32 value = 0;
+    if(sPopInt32(sc, &value)) {
+        sPushInt32(sc, ~value);
     }
 }
 
-static void sBitNotLong(Script* sc) {
-    long value = 0;
-    if(sPopLong(sc, &value)) {
-        sPushLong(sc, ~value);
+static void sBitNotInt64(Script* sc) {
+    int64 value = 0;
+    if(sPopInt64(sc, &value)) {
+        sPushInt64(sc, ~value);
     }
 }
 
@@ -215,33 +207,33 @@ static void sLine(Script* sc) {
 }
 
 static void sGoTo(Script* sc) {
-    int gotoIndex;
-    if(sReadInt(sc, &gotoIndex)) {
+    int32 gotoIndex;
+    if(sReadInt32(sc, &gotoIndex)) {
         sc->readIndex = gotoIndex;
     }
 }
 
 static void sGoSub(Script* sc) {
-    int gotoIndex;
-    int offset;
-    if(sReadInt(sc, &gotoIndex) && sReadInt(sc, &offset)) {
+    int32 gotoIndex;
+    int32 offset;
+    if(sReadInt32(sc, &gotoIndex) && sReadInt32(sc, &offset)) {
         Pointer p = {.array = -1,
-                     .offset = sc->stackIndex - offset - sizeof(int)};
-        void* dest = sCheckAddress(sc, &p, sizeof(int));
+                     .offset = sc->stackIndex - offset - sizeof(int32)};
+        void* dest = sCheckAddress(sc, &p, sizeof(int32));
         if(dest != NULL) {
-            memcpy(dest, &sc->readIndex, sizeof(int));
+            memcpy(dest, &sc->readIndex, sizeof(int32));
             sc->readIndex = gotoIndex;
         }
     }
 }
 
 static void sReturn(Script* sc) {
-    int bytes = 0;
-    int varIndex = 0;
-    if(sReadInt(sc, &bytes) && sPopInt(sc, &varIndex)) {
+    int32 bytes = 0;
+    int32 varIndex = 0;
+    if(sReadInt32(sc, &bytes) && sPopInt32(sc, &varIndex)) {
         sc->stackVarIndex = varIndex;
         sFree(sc, bytes);
-        if(!sPopInt(sc, &sc->readIndex) || sc->readIndex < 0) {
+        if(!sPopInt32(sc, &sc->readIndex) || sc->readIndex < 0) {
             sError(sc, "read index is corrupt");
         }
     }
@@ -265,33 +257,34 @@ static void sReturnPointer(Script* sc) {
     }
 
 static void sIfGoTo(Script* sc) {
-    int gotoIndex = 0;
+    int32 gotoIndex = 0;
     bool value = false;
-    if(sReadInt(sc, &gotoIndex) && sPopBool(sc, &value) && !value) {
+    if(sReadInt32(sc, &gotoIndex) && sPopBool(sc, &value) && !value) {
         sc->readIndex = gotoIndex;
     }
 }
 
 static void sPeekFalseGoTo(Script* sc) {
-    int gotoIndex = 0;
+    int32 gotoIndex = 0;
     bool value = false;
-    if(sReadInt(sc, &gotoIndex) && sPeek(sc, &value, sizeof(bool)) && !value) {
+    if(sReadInt32(sc, &gotoIndex) && sPeek(sc, &value, sizeof(bool)) &&
+       !value) {
         sc->readIndex = gotoIndex;
     }
 }
 
 static void sPeekTrueGoTo(Script* sc) {
-    int gotoIndex = 0;
+    int32 gotoIndex = 0;
     bool value = false;
-    if(sReadInt(sc, &gotoIndex) && sPeek(sc, &value, sizeof(bool)) && value) {
+    if(sReadInt32(sc, &gotoIndex) && sPeek(sc, &value, sizeof(bool)) && value) {
         sc->readIndex = gotoIndex;
     }
 }
 
 static void sNewArray(Script* sc) {
-    int length = 0;
-    int size = 0;
-    if(sReadInt(sc, &size) && sPopInt(sc, &length)) {
+    int32 length = 0;
+    int32 size = 0;
+    if(sReadInt32(sc, &size) && sPopInt32(sc, &length)) {
         Pointer p = {.array = asAllocate(&sc->arrays, size, length),
                      .offset = 0};
         if(p.array == -1) {
@@ -324,7 +317,7 @@ static void sLength(Script* sc) {
     Pointer p;
     if(sPopPointer(sc, &p)) {
         if(p.array == -1) {
-            sPushInt(sc, p.offset >= 0);
+            sPushInt32(sc, p.offset >= 0);
             return;
         }
         Array* a = asGet(&sc->arrays, p.array);
@@ -332,13 +325,13 @@ static void sLength(Script* sc) {
             sError(sc, "invalid heap pointer");
             return;
         }
-        sPushInt(sc, a->length);
+        sPushInt32(sc, a->length);
     }
 }
 
 static void sDereference(Script* sc) {
-    int address = 0;
-    if(sReadInt(sc, &address)) {
+    int32 address = 0;
+    if(sReadInt32(sc, &address)) {
         Pointer p = {.array = -1, .offset = address + sc->stackVarIndex};
         sPushPointer(sc, &p);
     }
@@ -362,19 +355,19 @@ static void sDuplicateReference(Script* sc) {
 }
 
 static void sAddReference(Script* sc) {
-    int size = 0;
-    int add = 0;
+    int32 size = 0;
+    int32 add = 0;
     Pointer p;
-    if(sReadInt(sc, &size) && sPopInt(sc, &add) && sPopPointer(sc, &p)) {
+    if(sReadInt32(sc, &size) && sPopInt32(sc, &add) && sPopPointer(sc, &p)) {
         p.offset += add * size;
         sPushPointer(sc, &p);
     }
 }
 
 static void sLoadSize(Script* sc) {
-    int size = 0;
+    int32 size = 0;
     Pointer p;
-    if(sReadInt(sc, &size) && sPopPointer(sc, &p)) {
+    if(sReadInt32(sc, &size) && sPopPointer(sc, &p)) {
         void* src = sCheckAddress(sc, &p, size);
         if(src != NULL) {
             sPush(sc, src, size);
@@ -406,8 +399,8 @@ static void sEqualPointer(Script* sc) {
 }
 
 static void sCall(Script* sc) {
-    int function = 0;
-    if(sReadInt(sc, &function) && gfsCall(sc, function)) {
+    int32 function = 0;
+    if(sReadInt32(sc, &function) && gfsCall(sc, function)) {
         sError(sc, "invalid function call");
     }
 }
@@ -447,14 +440,14 @@ static void sCall(Script* sc) {
         CHANGE(type);                                                          \
         break;
 #define CASE_NUMBER_OP(name, op)                                               \
-    case OP_##name##_INT: NUMBER_OP(int, Int, op); break;                      \
-    case OP_##name##_LONG: NUMBER_OP(long, Long, op); break;                   \
+    case OP_##name##_INT32: NUMBER_OP(int32, Int32, op); break;                \
+    case OP_##name##_INT64: NUMBER_OP(int64, Int64, op); break;                \
     case OP_##name##_FLOAT:                                                    \
         NUMBER_OP(float, Float, op);                                           \
         break;
 #define CASE_BOOL_OP(name, op)                                                 \
-    case OP_##name##_INT: BOOL_OP(int, Int, op); break;                        \
-    case OP_##name##_LONG: BOOL_OP(long, Long, op); break;                     \
+    case OP_##name##_INT32: BOOL_OP(int32, Int32, op); break;                  \
+    case OP_##name##_INT64: BOOL_OP(int64, Int64, op); break;                  \
     case OP_##name##_FLOAT:                                                    \
         BOOL_OP(float, Float, op);                                             \
         break;
@@ -471,42 +464,42 @@ static void sConsumeInstruction(Script* sc) {
         CASE_NUMBER_OP(MUL, *);
         CASE_BOOL_OP(LESS, <);
         CASE_BOOL_OP(GREATER, >);
-        CASE_TYPE(INT, Int, int);
-        CASE_TYPE(LONG, Long, long);
+        CASE_TYPE(INT32, Int32, int32);
+        CASE_TYPE(INT64, Int64, int64);
         CASE_TYPE(BOOL, Bool, bool);
         CASE_TYPE(FLOAT, Float, float);
-        CASE_CHANGE(INT, Int, int);
-        CASE_CHANGE(LONG, Long, long);
+        CASE_CHANGE(INT32, Int32, int32);
+        CASE_CHANGE(INT64, Int64, int64);
         case OP_NOTHING: break;
-        case OP_PUSH_INT: PUSH_CONSTANT(int, Int); break;
-        case OP_PUSH_LONG: PUSH_CONSTANT(long, Long); break;
+        case OP_PUSH_INT32: PUSH_CONSTANT(int32, Int32); break;
+        case OP_PUSH_INT64: PUSH_CONSTANT(int64, Int64); break;
         case OP_PUSH_FLOAT: PUSH_CONSTANT(float, Float); break;
         case OP_PUSH_TRUE: sPushBool(sc, true); break;
         case OP_PUSH_FALSE: sPushBool(sc, false); break;
         case OP_PUSH_NULLPTR: sPushNullPointer(sc); break;
-        case OP_DIV_INT: DIVISION(int, Int); break;
-        case OP_DIV_LONG: DIVISION(long, Long); break;
+        case OP_DIV_INT32: DIVISION(int32, Int32); break;
+        case OP_DIV_INT64: DIVISION(int64, Int64); break;
         case OP_DIV_FLOAT: DIVISION(float, Float); break;
-        case OP_MOD_INT: MODULE(int, Int); break;
-        case OP_MOD_LONG: MODULE(long, Long); break;
-        case OP_INVERT_SIGN_INT: INVERT_SIGN(int, Int); break;
-        case OP_INVERT_SIGN_LONG: INVERT_SIGN(long, Long); break;
+        case OP_MOD_INT32: MODULE(int32, Int32); break;
+        case OP_MOD_INT64: MODULE(int64, Int64); break;
+        case OP_INVERT_SIGN_INT32: INVERT_SIGN(int32, Int32); break;
+        case OP_INVERT_SIGN_INT64: INVERT_SIGN(int64, Int64); break;
         case OP_INVERT_SIGN_FLOAT: INVERT_SIGN(float, Float); break;
         case OP_NOT: sNot(sc); break;
         case OP_AND: BOOL_OP(bool, Bool, &&); break;
         case OP_OR: BOOL_OP(bool, Bool, ||); break;
-        case OP_BIT_NOT_INT: sBitNotInt(sc); break;
-        case OP_BIT_AND_INT: NUMBER_OP(int, Int, &); break;
-        case OP_BIT_OR_INT: NUMBER_OP(int, Int, |); break;
-        case OP_BIT_XOR_INT: NUMBER_OP(int, Int, ^); break;
-        case OP_LEFT_SHIFT_INT: NUMBER_OP(int, Int, <<); break;
-        case OP_RIGHT_SHIFT_INT: NUMBER_OP(int, Int, >>); break;
-        case OP_BIT_NOT_LONG: sBitNotLong(sc); break;
-        case OP_BIT_AND_LONG: NUMBER_OP(long, Long, &); break;
-        case OP_BIT_OR_LONG: NUMBER_OP(long, Long, |); break;
-        case OP_BIT_XOR_LONG: NUMBER_OP(long, Long, ^); break;
-        case OP_LEFT_SHIFT_LONG: NUMBER_OP(long, Long, <<); break;
-        case OP_RIGHT_SHIFT_LONG: NUMBER_OP(long, Long, >>); break;
+        case OP_BIT_NOT_INT32: sBitNotInt32(sc); break;
+        case OP_BIT_AND_INT32: NUMBER_OP(int32, Int32, &); break;
+        case OP_BIT_OR_INT32: NUMBER_OP(int32, Int32, |); break;
+        case OP_BIT_XOR_INT32: NUMBER_OP(int32, Int32, ^); break;
+        case OP_LEFT_SHIFT_INT32: NUMBER_OP(int32, Int32, <<); break;
+        case OP_RIGHT_SHIFT_INT32: NUMBER_OP(int32, Int32, >>); break;
+        case OP_BIT_NOT_INT64: sBitNotInt64(sc); break;
+        case OP_BIT_AND_INT64: NUMBER_OP(int64, Int64, &); break;
+        case OP_BIT_OR_INT64: NUMBER_OP(int64, Int64, |); break;
+        case OP_BIT_XOR_INT64: NUMBER_OP(int64, Int64, ^); break;
+        case OP_LEFT_SHIFT_INT64: NUMBER_OP(int64, Int64, <<); break;
+        case OP_RIGHT_SHIFT_INT64: NUMBER_OP(int64, Int64, >>); break;
         case OP_LINE: sLine(sc); break;
         case OP_GOTO: sGoTo(sc); break;
         case OP_IF_GOTO: sIfGoTo(sc); break;
@@ -526,12 +519,12 @@ static void sConsumeInstruction(Script* sc) {
         case OP_LENGTH: sLength(sc); break;
         case OP_STORE_POINTER: sStore(sc, sizeof(Pointer)); break;
         case OP_EQUAL_POINTER: sEqualPointer(sc); break;
-        case OP_INT_TO_FLOAT: CAST(Int, int, Float); break;
-        case OP_FLOAT_TO_INT: CAST(Float, float, Int); break;
-        case OP_INT_TO_LONG: CAST(Int, int, Long); break;
-        case OP_LONG_TO_INT: CAST(Long, long, Int); break;
-        case OP_FLOAT_TO_LONG: CAST(Float, float, Long); break;
-        case OP_LONG_TO_FLOAT: CAST(Long, long, Float); break;
+        case OP_INT32_TO_FLOAT: CAST(Int32, int32, Float); break;
+        case OP_FLOAT_TO_INT32: CAST(Float, float, Int32); break;
+        case OP_INT32_TO_INT64: CAST(Int32, int32, Int64); break;
+        case OP_INT64_TO_INT32: CAST(Int64, int64, Int32); break;
+        case OP_FLOAT_TO_INT64: CAST(Float, float, Int64); break;
+        case OP_INT64_TO_FLOAT: CAST(Int64, int64, Float); break;
         case OP_CALL: sCall(sc); break;
     }
 }

vm/Script.h

@@ -26,10 +26,10 @@ void sDelete(Script* sc);
 void sRun(Script* sc);
 
 void sError(Script* sc, const char* format, ...);
-bool sPopInt(Script* sc, int* i);
-bool sPushInt(Script* sc, int i);
-bool sPopLong(Script* sc, long* l);
-bool sPushLong(Script* sc, long l);
+bool sPopInt32(Script* sc, int32* i);
+bool sPushInt32(Script* sc, int32 i);
+bool sPopInt64(Script* sc, int64* i);
+bool sPushInt64(Script* sc, int64 i);
 bool sPopFloat(Script* sc, float* f);
 bool sPushFloat(Script* sc, float f);
 bool sPopBool(Script* sc, bool* b);