Fix code generation for .indexOf for dynamic array od CHAR

src/eberon/EberonDynamicArray.ob

@@ -186,20 +186,22 @@ BEGIN
     RETURN result
 END MethodAdd.callGenerator;
 
-PROCEDURE MethodCallRemove.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+PROCEDURE MethodCallRemove.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
 BEGIN
-    arg <- Procedure.checkSingleArgument(args, SELF, cx.types);
+    argCode <- Procedure.makeArgumentsCode(cx);
+    arg <- Procedure.checkSingleArgument(args, SELF, cx.types, argCode);
     value <- arg.constValue();
     IF (value # NIL) & (value^ IS Code.IntConst) THEN
         Code.checkIndex(value.value);
     END;
-    RETURN Code.makeSimpleExpression("(" + arg.code() + ", 1)", NIL)
+    RETURN Code.makeSimpleExpression("(" + argCode.result() + ", 1)", NIL)
 END MethodCallRemove.make;
 
-PROCEDURE MethodCallIndexOf.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+PROCEDURE MethodCallIndexOf.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
 BEGIN
-    arg <- Procedure.checkSingleArgument(args, SELF, cx.types);
-    RETURN Code.makeSimpleExpression("(" + arg.code() + ")", Types.basic.integer)
+    argCode <- Procedure.makeArgumentsCode(cx);
+    void <- Procedure.checkSingleArgument(args, SELF, cx.types, argCode);
+    RETURN Code.makeSimpleExpression("(" + argCode.result() + ")", Types.basic.integer)
 END MethodCallIndexOf.make;
 
 PROCEDURE MethodRemove.designatorCode(id: STRING): STRING;

src/ob/Module.ob

@@ -101,12 +101,12 @@ VAR
     call: POINTER TO Call;
     proc: POINTER TO Proc;
 
-    PROCEDURE Call.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE Call.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         arg: Code.PExpression;
         type: Types.PType;
     BEGIN
-        arg := Procedure.checkSingleArgument(args, SELF, cx.types);
+        arg := Procedure.checkSingleArgument(args, SELF, cx.types, NIL);
         type := arg.type();
         IF ~(type IS Types.PString) THEN
             Errors.raise("string is expected as an argument of "

src/ob/Procedure.ob

@@ -16,7 +16,7 @@ IMPORT
     Types;
 TYPE
     Call* = RECORD
-        PROCEDURE make*(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression
+        PROCEDURE make*(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression
     END;
     PCall = POINTER TO Call;
 
@@ -188,7 +188,7 @@ BEGIN
 END CallGenerator.handleArgument;
 
 PROCEDURE CallGenerator.end(): Code.PExpression;
-    RETURN SELF.call.make(SELF.args, SELF.cx^)
+    RETURN SELF.call.make(SELF.args, SELF.cx)
 END CallGenerator.end;
 
 PROCEDURE makeCallGenerator*(call: PCall; cx: LanguageContext.PType): PCallGenerator;
@@ -242,7 +242,7 @@ TYPE
 VAR
     call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         expectedArgs: JsArray.Type;
         a: Object.PType;
@@ -351,10 +351,15 @@ BEGIN
     JsArray.add(call.args, a);
 END hasVarArgumnetWithCustomType;
 
-PROCEDURE checkSingleArgument*(actual: JsArray.Type; call: StdCall; types: Language.PTypes): Code.PExpression;
+PROCEDURE checkSingleArgument*(
+    actual: JsArray.Type; 
+    call: StdCall; 
+    types: Language.PTypes; 
+    code: PArgumentsCode
+    ): Code.PExpression;
 BEGIN
     ASSERT(JsArray.len(call.args) = 1);
-    checkArguments(actual, call.args, types);
+    processArguments(actual, call.args, code, types);
     ASSERT(JsArray.len(actual) = 1);
     RETURN nthArgument(actual, 0)
 END checkSingleArgument;
@@ -366,13 +371,13 @@ PROCEDURE makeNew(): Symbols.PSymbol;
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         arg: Code.PExpression;
         argType: Types.PType;
         baseType: Types.PRecord;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types);
+        arg := checkSingleArgument(args, SELF, cx.types, NIL);
         argType := arg.type();
         IF ~(argType IS Types.PPointer) THEN
             Errors.raise("POINTER variable expected, got '" 
@@ -383,7 +388,7 @@ PROCEDURE makeNew(): Symbols.PSymbol;
             Errors.raise("non-exported RECORD type cannot be used in NEW");
         END;
         RETURN Code.makeSimpleExpression(
-                arg.code() + " = " + baseType.initializer(cx, TRUE),
+                arg.code() + " = " + baseType.initializer(cx^, TRUE),
                 NIL)
     END CallImpl.make;
 BEGIN
@@ -397,12 +402,12 @@ PROCEDURE lenArgumentCheck*(argType: Types.PType): BOOLEAN;
     RETURN (argType IS Types.PArray) OR (argType IS Types.PString)
 END lenArgumentCheck;
 
-PROCEDURE CallLen.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+PROCEDURE CallLen.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
 VAR
     arg: Code.PExpression;
     argType: Types.PType;
 BEGIN
-    arg := checkSingleArgument(args, SELF, cx.types);
+    arg := checkSingleArgument(args, SELF, cx.types, NIL);
     argType := arg.type();
     IF ~SELF.check(argType) THEN
         Errors.raise("ARRAY or string is expected as an argument of LEN, got '"
@@ -431,13 +436,13 @@ PROCEDURE makeOdd(): Symbols.PSymbol;
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         arg: Code.PExpression;
         code: STRING;
         constValue: Code.PConst;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types);
+        arg := checkSingleArgument(args, SELF, cx.types, NIL);
         code := Code.adjustPrecedence(arg, Precedence.bitAnd);
         
         constValue := arg.constValue();
@@ -467,11 +472,11 @@ PROCEDURE makeAssert(): Symbols.PSymbol;
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         arg: Code.PExpression;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types);
+        arg := checkSingleArgument(args, SELF, cx.types, NIL);
         RETURN Code.makeSimpleExpression(
                 cx.rtl.assertId() + "(" + arg.code() + ")",
                 NIL)
@@ -492,7 +497,7 @@ PROCEDURE setBitImpl(name: STRING; bitOp: BinaryOpStr): Symbols.PSymbol;
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         x, y: Code.PExpression;
         yValue: INTEGER;
@@ -570,7 +575,7 @@ PROCEDURE incImpl(name: STRING; unary: STRING; incOp: BinaryOpStr): Symbols.PSym
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         x, y: Code.PExpression;
         code: STRING;
@@ -631,12 +636,12 @@ PROCEDURE makeAbs(): Symbols.PSymbol;
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         arg: Code.PExpression;
         argType: Types.PType;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types);
+        arg := checkSingleArgument(args, SELF, cx.types, NIL);
         argType := arg.type();
         IF ~JsArray.contains(Types.numeric, argType) THEN
             Errors.raise("type mismatch: expected numeric type, got '"
@@ -658,11 +663,11 @@ PROCEDURE makeFloor(): Symbols.PSymbol;
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         arg: Code.PExpression;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types);
+        arg := checkSingleArgument(args, SELF, cx.types, NIL);
         RETURN Code.makeSimpleExpression(
             "Math.floor(" + arg.code() + ")",
             Types.basic.integer)
@@ -681,12 +686,12 @@ PROCEDURE makeFlt(): Symbols.PSymbol;
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         arg: Code.PExpression;
         value: Code.PConst;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types);
+        arg := checkSingleArgument(args, SELF, cx.types, NIL);
         value := arg.constValue();
         IF value # NIL THEN
             value := Code.makeRealConst(FLT(value^(Code.IntConst).value));
@@ -714,7 +719,7 @@ PROCEDURE bitShiftImpl(name: STRING; op: BinaryOp): Symbols.PSymbol;
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         x, y: Code.PExpression;
     BEGIN
@@ -741,7 +746,7 @@ PROCEDURE makeOrd(): Symbols.PSymbol;
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         arg: Code.PExpression;
         argType: Types.PType;
@@ -750,7 +755,7 @@ PROCEDURE makeOrd(): Symbols.PSymbol;
         ch: CHAR;
         result: Code.PExpression;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types);
