Transferring JsArray -> dynamic array

src/ob/Module.ob

@@ -17,7 +17,10 @@ TYPE
     AnyField = RECORD(Types.Field)
     END;
 
-    AnyTypeProc* = RECORD(Types.DefinedProcedure)
+    AnyTypeProc* = RECORD(Procedure.Std)
+    END;
+
+    AnyProcCall = RECORD(Procedure.Call)
     END;
 
     JS = RECORD(Type)
@@ -36,8 +39,16 @@ PROCEDURE AnyType.initializer(cx: Context.Type; forNew: BOOLEAN): STRING;
     RETURN "undefined"
 END AnyType.initializer;
 
+PROCEDURE makeCallGenerator(cx: LanguageContext.PType): Procedure.PCallGenerator;
+VAR
+    call: POINTER TO AnyProcCall;
+BEGIN
+    NEW(call);
+    RETURN Procedure.makeCallGenerator(call, cx)
+END makeCallGenerator;
+
 PROCEDURE AnyType.callGenerator(cx: LanguageContext.PType): Procedure.PCallGenerator;
-    RETURN Procedure.makeProcCallGenerator(cx, anyProc)
+    RETURN makeCallGenerator(cx)
 END AnyType.callGenerator;
 
 PROCEDURE AnyType.denote(id: STRING): Types.PField;
@@ -64,13 +75,19 @@ PROCEDURE AnyField.asVar(): Types.PId;
     RETURN any.asVar
 END AnyField.asVar;
 
-PROCEDURE AnyTypeProc.args(): JsArray.Type;
-    RETURN NIL
-END AnyTypeProc.args;
+PROCEDURE AnyTypeProc.callGenerator(cx: LanguageContext.PType): Procedure.PCallGenerator;
+    RETURN makeCallGenerator(cx)
+END AnyTypeProc.callGenerator;
 
-PROCEDURE AnyTypeProc.result(): Types.PType;
-    RETURN any
-END AnyTypeProc.result;
+PROCEDURE AnyProcCall.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
+BEGIN
+    argCode <- Procedure.makeArgumentsCode(cx);
+    FOR i <- 0 TO JsArray.len(args) - 1 DO
+        a <- JsArray.at(args, i);
+        argCode.write(a(Code.PExpression), NIL, NIL);
+    END;
+    RETURN Code.makeSimpleExpression("(" + argCode.result() + ")", any)
+END AnyProcCall.make;
 
 PROCEDURE JS.findSymbol(id: STRING): Symbols.PFoundSymbol;
 VAR

src/ob/Procedure.ob

@@ -56,10 +56,10 @@ TYPE
     END;
 
     ArgumentsCode* = RECORD
-        PROCEDURE write(actual: Code.PExpression; 
-                        expected: Types.PProcedureArgument; 
-                        cast: Cast.PCastOp
-                        );
+        PROCEDURE write*(actual: Code.PExpression; 
+                         expected: Types.PProcedureArgument; 
+                         cast: Cast.PCastOp
+                         );
         PROCEDURE result*(): STRING
     END;
     PArgumentsCode* = POINTER TO ArgumentsCode;
@@ -72,7 +72,7 @@ TYPE
     BinaryOp = PROCEDURE(left, right: Code.PExpression; rtl: OberonRtl.PType): Code.PExpression;
     BinaryOpStr = PROCEDURE (x, y: STRING): STRING;
 VAR
-    predefined*: JsArray.Type;
+    predefined*: ARRAY * OF Symbols.PSymbol;
 
 PROCEDURE checkArgument*(
     actual: Code.PExpression; 
@@ -243,20 +243,8 @@ VAR
     call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: JsArray.Type; cx: LanguageContext.PType): Code.PExpression;
-    VAR
-        expectedArgs: JsArray.Type;
-        a: Object.PType;
-
     BEGIN
