get rid of "special" array lengths

build.py

@@ -222,7 +222,7 @@ class compile_target(object):
         compile_using_snapshot(options.file)
 
 class self_recompile_target(object):
-    name = 'self_recompile'
+    name = 'self-recompile'
     description = 'compile itself using current sources'
 
     @staticmethod

src/context.js

@@ -356,13 +356,15 @@ exports.Designator = ChainedContext.extend({
                 Type.intsDescription() + " expression expected, got '" + expType.description() + "'");
 
         var index = this._indexSequence(this.__currentType, this.__info);
-        var length = index.length;
         var pValue = e.constValue();
         if (pValue){
             var value = pValue.value;
             if (value < 0)
                 throw new Errors.Error("index is negative: " + value);
-            if (length != Type.openArrayLength && value >= length)
+            
+            var length = index.length;
+            if ((this.__currentType instanceof Type.StaticArray || this.__currentType instanceof Type.String)
+             && value >= length)
                 throw new Errors.Error("index out of bounds: maximum possible index is "
                                      + (length - 1)
                                      + ", got " + value );
@@ -379,7 +381,9 @@ exports.Designator = ChainedContext.extend({
         if (!isArray && !(type instanceof Type.String))
             throw new Errors.Error("ARRAY or string expected, got '" + type.description() + "'");
 
-        var length = isArray ? type.length() : Type.stringLen(type);
+        var length = isArray ? type instanceof Type.StaticArray ? type.length() 
+                                                                : undefined
+                             : Type.stringLen(type);
         if (!isArray && !length)
             throw new Errors.Error("cannot index empty string" );
         var indexType = isArray ? Type.arrayElementsType(type) : basicTypes.ch;

src/eberon/EberonTypes.ob

@@ -1,9 +1,6 @@
 MODULE EberonTypes;
 IMPORT Context, Types;
 
-CONST
-    dynamicArrayLength* = Types.openArrayLength - 1;
-
 TYPE
     DynamicArray* = RECORD(Types.Array)
     END;
@@ -25,10 +22,6 @@ PROCEDURE DynamicArray.initializer(cx: Context.Type; forNew: BOOLEAN): STRING;
     RETURN "[]"
 END DynamicArray.initializer;
 
-PROCEDURE DynamicArray.length(): INTEGER;
-    RETURN Types.openArrayLength
-END DynamicArray.length;
-
 PROCEDURE DynamicArray.description(): STRING;
     RETURN Types.arrayDescription(SELF, arrayDimensionDescription)
 END DynamicArray.description;

src/eberon/eberon_context.js

@@ -284,7 +284,7 @@ var InPlaceVariableInit = Context.Chained.extend({
             this._code += this.language().rtl.clone(e.code());
         }
         else if (type instanceof Type.Array){
-            if (type.length() == Type.openArrayLength)
+            if (type instanceof Type.OpenArray)
                 throw new Errors.Error("cannot initialize variable '" + this.__id + "' with open array");
             this._code += this.language().rtl.clone(e.code());
         }
@@ -1097,13 +1097,15 @@ var For = Context.For.extend({
     }
 });
 
+var dynamicArrayLength = -1;
+
 var ArrayDimensions = Context.ArrayDimensions.extend({
     init: function EberonContext$ArrayDimensions(context){
         Context.ArrayDimensions.prototype.init.call(this, context);
     },
     handleLiteral: function(s){
         if ( s == "*" )
-            this._addDimension(EberonTypes.dynamicArrayLength);
+            this._addDimension(dynamicArrayLength);
         else
             Context.ArrayDimensions.prototype.handleLiteral.call(this, s);
     }
@@ -1114,12 +1116,12 @@ var ArrayDecl = Context.ArrayDecl.extend({
         Context.ArrayDecl.prototype.init.call(this, context);
     },
     _makeInit: function(type, dimensions, length){
-        if (length == EberonTypes.dynamicArrayLength)
+        if (length == dynamicArrayLength)
             return '[]';
         return Context.ArrayDecl.prototype._makeInit.call(this, type, dimensions, length);
     },
     _makeType: function(elementsType, init, length){
-        return length == EberonTypes.dynamicArrayLength
+        return length == dynamicArrayLength
             ? EberonTypes.makeDynamicArray(elementsType)
             : Type.makeStaticArray(init, elementsType, length);
     }

src/ob/Cast.ob

@@ -62,12 +62,9 @@ PROCEDURE areTypesMatch*(t1: Types.PType; t2: Types.PType): BOOLEAN;
 END areTypesMatch;
 
 PROCEDURE areArgsMatch(oa1, oa2: Object.PType; p1, p2: Types.PDefinedProcedure): BOOLEAN;
-VAR
-    a1: Types.PProcedureArgument;
-    a2: Types.PProcedureArgument;
 BEGIN
-    a1 := oa1(Types.PProcedureArgument);
-    a2 := oa2(Types.PProcedureArgument);
+    a1 <- oa1(Types.PProcedureArgument);
+    a2 <- oa2(Types.PProcedureArgument);
     RETURN (a1.isVar = a2.isVar)
         & (    ((a1.type = p1) & (a2.type = p2))
             OR areTypesExactlyMatch(a1.type, a2.type))
@@ -76,22 +73,19 @@ END areArgsMatch;
 PROCEDURE areProceduresMatch*(p1, p2: Types.PDefinedProcedure): BOOLEAN;
 VAR
     result: BOOLEAN;
-    args1, args2: JsArray.Type;
-    argsLen: INTEGER;
-    i: INTEGER;
-    r1, r2: Types.PType;
 BEGIN
-    args1 := p1.args();
-    args2 := p2.args();
-    argsLen := JsArray.len(args1);
+    args1 <- p1.args();
+    args2 <- p2.args();
+    argsLen <- JsArray.len(args1);
     IF JsArray.len(args2) = argsLen THEN
+        i <- 0;
         WHILE (i < argsLen) 
             & areArgsMatch(JsArray.at(args1, i), JsArray.at(args2, i), p1, p2) DO
             INC(i);
         END;
         IF i = argsLen THEN
-            r1 := p1.result();
-            r2 := p2.result();
+            r1 <- p1.result();
+            r2 <- p2.result();
             result := ((r1 = p1) & (r2 = p2)) OR areTypesExactlyMatch(r1, r2);
         END;
     END;
@@ -104,7 +98,10 @@ VAR
 BEGIN
     IF t1 = t2 THEN
         result := TRUE;
-    ELSIF (t1 IS Types.PArray) & (t2 IS Types.PArray) THEN
+    ELSIF (t1 IS Types.POpenArray) & (t2 IS Types.POpenArray) THEN
+        result := areTypesMatch(Types.arrayElementsType(t1^), 
+                                Types.arrayElementsType(t2^));
+    ELSIF (t1 IS Types.PStaticArray) & (t2 IS Types.PStaticArray) THEN
         result := (t1.length() = t2.length()) 
                 & (areTypesMatch(Types.arrayElementsType(t1^), 
                                  Types.arrayElementsType(t2^)));
@@ -132,11 +129,10 @@ END makeCastOpStrToChar;
 
 PROCEDURE implicit*(from, to: Types.PType; toVar: BOOLEAN; ops: Operations; VAR op: PCastOp): INTEGER;
 VAR
-    result: INTEGER;
     c: CHAR;
     ignore: BOOLEAN;
 BEGIN
-    result := err;
+    result <- err;
     op := NIL;
     IF from = to THEN
         result := errNo;
@@ -162,13 +158,15 @@ BEGIN
         ELSIF Types.isString(to) THEN
             result := errNo;
         END;
-    ELSIF (from IS Types.PArray) & (to IS Types.PArray) THEN
-        IF ((from.length() = to.length())
-                OR (to.length() = Types.openArrayLength))
-            & areTypesExactlyMatch(Types.arrayElementsType(from^), 
-                                   Types.arrayElementsType(to^)) THEN
+    ELSIF (from IS Types.PArray) & (to IS Types.POpenArray)
+        & areTypesExactlyMatch(Types.arrayElementsType(from^), 
+                               Types.arrayElementsType(to^)) THEN
+            result := errNo;
+    ELSIF (from IS Types.PStaticArray) & (to IS Types.PStaticArray) 
+        & (from.length() = to.length())
+        & areTypesExactlyMatch(Types.arrayElementsType(from^), 
+                               Types.arrayElementsType(to^)) THEN
             result := errNo;
-        END;
     ELSIF (from IS Types.PPointer) & (to IS Types.PPointer) THEN
         IF ~toVar THEN
             IF findPointerBaseType(to, from^) # NIL THEN

src/ob/Operator.ob

@@ -478,13 +478,12 @@ VAR
     ignored: BOOLEAN;
     result: STRING;
 
-    PROCEDURE assignArrayFromString(a: Types.Array; s: Types.String): STRING;
+    PROCEDURE assignArrayFromString(VAR a: Types.Array; s: Types.String): STRING;
     BEGIN
-        len <- a.length();
-        IF len = Types.openArrayLength THEN
+        IF ~(a IS Types.StaticArray) THEN
             Errors.raise("string cannot be assigned to open " + a.description());
-        ELSIF Types.stringLen(s) > len THEN
-            Errors.raise(String.fromInt(len) 
+        ELSIF Types.stringLen(s) > a.length() THEN
+            Errors.raise(String.fromInt(a.length()) 
                          + "-character ARRAY is too small for "
                          + String.fromInt(Types.stringLen(s))
                          + "-character string");

src/ob/Types.ob

@@ -1,8 +1,6 @@
 MODULE Types;
 IMPORT
     Context, Errors, JS, JsArray, JsMap, Object, ScopeBase, Str := String;
-CONST
-    openArrayLength* = 0;
 
 TYPE
     Id* = RECORD(Object.Type)
@@ -88,8 +86,6 @@ TYPE
     END;
 
     Array* = RECORD(NamedType)
-        PROCEDURE length*(): INTEGER;
-
         elementsType: PType
     END;
     PArray* = POINTER TO Array;
@@ -99,9 +95,12 @@ TYPE
     POpenArray* = POINTER TO OpenArray;
 
     StaticArray* = RECORD(Array)
+        PROCEDURE length*(): INTEGER;
+
         mInitializer: STRING;
         len: INTEGER
     END;
+    PStaticArray* = POINTER TO StaticArray;
 
     PRecord* = POINTER TO Record;
 
@@ -487,7 +486,7 @@ PROCEDURE arrayDimensionDescription*(VAR a: Array): STRING;
 VAR
     result: STRING;
 BEGIN
-    IF ~(a IS OpenArray) THEN
+    IF a IS StaticArray THEN
         result := Str.fromInt(a.length());
     END;
     RETURN result
@@ -526,10 +525,6 @@ PROCEDURE arrayElementsType*(a: Array): PType;
     RETURN a.elementsType
 END arrayElementsType;
 
-PROCEDURE OpenArray.length(): INTEGER;
-    RETURN openArrayLength
-END OpenArray.length;
-
 PROCEDURE StaticArray.length(): INTEGER;
     RETURN SELF.len
 END StaticArray.length;
@@ -609,10 +604,10 @@ END makeOpenArray;
 PROCEDURE makeStaticArray*(
     initializer: STRING;
     elementsType: PType;
-    len: INTEGER (* see openArrayLength *)
+    len: INTEGER
     ): PArray;
 VAR
-    result: POINTER TO StaticArray;
+    result: PStaticArray;
 BEGIN
     NEW(result);
     initArray(elementsType, result^);