offset is signed again

DataType.c

@@ -27,7 +27,7 @@ const char* vtGetName(ValueType vt) {
 }
 
 #define VALUE_TYPE_MASK ((1u << VALUE_TYPE_BIT_SIZE) - 1u)
-#define VALUE_MAX_OFFSET ((1u << (32 - VALUE_TYPE_BIT_SIZE)) - 1u)
+#define VALUE_MAX_OFFSET ((1 << (32 - VALUE_TYPE_BIT_SIZE)) - 1)
 
 ValueType vGetType(Value v) {
     uint32 type = v.typeAndOffset & VALUE_TYPE_MASK;
@@ -45,16 +45,16 @@ bool vSetType(Value* v, ValueType vt) {
     return false;
 }
 
-uint32 vGetOffset(Value v) {
+int32 vGetOffset(Value v) {
-    return v.typeAndOffset >> VALUE_TYPE_BIT_SIZE;
+    return (int32)(v.typeAndOffset >> VALUE_TYPE_BIT_SIZE);
 }
 
-bool vSetOffset(Value* v, uint32 offset) {
+bool vSetOffset(Value* v, int32 offset) {
-    if(v == NULL || offset > VALUE_MAX_OFFSET) {
+    if(v == NULL || offset < 0 || offset > VALUE_MAX_OFFSET) {
         return true;
     }
-    v->typeAndOffset =
+    v->typeAndOffset = (v->typeAndOffset & VALUE_TYPE_MASK) |
-        (v->typeAndOffset & VALUE_TYPE_MASK) | (offset << VALUE_TYPE_BIT_SIZE);
+                       ((uint32)offset << VALUE_TYPE_BIT_SIZE);
     return false;
 }
 

DataType.h

@@ -82,8 +82,8 @@ typedef struct {
 const char* vtGetName(ValueType vt);
 ValueType vGetType(Value v);
 check_return bool vSetType(Value* v, ValueType vt);
-uint32 vGetOffset(Value v);
+int32 vGetOffset(Value v);
-check_return bool vSetOffset(Value* v, uint32 offset);
+check_return bool vSetOffset(Value* v, int32 offset);
 
 int dtGetSize(DataType dt, const Structs* sts);
 

vm/Script.c

@@ -343,8 +343,7 @@ static void sDereference(Script* sc) {
         return;
     }
     Value* v = sPushStack(sc, 1);
-    if(vSetType(v, VT_POINTER) ||
+    if(vSetType(v, VT_POINTER) || vSetOffset(v, address + sc->stackVarIndex)) {
-       vSetOffset(v, (uint32)(address + sc->stackVarIndex))) {
         sCannotSetValueType(sc);
         return;
     }
@@ -357,7 +356,7 @@ static void sGlobalDereference(Script* sc) {
         return;
     }
     Value* v = sPushStack(sc, 1);
-    if(vSetType(v, VT_POINTER) || vSetOffset(v, (uint32)address)) {
+    if(vSetType(v, VT_POINTER) || vSetOffset(v, address)) {
         sCannotSetValueType(sc);
         return;
     }
@@ -382,14 +381,14 @@ static void sAddReference(Script* sc) {
     }
     Value* v = sPeekStack(sc, VT_POINTER);
     if(v != NULL) {
-        if(vSetOffset(v, vGetOffset(*v) + (uint32)(add * size))) {
+        if(vSetOffset(v, vGetOffset(*v) + add * size)) {
             sCannotSetValueType(sc);
         }
     } else {
         sc->error[0] = '\0';
         v = sPeekStack(sc, VT_ARRAY);
         if(vSetType(v, VT_POINTER) ||
-           vSetOffset(v, vGetOffset(*v) + (uint32)(add * size))) {
+           vSetOffset(v, vGetOffset(*v) + add * size)) {
             sCannotSetValueType(sc);
         }
     }
@@ -412,10 +411,10 @@ static void sPushStructReference(Script* sc) {
 }
 
 static Value* sLoadFromPointer(Script* sc, Value* p, ValueType wantedType) {
-    uint32 offset = vGetOffset(*p);
+    int32 offset = vGetOffset(*p);
     if(p->data.intValue < 0) {
-        if(offset >= SCRIPT_STACK_SIZE) {
+        if(offset < 0 || offset >= SCRIPT_STACK_SIZE) {
-            sError(sc, "load offset overflow");
+            sError(sc, "invalid offset");
             return NULL;
         }
         Value* v = sc->stack + offset;
@@ -432,8 +431,8 @@ static Value* sLoadFromPointer(Script* sc, Value* p, ValueType wantedType) {
         sError(sc, "invalid heap pointer %d", p->data.intValue);
         return NULL;
     }
-    if((int32)offset >= a->realLength) {
+    if(offset >= a->realLength) {
-        sError(sc, "invalid heap pointer offset %u %d", offset, a->realLength);
+        sError(sc, "invalid heap pointer offset %d %d", offset, a->realLength);
         return NULL;
     }
     return a->data + offset;