get rid of JsMap

src/context.js

@@ -1893,7 +1893,7 @@ exports.ModuleDeclaration = ChainedContext.extend({
         else if (id === this.__name){
             var scope = parent.currentScope();
             scope.close();
-            var exports = Scope.moduleExports(scope);
+            var exports = scope.$exports;
             Scope.defineExports(Scope.moduleSymbol(scope).info(), exports);
             this.codeGenerator().write(this.__moduleGen.epilog(exports));
         }

src/eberon/EberonScope.ob

@@ -1,5 +1,5 @@
 MODULE EberonScope;
-IMPORT Errors, JsMap, Scope, Symbols;
+IMPORT Errors, Scope, Symbols;
 TYPE
     Operator = RECORD(Scope.Type)
         parent: Scope.PType
@@ -34,7 +34,7 @@ PROCEDURE Operator.generateTempVar(pattern: STRING): STRING;
     RETURN SELF.parent.generateTempVar(pattern);
 END;
 
-PROCEDURE makeOperator*(parent: Scope.PType; stdSymbols: JsMap.Type): Scope.PType;
+PROCEDURE makeOperator*(parent: Scope.PType; stdSymbols: Symbols.Map): Scope.PType;
 BEGIN
     result <- NEW Operator(stdSymbols);
     result.parent := parent;

src/eberon/EberonSymbols.ob

@@ -1,22 +1,19 @@
 MODULE EberonSymbols;
-IMPORT EberonMap, EberonString, JsMap, Procedure, Scope, Symbols, Types;
+IMPORT EberonMap, EberonString, Procedure, Scope, Symbols, Types;
 
 PROCEDURE lenArgumentCheck(argType: Types.PType): BOOLEAN;
     RETURN Procedure.lenArgumentCheck(argType) 
         OR (argType = EberonString.string)
 END lenArgumentCheck;
 
-PROCEDURE makeStd*(): JsMap.Type;
-VAR 
-    proc: Symbols.PSymbol;
-    result: JsMap.Type;
+PROCEDURE makeStd*(): Symbols.Map;
 BEGIN
-    result := Scope.makeStdSymbols();
-    proc := Procedure.makeLen(lenArgumentCheck);
-    JsMap.put(result, proc.id(), proc);
+    result <- Scope.makeStdSymbols();
+    proc <- Procedure.makeLen(lenArgumentCheck);
+    result[proc.id()] := proc;
     
     Scope.addSymbolForType(EberonString.string, result);
-    RETURN result
-END makeStd;
+    RETURN result;
+END;
 
 END EberonSymbols.

src/ob/Code.ob

@@ -1,7 +1,6 @@
 MODULE Code;
 IMPORT 
     CodeGenerator,
-    JsMap, 
     Errors,
     Object, 
     Stream, 
@@ -18,7 +17,7 @@ TYPE
         PROCEDURE Designator*(code: STRING; lval: STRING; refCode: RefCodeProc; type: Types.PType; info: Types.PId; scope: ScopeBase.PType);
 
         PROCEDURE code(): STRING;
-        PROCEDURE lval*(): STRING;
+        PROCEDURE lval(): STRING;
         PROCEDURE refCode(): RefCodeProc;
         PROCEDURE type(): Types.PType;
         PROCEDURE info*(): Types.PId;
@@ -79,22 +78,20 @@ TYPE
 
     PExpression* = POINTER TO Expression;
 
+    StringsMap = MAP OF STRING;
+
     ModuleGenerator* = RECORD
-        PROCEDURE ModuleGenerator*(name: STRING; imports: JsMap.Strings);
+        PROCEDURE ModuleGenerator*(name: STRING; imports: StringsMap);
 
         PROCEDURE prolog(): STRING;
-        PROCEDURE epilog(exports: JsMap.Type): STRING;
+        PROCEDURE epilog(exports: Symbols.Map): STRING;
 
         name: STRING;
-        imports: JsMap.Strings
+        imports: StringsMap;
     END;
 
     PModuleGenerator = POINTER TO ModuleGenerator;
 
-    Closure = RECORD(Object.Type)
-        result: STRING
-    END;
-
 PROCEDURE Expression.code(): STRING;
     RETURN SELF.mCode
 END Expression.code;
@@ -300,71 +297,51 @@ BEGIN
         result := typeShouldBeExported(s.info(), s.id())
     END;
     RETURN result
-END genExport;
+END;
 
-PROCEDURE genCommaList(name: STRING; VAR closure: Closure);
+PROCEDURE genCommaList(m: StringsMap; import: BOOLEAN): STRING;
+VAR
+    result: STRING;
 BEGIN
-    IF LEN(closure.result) # 0 THEN
-        closure.result := closure.result + ", ";
+    FOREACH alias, name IN m DO;
+        IF LEN(result) # 0 THEN
+            result := result + ", ";
+        END;
+        IF import THEN
+            result := result + alias;
+        ELSE
+            result := result + name;
+        END;
     END;
-    closure.result := closure.result + name;
-END genCommaList;
-
-PROCEDURE genAliasesAdaptor(key: STRING; value: STRING; VAR closure: Object.Type);
-BEGIN
-    genCommaList(value, closure(Closure));
-END genAliasesAdaptor;
+    RETURN result;
+END;
 
 PROCEDURE ModuleGenerator.prolog(): STRING;
-VAR
-    closure: Closure;
-BEGIN
-    JsMap.forEachString(SELF.imports, genAliasesAdaptor, closure);
-    RETURN "var " + SELF.name + " = function (" + closure.result + "){" + Stream.kCR
-END ModuleGenerator.prolog;
+    RETURN "var " + SELF.name + " = function (" + genCommaList(SELF.imports, TRUE) + "){" + Stream.kCR
+END;
 
-PROCEDURE genExports(s: Symbols.Symbol; VAR closure: Closure);
+PROCEDURE ModuleGenerator.epilog(exports: Symbols.Map): STRING;
 VAR
-    code: STRING;
+    result: STRING;
 BEGIN
-    code := genExport(s);
-    IF LEN(code) # 0 THEN
-        IF LEN(closure.result) # 0 THEN
-            closure.result := closure.result + "," + Stream.kCR;
+    FOREACH s, k IN exports DO
+        code <- genExport(s^);
+        IF LEN(code) # 0 THEN
+            IF LEN(result) # 0 THEN
+                result := result + "," + Stream.kCR;
+            END;
+            result := result + CodeGenerator.kTab + s.id() + ": " + code;
         END;
-        closure.result := closure.result + CodeGenerator.kTab + s.id() + ": " + code;
     END;
-END genExports;
-
-PROCEDURE genExportsAdaptor(key: STRING; value: Object.PType; VAR closure: Object.Type);
-BEGIN
-    genExports(value^(Symbols.Symbol), closure(Closure));
-END genExportsAdaptor;
-
-PROCEDURE genImportListAdaptor(key: STRING; value: STRING; VAR closure: Object.Type);
-BEGIN
-    genCommaList(key, closure(Closure));
-END genImportListAdaptor;
 
-PROCEDURE ModuleGenerator.epilog(exports: JsMap.Type): STRING;
-VAR
-    result: STRING;
-    closure: Closure;
-BEGIN
-    JsMap.forEach(exports, genExportsAdaptor, closure);
-    result := closure.result;
     IF LEN(result) # 0 THEN
         result := "return {" + Stream.kCR + result + Stream.kCR + "}" + Stream.kCR;
     END;
-    result := result + "}(";
-
-    closure.result := "";
-    JsMap.forEachString(SELF.imports, genImportListAdaptor, closure);
-    result := result + closure.result + ");" + Stream.kCR;
+    result := result + "}(" + genCommaList(SELF.imports, FALSE) + ");" + Stream.kCR;
     RETURN result
-END ModuleGenerator.epilog;
+END;
 
-PROCEDURE ModuleGenerator.ModuleGenerator(name: STRING; imports: JsMap.Strings)
+PROCEDURE ModuleGenerator.ModuleGenerator(name: STRING; imports: StringsMap)
     | name(name),
       imports(imports);
 END;

src/ob/Scope.ob

@@ -1,7 +1,6 @@
 MODULE Scope;
 IMPORT 
     Errors, 
-    JsMap, 
     Object, 
     Procedures := Procedure, 
     ScopeBase,
@@ -19,15 +18,15 @@ TYPE
     END;
 
     Type* = RECORD(ScopeBase.Type)
-        PROCEDURE Type*(stdSymbols: JsMap.Type);
+        PROCEDURE Type*(stdSymbols: Symbols.Map);
 
         PROCEDURE addSymbol*(s: Symbols.PSymbol; exported: BOOLEAN);
         PROCEDURE findSymbol*(id: STRING): Symbols.PFoundSymbol;
         PROCEDURE close();
         PROCEDURE generateTempVar*(pattern: STRING): STRING;
 
-        stdSymbols: JsMap.Type;
-        symbols: JsMap.Type;
+        stdSymbols: Symbols.Map;
+        symbols: Symbols.Map;
         unresolved: Unresolved;
         finalizers: ARRAY * OF POINTER TO Finalizer
     END;
@@ -38,40 +37,34 @@ TYPE
     END;
 
     CompiledModule = RECORD(Types.Module)
-        PROCEDURE CompiledModule(name: STRING);
-
         PROCEDURE findSymbol(id: STRING): Symbols.PFoundSymbol;
 
-        exports: JsMap.Type
+        exports: Symbols.Map;
     END;
 
     Module* = RECORD(Type)
-        PROCEDURE Module*(name: STRING; stdSymbols: JsMap.Type);
+        PROCEDURE Module*(name: STRING; stdSymbols: Symbols.Map);
 
         symbol: Symbols.PSymbol;
-        exports: JsMap.Type;
+        exports: Symbols.Map;
         tempVarCounter: INTEGER;
     END;
     PModule = POINTER TO Module;
 
-PROCEDURE addSymbolForType*(t: Types.PBasicType; result: JsMap.Type);
-VAR
-    name: STRING;
+PROCEDURE addSymbolForType*(t: Types.PBasicType; VAR result: Symbols.Map);
 BEGIN
-    name := Types.typeName(t^);
-    JsMap.put(result, name, NEW Symbols.Symbol(name, NEW Types.TypeId(t)));
-END addSymbolForType;
+    result[t.name] := NEW Symbols.Symbol(t.name, NEW Types.TypeId(t));
+END;
 
-PROCEDURE makeStdSymbols*(): JsMap.Type;
+PROCEDURE makeStdSymbols*(): Symbols.Map;
 VAR 
-    result: JsMap.Type;
+    result: Symbols.Map;
 
     PROCEDURE addSymbol(t: Types.PBasicType);
     BEGIN
         addSymbolForType(t, result);
-    END addSymbol;
+    END;
 BEGIN
-    result := JsMap.make();
     addSymbol(Types.basic.bool);
     addSymbol(Types.basic.ch);
     addSymbol(Types.basic.integer);
@@ -81,25 +74,18 @@ BEGIN
 
     FOR i <- 0 TO LEN(Procedures.predefined) - 1 DO
         proc <- Procedures.predefined[i];
-        JsMap.put(result, proc.id(), proc);
+        result[proc.id()] := proc;
     END;
     RETURN result
-END makeStdSymbols;
-
-PROCEDURE Type.Type(stdSymbols: JsMap.Type)
-    | stdSymbols(stdSymbols),
-      symbols(JsMap.make());
 END;
 
-PROCEDURE CompiledModule.CompiledModule(name: STRING)
-    | SUPER(name),
-      exports(JsMap.make());
+PROCEDURE Type.Type(stdSymbols: Symbols.Map)
+    | stdSymbols(stdSymbols);
 END;
 
-PROCEDURE Module.Module(name: STRING; stdSymbols: JsMap.Type)
+PROCEDURE Module.Module(name: STRING; stdSymbols: Symbols.Map)
     | SUPER(stdSymbols),
-      symbol(NEW Symbols.Symbol(name, NEW CompiledModule(name))),
-      exports(JsMap.make());
+      symbol(NEW Symbols.Symbol(name, NEW CompiledModule(name)));
 BEGIN
     SELF.addSymbol(SELF.symbol, FALSE);
 END;
@@ -109,7 +95,7 @@ BEGIN
     IF s.unresolved.indexOf(id) = -1 THEN
         s.unresolved.add(id);
     END;
-END addUnresolved;
+END;
 
 PROCEDURE resolve*(VAR s: Type; symbol: Symbols.PSymbol);
 VAR
@@ -131,11 +117,11 @@ BEGIN
         END;
         s.unresolved.remove(i);
     END;
-END resolve;
+END;
 
 PROCEDURE unresolved*(s: Type): Unresolved;
     RETURN s.unresolved
-END unresolved;
+END;
 
 PROCEDURE Type.close();
 BEGIN
@@ -146,7 +132,7 @@ BEGIN
 
     (* make second close() call safe and free memory *)
     SELF.finalizers.clear(); 
-END Type.close;
+END;
 
 PROCEDURE Finalizer.Finalizer(proc: ScopeBase.FinalizerProc; closure: Object.PType)
     | proc(proc),
@@ -160,36 +146,36 @@ END;
 
 PROCEDURE close*(s: Type): Unresolved;
     RETURN s.unresolved
-END close;
+END;
 
 PROCEDURE Type.addSymbol(s: Symbols.PSymbol; exported: BOOLEAN);
-VAR
-    id: STRING;
 BEGIN
-    id := s.id();
+    id <- s.id();
     IF SELF.findSymbol(id) # NIL THEN
         Errors.raise("'" + id + "' already declared");
     END;
-    JsMap.put(SELF.symbols, id, s);
-END Type.addSymbol;
+    SELF.symbols[id] := s;
+END;
 
 PROCEDURE Type.findSymbol(id: STRING): Symbols.PFoundSymbol;
 VAR
-    result: Object.PType;
+    result: Symbols.PSymbol;
     found: Symbols.PFoundSymbol;
 BEGIN
-    IF ~JsMap.find(SELF.symbols, id, result) THEN
-        void <- JsMap.find(SELF.stdSymbols, id, result);
+    IF id IN SELF.symbols THEN
+        result := SELF.symbols[id];
+    ELSIF id IN SELF.stdSymbols THEN
+        result := SELF.stdSymbols[id];
     END;
     IF result # NIL THEN
-        found := NEW Symbols.FoundSymbol(result(Symbols.PSymbol), SELF(POINTER))
+        found := NEW Symbols.FoundSymbol(result, SELF(POINTER))
     END;
     RETURN found
-END Type.findSymbol;
+END;
 
 PROCEDURE Procedure.name(): STRING;
     RETURN "procedure"
-END Procedure.name;
+END;
 
 PROCEDURE Procedure.addSymbol(s: Symbols.PSymbol; exported: BOOLEAN);
 VAR
@@ -201,7 +187,7 @@ BEGIN
                      + info.idType() + " '" + s.id() + "'");
     END;
     SUPER(s, exported);
-END Procedure.addSymbol;
+END;
 
 PROCEDURE generateTempVar(pattern: STRING; VAR counter: INTEGER): STRING;
 BEGIN
@@ -217,57 +203,46 @@ PROCEDURE Module.generateTempVar(pattern: STRING): STRING;
     RETURN generateTempVar(pattern, SELF.tempVarCounter);
 END;
 
-PROCEDURE makeProcedure*(stdSymbols: JsMap.Type): PType;
+PROCEDURE makeProcedure*(stdSymbols: Symbols.Map): PType;
     RETURN NEW Procedure(stdSymbols);
 END;
 
-PROCEDURE addExport(id: STRING; value: Object.PType; VAR closure: Object.Type);
-VAR
-    symbol: Symbols.PSymbol;
-    info: Types.PId;
+PROCEDURE defineExports*(VAR m: CompiledModule; exports: Symbols.Map);
 BEGIN
-    symbol := value(Symbols.PSymbol);
-    info := symbol.info();
-    IF info IS Types.PVariable THEN
-        symbol := NEW Symbols.Symbol(id, Types.makeExportedVariable(info(Types.PVariable)^));
+    FOREACH k, id IN exports DO
+        symbol <- k;
+        info <- symbol.info();
+        IF info IS Types.PVariable THEN
+            symbol := NEW Symbols.Symbol(id, Types.makeExportedVariable(info^));
+        END;
+        m.exports[id] := symbol;
     END;
-    JsMap.put(closure(CompiledModule).exports, id, symbol);
-END addExport;
-
-PROCEDURE defineExports*(VAR m: CompiledModule; exports: JsMap.Type);
-BEGIN
-    JsMap.forEach(exports, addExport, m);
-END defineExports;
+END;
 
 PROCEDURE CompiledModule.findSymbol(id: STRING): Symbols.PFoundSymbol;
 VAR
-    s: Object.PType;
     result: Symbols.PFoundSymbol;
 BEGIN
-    IF JsMap.find(SELF.exports, id, s) THEN
-        result := NEW Symbols.FoundSymbol(s(Symbols.PSymbol), NIL);
+    IF id IN SELF.exports THEN
+        result := NEW Symbols.FoundSymbol(SELF.exports[id], NIL);
     END;
     RETURN result
-END CompiledModule.findSymbol;
+END;
 
 PROCEDURE Module.name(): STRING;
     RETURN "module"
-END Module.name;
+END;
 
 PROCEDURE Module.addSymbol(s: Symbols.PSymbol; exported: BOOLEAN);
 BEGIN
     SUPER(s, exported);
     IF exported THEN
-        JsMap.put(SELF.exports, s.id(), s);
+        SELF.exports[s.id()] := s;
     END;
-END Module.addSymbol;
+END;
 
 PROCEDURE moduleSymbol*(m: Module): Symbols.PSymbol;
     RETURN m.symbol
-END moduleSymbol;
-
-PROCEDURE moduleExports*(m: Module): JsMap.Type;
-    RETURN m.exports
-END moduleExports;
+END;
 
 END Scope.

src/ob/Symbols.ob

@@ -17,6 +17,7 @@ TYPE
     END;
 
     PSymbol* = POINTER TO Symbol;
+    Map* = MAP OF PSymbol;
 
     FoundSymbol* = RECORD
         PROCEDURE FoundSymbol*(s: PSymbol; scope: ScopeBase.PType);

src/ob/Types.ob

@@ -1,6 +1,6 @@
 MODULE Types;
 IMPORT
-    Context, Errors, JS, JsMap, Object, ScopeBase, Str := String;
+    Context, Errors, JS, Object, ScopeBase, Str := String;
 TYPE
     Id* = RECORD(Object.Type)
         PROCEDURE idType*(): STRING

src/oberon/OberonSymbols.ob

@@ -1,15 +1,12 @@
 MODULE OberonSymbols;
-IMPORT JsMap, Procedure, Scope, Symbols;
+IMPORT Procedure, Scope, Symbols;
 
-PROCEDURE makeStd*(): JsMap.Type;
-VAR 
-    proc: Symbols.PSymbol;
-    result: JsMap.Type;
+PROCEDURE makeStd*(): Symbols.Map;
 BEGIN
-    result := Scope.makeStdSymbols();
-    proc := Procedure.makeLen(Procedure.lenArgumentCheck);
-    JsMap.put(result, proc.id(), proc);
-    RETURN result
-END makeStd;
+    result <- Scope.makeStdSymbols();
+    proc <- Procedure.makeLen(Procedure.lenArgumentCheck);
+    result[proc.id()] := proc;
+    RETURN result;
+END;
 
 END OberonSymbols.

src/oc.js

@@ -40,7 +40,7 @@ function compileModule(grammar, stream, context, handleErrors){
     return new CompiledModule(
             Scope.moduleSymbol(scope),
             context.codeGenerator().result(),
-            Scope.moduleExports(scope));
+            scope.exports);
 }
 
 function compileModulesFromText(