cleaned away some old exception types

jslib/jit/compiler/driver.js

@@ -252,7 +252,7 @@ RiverTrail.compiler = (function () {
                 // numbers are floats
                 argumentTypes.push({ inferredType: defaultNumberType, dimSize: [] });
             } else {
-                throw new CompilerBug("Type derivation for argument not implemented yet");
+                throw new Error("Type derivation for argument not implemented yet");
             }
         }
         return argumentTypes;
@@ -291,16 +291,6 @@ RiverTrail.compiler = (function () {
                 Array.prototype.every.call(shapeA, function (a,idx) { return a == shapeB[idx];}));
     };
 
-    // I create three names for Error here so that we can, should we ever wish
-    // distinguish both or have our own implementation for exceptions
-    var errorHelper = function errorHelper(e) {
-        throw (e);
-    };
-
-    var CompilerError = errorHelper;
-    var CompilerBug = errorHelper;     // something went wrong although it should not
-    var CompilerAbort = errorHelper;   // exception thrown to influence control flow, e.g., misspeculation
-
 // end code from parallel array
     return {
         verboseDebug: false,

jslib/jit/compiler/runOCL.js

@@ -64,7 +64,7 @@ RiverTrail.compiler.runOCL = function () {
         var resSize;
         var kernelName = ast.name;
         if (!kernelName) {
-            throw new CompilerBug("Invalid ast: Function expected at top level");
+            throw new Error("Invalid ast: Function expected at top level");
         }
         if ((construct === "comprehension") || (construct === "comprehensionScalar")) {
             // comprehensions do not have a source, so we derive the required information
@@ -103,7 +103,7 @@ RiverTrail.compiler.runOCL = function () {
                 } else {
                     // We have a regular array as data container. There is no point trying
                     // to convert it, as the constructor would already have tried.
-                    throw new CompilerError("Cannot transform regular array to OpenCL kernel arguments");
+                    throw new Error("Cannot transform regular array to OpenCL kernel arguments");
                 }
                 // Add the offset as an additional integer argument. We do this for 
                 // Parallel Array arguments, only! The kernel will have been created 
@@ -127,7 +127,7 @@ RiverTrail.compiler.runOCL = function () {
                 // map the typed array
                 args.push(RiverTrail.compiler.openCLContext.mapData(object));
             } else {
-                throw new CompilerError("only typed arrays and scalars are currently supported as OpenCL kernel arguments");
+                throw new Error("only typed arrays and scalars are currently supported as OpenCL kernel arguments");
             }
             return args;
         }
@@ -147,10 +147,10 @@ RiverTrail.compiler.runOCL = function () {
             // first we ensure that the shape of what we compute is the shape of what is expected
             if (!equalsShape(resShape, paSource.updateInPlaceShape)) {
                 // throwing this will revert the outer scan to non-destructive mode
-                throw new CompilerAbort("shape mismatch during update in place!");
+                throw new Error("shape mismatch during update in place!");
             }
             if (++paSource.updateInPlaceUses !== 1) {
-                throw new CompilerAbort("preallocated memory used more than once!");
+                throw new Error("preallocated memory used more than once!");
             }
             if (!(paSource.updateInPlacePA.data instanceof Components.interfaces.dpoIData)) {
                 paSource.updateInPlacePA.data = RiverTrail.compiler.openCLContext.mapData(paSource.updateInPlacePA.data);
@@ -161,7 +161,7 @@ RiverTrail.compiler.runOCL = function () {
             // We allocate whatever the result type says. To ensure portability of 
             // the extension, we need a template typed array. So lets just create one!
             var template = RiverTrail.Helper.elementalTypeToConstructor(resultElemType);
-            if (template == undefined) throw new CompilerBug("cannot map inferred type to constructor");
+            if (template == undefined) throw new Error("cannot map inferred type to constructor");
             resultMemObj = RiverTrail.compiler.openCLContext.allocateData(new template(1), resSize);
             resultOffset = 0;
         }
@@ -220,7 +220,7 @@ RiverTrail.compiler.runOCL = function () {
                 } else if (arg instanceof Components.interfaces.dpoIData) {
                     kernel.setArgument(index, arg);
                 } else {
-                    throw new CompilerBug("unexpected kernel argument type!");
+                    throw new Error("unexpected kernel argument type!");
                 }
                 return kernel;
             } catch (e) {