+        arg := checkSingleArgument(args, SELF, cx.types, NIL);
         argType := arg.type();
         IF (argType = Types.basic.ch) OR (argType = Types.basic.set) THEN
             value := arg.constValue();
@@ -795,11 +800,11 @@ PROCEDURE makeChr(): Symbols.PSymbol;
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         arg: Code.PExpression;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types);
+        arg := checkSingleArgument(args, SELF, cx.types, NIL);
         RETURN Code.makeSimpleExpression(arg.code(), Types.basic.ch)
     END CallImpl.make;
 BEGIN
@@ -816,7 +821,7 @@ PROCEDURE makePack(): Symbols.PSymbol;
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         x, y: Code.PExpression;
     BEGIN
@@ -824,7 +829,7 @@ PROCEDURE makePack(): Symbols.PSymbol;
         x := nthArgument(args, 0);
         y := nthArgument(args, 1);
         RETURN Code.makeSimpleExpression(
-            Operator.mulInplace(x, Operator.pow2(y), cx),
+            Operator.mulInplace(x, Operator.pow2(y), cx^),
             NIL)
     END CallImpl.make;
 BEGIN
@@ -842,7 +847,7 @@ PROCEDURE makeUnpk(): Symbols.PSymbol;
     VAR
         call: POINTER TO CallImpl;
 
