check array indexes on read as an option

src/eberon/EberonContextDesignator.ob

@@ -126,7 +126,7 @@ BEGIN
             0, 
             Types.basic.ch, 
             EberonString.makeElementVariable(),
-            ContextDesignator.stringIndexCode(SELF),
+            ContextDesignator.getAt(SELF, Types.basic.ch),
             "",
             "");
     ELSIF currentType IS EberonMap.PType THEN

src/ob/ContextDesignator.ob

@@ -135,8 +135,8 @@ BEGIN
     designator.lval := "";
 END;
 
-PROCEDURE stringIndexCode*(d: Type): STRING;
-    RETURN d.root().language().codeTraits.stringIndex(d.derefCode, Expression.deref(d.indexExpression).code());
+PROCEDURE getAt*(d: Type; type: Types.PStorageType): STRING;
+    RETURN d.root().language().codeTraits.getAt(d.derefCode, Expression.deref(d.indexExpression).code(), type);
 END;
 
 PROCEDURE advance*(VAR d: Type; type: Types.PType; info: Types.PId; code, lval: STRING; replace: BOOLEAN);
@@ -242,11 +242,7 @@ BEGIN
     END;
 
     leadCode <- code;
-    wholeCode <- code + "[" + indexCode + "]";
-    IF indexType = Types.basic.ch THEN
-        lval := wholeCode;
-        wholeCode := stringIndexCode(SELF);
-    END;
+    wholeCode <- getAt(SELF, indexType);
 
     readOnly <- (info IS Types.PConst) 
              OR ((info IS Types.PVariable) & info.isReadOnly());

src/ob/LanguageContext.ob

@@ -31,7 +31,7 @@ TYPE
         PROCEDURE CodeTraits*(code: CodeGenerator.PIGenerator; rtl: OberonRtl.PType; checkIndexes: BOOLEAN);
 
         PROCEDURE generator*(): CodeGenerator.PIGenerator;
-        PROCEDURE stringIndex*(e, index: STRING): STRING;
+        PROCEDURE getAt*(e, index: STRING; type: T.PStorageType): STRING;
         PROCEDURE putAt*(where, index, what: STRING): STRING;
         PROCEDURE referenceCode*(VAR info: T.Id): STRING;
         PROCEDURE assign*(VAR info: T.Id; right: Expression.PType): STRING;
@@ -75,14 +75,22 @@ PROCEDURE CodeTraits.generator(): CodeGenerator.PIGenerator;
     RETURN SELF.code;
 END;
 
-PROCEDURE CodeTraits.stringIndex(e, index: STRING): STRING;
+PROCEDURE CodeTraits.getAt(e, index: STRING; type: T.PStorageType): STRING;
 VAR
     r: STRING;
 BEGIN
     IF ~SELF.checkIndexes THEN
-        r := e + ".charCodeAt(" + index + ")";
+        IF type = T.basic.ch THEN
+            r := e + ".charCodeAt(" + index + ")";
+        ELSE
+            r := e + "[" + index + "]";
+        END;
     ELSE
-        r := SELF.rtl.charAt(e, index);
+        IF type = T.basic.ch THEN
+            r := SELF.rtl.charAt(e, index);
+        ELSE
+            r := SELF.rtl.getAt(e, index);
+        END;
     END; 
     RETURN r;
 END;

src/ob/OberonRtl.ob

@@ -15,6 +15,7 @@ TYPE
         PROCEDURE makeCharArray*(dimensions: STRING): STRING;
         PROCEDURE typeGuard*(from, to: STRING): STRING;
         PROCEDURE charAt*(s, index: STRING): STRING;
+        PROCEDURE getAt*(s, index: STRING): STRING;
         PROCEDURE putAt*(where, index, what: STRING): STRING;
     END;
     PType* = POINTER TO Type;

src/rtl.js

@@ -72,6 +72,11 @@ var methods = {
             return s.charCodeAt(index);
         throw new Error("index out of bounds: " + index);
     },
+    getAt: function(where, index){
+        if (index >= 0 && index < where.length)
+            return where[index];
+        throw new Error("index out of bounds: " + index);
+    },
     putAt: function(where, index, what){
         if (index >= 0 && index < where.length)
             where[index] = what;

test/expected/check_indexes.js

@@ -13,6 +13,12 @@ function writeCharArray(a/*VAR ARRAY OF CHAR*/){
 	RTL$.putAt(a, RTL$.charAt(a, 1), c);
 }
 
+function readIntArray(a/*ARRAY OF INTEGER*/){
+	var i = 0;
+	i = RTL$.getAt(a, 1);
+	i = RTL$.getAt(a, RTL$.getAt(a, i));
+}
+
 function writeIntArray(a/*VAR ARRAY OF INTEGER*/){
 	var i = 0;
 	RTL$.putAt(a, 1, i);

test/expected/errorsRT/check_indexes_int_write.txt

@@ -0,0 +1 @@
+Error: index out of bounds: 1

test/input/check_indexes.ob

@@ -17,6 +17,14 @@ BEGIN
 	a[ORD(a[1])] := c;
 END writeCharArray;
 
+PROCEDURE readIntArray(a: ARRAY OF INTEGER);
+VAR
+	i: INTEGER;
+BEGIN
+	i := a[1];
+	i := a[a[i]]
+END readIntArray;
+
 PROCEDURE writeIntArray(VAR a: ARRAY OF INTEGER);
 VAR
 	i: INTEGER;

test/input/errorsRT/check_indexes_int.ob

@@ -3,11 +3,11 @@ MODULE m;
 VAR
 	a: ARRAY 1 OF INTEGER;
 
-PROCEDURE intArray(VAR a: ARRAY OF INTEGER);
+PROCEDURE intArray(a: ARRAY OF INTEGER);
 VAR
 	i: INTEGER;
 BEGIN
-	a[1] := 1;
+	i := a[1];
 END intArray;
 
 BEGIN

test/input/errorsRT/check_indexes_int_write.ob

@@ -0,0 +1,15 @@
+(*options:{"checkIndexes": true}*)
+MODULE m;
+VAR
+	a: ARRAY 1 OF INTEGER;
+
+PROCEDURE intArray(VAR a: ARRAY OF INTEGER);
+VAR
+	i: INTEGER;
+BEGIN
+	a[1] := 1;
+END intArray;
+
+BEGIN
+	intArray(a);
+END m.