-        expectedArgs := SELF.args;
-        IF expectedArgs # NIL THEN
-            processArguments(args, expectedArgs, SELF.argumentsCode, cx.types);
-        ELSE
-            FOR i <- 0 TO JsArray.len(args) - 1 DO
-                a := JsArray.at(args, i);
-                SELF.argumentsCode.write(a(Code.PExpression), NIL, NIL);
-            END;
-        END;
+        processArguments(args, SELF.args, SELF.argumentsCode, cx.types);
         RETURN Code.makeSimpleExpression(
                 "(" + SELF.argumentsCode.result() + ")",
                 SELF.result
@@ -643,7 +631,7 @@ PROCEDURE makeAbs(): Symbols.PSymbol;
     BEGIN
         arg := checkSingleArgument(args, SELF, cx.types, NIL);
         argType := arg.type();
-        IF ~JsArray.contains(Types.numeric, argType) THEN
+        IF Types.numeric.indexOf(argType) = -1 THEN
             Errors.raise("type mismatch: expected numeric type, got '"
                          + argType.description() + "'");
         END;
@@ -935,22 +923,21 @@ BEGIN
 END make;
 
 BEGIN
-    predefined := JsArray.make();
-    JsArray.add(predefined, makeNew());
-    JsArray.add(predefined, makeOdd());
-    JsArray.add(predefined, makeAssert());
-    JsArray.add(predefined, setBitImpl("INCL", inclOp));
-    JsArray.add(predefined, setBitImpl("EXCL", exclOp));
-    JsArray.add(predefined, incImpl("INC", "++", incOp));
-    JsArray.add(predefined, incImpl("DEC", "--", decOp));
-    JsArray.add(predefined, makeAbs());
-    JsArray.add(predefined, makeFloor());
-    JsArray.add(predefined, makeFlt());
-    JsArray.add(predefined, bitShiftImpl("LSL", Operator.lsl));
-    JsArray.add(predefined, bitShiftImpl("ASR", Operator.asr));
-    JsArray.add(predefined, bitShiftImpl("ROR", Operator.ror));
-    JsArray.add(predefined, makeOrd());
-    JsArray.add(predefined, makeChr());
-    JsArray.add(predefined, makePack());
-    JsArray.add(predefined, makeUnpk());
+    predefined.add(makeNew());
+    predefined.add(makeOdd());
+    predefined.add(makeAssert());
+    predefined.add(setBitImpl("INCL", inclOp));
+    predefined.add(setBitImpl("EXCL", exclOp));
+    predefined.add(incImpl("INC", "++", incOp));
+    predefined.add(incImpl("DEC", "--", decOp));
+    predefined.add(makeAbs());
+    predefined.add(makeFloor());
+    predefined.add(makeFlt());
+    predefined.add(bitShiftImpl("LSL", Operator.lsl));
+    predefined.add(bitShiftImpl("ASR", Operator.asr));
+    predefined.add(bitShiftImpl("ROR", Operator.ror));
+    predefined.add(makeOrd());
+    predefined.add(makeChr());
+    predefined.add(makePack());
+    predefined.add(makeUnpk());
 END Procedure.

src/ob/Scope.ob

@@ -1,7 +1,6 @@
 MODULE Scope;
 IMPORT 
     Errors, 
-    JsArray, 
     JsMap, 
     Object, 
     Procedures := Procedure, 
@@ -9,6 +8,13 @@ IMPORT
     Symbols, 
     Types;
 TYPE
+    Unresolved = ARRAY * OF STRING;
+
+    Finalizer = POINTER TO RECORD
+        proc: ScopeBase.FinalizerProc;
+        closure: Object.PType
+    END;
+
     Type* = RECORD(ScopeBase.Type)
         PROCEDURE addSymbol*(s: Symbols.PSymbol; exported: BOOLEAN);
         PROCEDURE findSymbol*(id: STRING): Symbols.PFoundSymbol;
@@ -16,8 +22,8 @@ TYPE
 
         stdSymbols: JsMap.Type;
         symbols: JsMap.Type;
-        unresolved: JsArray.Strings;
-        finalizers: JsArray.Type
+        unresolved: Unresolved;
+        finalizers: ARRAY * OF Finalizer
     END;
     PType* = POINTER TO Type;
 
@@ -37,11 +43,6 @@ TYPE
     END;
     PModule = POINTER TO Module;
 
-    Finalizer = POINTER TO RECORD (Object.Type)
-        proc: ScopeBase.FinalizerProc;
-        closure: Object.PType
-    END;
-
 PROCEDURE addSymbolForType*(t: Types.PBasicType; result: JsMap.Type);
 VAR
     name: STRING;
@@ -53,7 +54,6 @@ END addSymbolForType;
 PROCEDURE makeStdSymbols*(): JsMap.Type;
 VAR 
     result: JsMap.Type;
-    proc: Object.PType;
 
     PROCEDURE addSymbol(t: Types.PBasicType);
     BEGIN
@@ -68,9 +68,9 @@ BEGIN
     addSymbol(Types.basic.real);
     addSymbol(Types.basic.set); 
 
-    FOR i <- 0 TO JsArray.len(Procedures.predefined) - 1 DO
-        proc := JsArray.at(Procedures.predefined, i);
-        JsMap.put(result, proc(Symbols.PSymbol).id(), proc);
+    FOR i <- 0 TO LEN(Procedures.predefined) - 1 DO
+        proc <- Procedures.predefined[i];
+        JsMap.put(result, proc.id(), proc);
     END;
     RETURN result
 END makeStdSymbols;
@@ -79,8 +79,6 @@ PROCEDURE init*(VAR scope: Type; stdSymbols: JsMap.Type);
 BEGIN
     scope.stdSymbols := stdSymbols;
     scope.symbols := JsMap.make();
-    scope.unresolved := JsArray.makeStrings();
-    scope.finalizers := JsArray.make();
 END init;
 
 PROCEDURE makeCompiledModule(name: STRING): PCompiledModule;
@@ -107,8 +105,8 @@ END makeModule;
 
 PROCEDURE addUnresolved*(s: Type; id: STRING);
 BEGIN
-    IF ~JsArray.containsString(s.unresolved, id) THEN
-        JsArray.addString(s.unresolved, id);
+    IF s.unresolved.indexOf(id) = -1 THEN
+        s.unresolved.add(id);
     END;
 END addUnresolved;
 
@@ -120,7 +118,7 @@ VAR
     type: Types.PType;
 BEGIN
     id := symbol.id();
-    i := JsArray.stringsIndexOf(s.unresolved, id);
+    i := s.unresolved.indexOf(id);
     IF i # -1 THEN
         info := symbol.info();
         type := info(Types.PTypeId).type();
@@ -130,29 +128,23 @@ BEGIN
                 + id
                 + "' must be of RECORD type because it was used before in the declation of POINTER");
         END;