-    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
+    PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
     VAR
         x, y: Code.PExpression;
     BEGIN
@@ -850,9 +855,9 @@ PROCEDURE makeUnpk(): Symbols.PSymbol;
         x := nthArgument(args, 0);
         y := nthArgument(args, 1);
         RETURN Code.makeSimpleExpression(
-                Operator.assign(y, Operator.log2(x), cx) 
+                Operator.assign(y, Operator.log2(x), cx^) 
                 + "; "
-                + Operator.divInplace(x, Operator.pow2(y), cx),
+                + Operator.divInplace(x, Operator.pow2(y), cx^),
             NIL)
     END CallImpl.make;
 BEGIN

test/expected/eberon/dynamic_array.js

@@ -93,6 +93,7 @@ var r = new T();
 var a = RTL$.makeArray(3, 0);
 var dynamicInt = [];
 var dynamicString = [];
+var dynamicChar = [];
 var dynamicByte = [];
 var dynamicRecord = [];
 var dynamicArrayOfStaticArrayInt = [];
@@ -111,10 +112,12 @@ dynamicInt.push(byte);
 dynamicString.push("abc");
 dynamicString.push("\"");
 dynamicString.push(s);
+dynamicChar.push(34);
 dynamicByte.push(byte);
 dynamicByte.push(i & 0xFF);
 dynamicRecord.push(RTL$.clone(r));
 dynamicArrayOfStaticArrayInt.push(RTL$.clone(a));
 RTL$.assert(dynamicInt.indexOf(i) != -1);
+RTL$.assert(dynamicChar.indexOf(34) != -1);
 dynamicInt.splice(i, 1);
 }();

test/input/eberon/dynamic_array.ob

@@ -10,6 +10,7 @@ VAR
     a: A;
     dynamicInt: ARRAY * OF INTEGER;
     dynamicString: ARRAY * OF STRING;
+    dynamicChar: ARRAY * OF CHAR;
     dynamicByte: ARRAY * OF BYTE;
     dynamicRecord: ARRAY * OF T;
     dynamicArrayOfStaticArrayInt: ARRAY * OF A;
@@ -33,6 +34,8 @@ BEGIN
     dynamicString.add("abc");
     dynamicString.add(22X);
     dynamicString.add(s);
+
+    dynamicChar.add(22X);
     
     dynamicByte.add(byte);
     dynamicByte.add(i);
@@ -42,6 +45,7 @@ BEGIN
     dynamicArrayOfStaticArrayInt.add(a);
 
     ASSERT(dynamicInt.indexOf(i) # -1);
+    ASSERT(dynamicChar.indexOf(22X) # -1);
 
     dynamicInt.remove(i);
 END m.