-        JsArray.removeString(s.unresolved, i);
+        s.unresolved.remove(i);
     END;
 END resolve;
 
-PROCEDURE unresolved*(s: Type): JsArray.Strings;
+PROCEDURE unresolved*(s: Type): Unresolved;
     RETURN s.unresolved
 END unresolved;
 
 PROCEDURE Type.close();
-VAR
-    p: Object.PType;
-    finalizer: Finalizer;
 BEGIN
-    IF SELF.finalizers # NIL THEN
-        FOR i <- 0 TO JsArray.len(SELF.finalizers) - 1 DO
-            p := JsArray.at(SELF.finalizers, i);
-            finalizer := p(Finalizer);
-            finalizer.proc(finalizer.closure);
-        END;
-
-        (* make second close() call safe and free memory *)
-        SELF.finalizers := NIL; 
+    FOR i <- 0 TO LEN(SELF.finalizers) - 1 DO
+        finalizer <- SELF.finalizers[i];
+        finalizer.proc(finalizer.closure);
     END;
+
+    (* make second close() call safe and free memory *)
+    SELF.finalizers.clear(); 
 END Type.close;
 
 PROCEDURE Type.addFinalizer(proc: ScopeBase.FinalizerProc; closure: Object.PType);
@@ -162,10 +154,10 @@ BEGIN
     NEW(f);
     f.proc := proc;
     f.closure := closure;
-    JsArray.add(SELF.finalizers, f);
+    SELF.finalizers.add(f);
 END Type.addFinalizer;
 
-PROCEDURE close*(s: Type): JsArray.Strings;
+PROCEDURE close*(s: Type): Unresolved;
     RETURN s.unresolved
 END close;
 

src/ob/Types.ob

@@ -155,7 +155,7 @@ TYPE
         base:   PRecord;
         cons:   STRING;
         scope:  ScopeBase.PType;
-        notExported: JsArray.Strings
+        notExported: ARRAY * OF STRING
     END;
     
     NonExportedRecord* = RECORD(Record)
@@ -178,7 +178,7 @@ VAR
         bool*, ch*, integer*, uint8*, real*, set*: PBasicType
     END;
 
-    numeric*: JsArray.Type;
+    numeric*: ARRAY * OF PType;
     nil*: POINTER TO Nil;
 
 PROCEDURE TypeId.description(): STRING;
@@ -200,10 +200,10 @@ END finalizeRecord;
 
 PROCEDURE Record.finalize();
 BEGIN
-    FOR i <- 0 TO JsArray.stringsLen(SELF.notExported) - 1 DO
-        JsMap.erase(SELF.fields, JsArray.stringsAt(SELF.notExported, i))
+    FOR i <- 0 TO LEN(SELF.notExported) - 1 DO
+        JsMap.erase(SELF.fields, SELF.notExported[i])
     END;
-    SELF.notExported := NIL;
+    SELF.notExported.clear();
 END Record.finalize;
 
 PROCEDURE initRecord*(r: PRecord; name: STRING; cons: STRING; scope: ScopeBase.PType);
@@ -212,7 +212,6 @@ BEGIN
     r.cons := cons;
     r.scope := scope;
     r.fields := JsMap.make();
-    r.notExported := JsArray.makeStrings();
     scope.addFinalizer(finalizeRecord, r);
 END initRecord;
 
@@ -412,7 +411,7 @@ BEGIN
     END;
     JsMap.put(SELF.fields, f.id(), f);
     IF ~f.exported() THEN
-        JsArray.addString(SELF.notExported, f.id());
+        SELF.notExported.add(f.id());
     END;
 END Record.addField;
 
@@ -761,10 +760,9 @@ BEGIN
     basic.real := makeBasic("REAL", "0");
     basic.set := makeBasic("SET", "0");
 
-    numeric := JsArray.make();
-    JsArray.add(numeric, basic.integer);
-    JsArray.add(numeric, basic.uint8);
-    JsArray.add(numeric, basic.real);
+    numeric.add(basic.integer);
+    numeric.add(basic.uint8);
+    numeric.add(basic.real);
 
     NEW(nil);
 END Types.