timed-automata-analyzer 1.0.0 → 1.0.2

package/package.json

@@ -5,7 +5,7 @@
     "luth1um"
   ],
   "description": "An analyzer for Timed Automata written in Rust",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "license": "MIT",
   "repository": {
     "type": "git",

package/timed_automata_analyzer.d.ts

@@ -1,79 +1,82 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
-* @param {TimedAutomaton} ta
-* @returns {(string)[]}
-*/
+ * Checks all locations of the input TA for reachability and returns all unreachable locations. The
+ * result will be empty if all locations are reachable.
+ *
+ * This function will throw an error if one or more validation checks fail. The following
+ * properties will be validated:
+ * <ul>
+ * <li>There exists exactly one initial location.</li>
+ * <li>The set of locations is non-empty.</li>
+ * <li>All invariants are downward-closed.</li>
+ * <li>The highest constant used in any clock constraint is not greater than the highest allowed
+ * value (536870909).</li>
+ * <li>All locations names are unique.</li>
+ * <li>All clock names are unique.</li>
+ * <li>All clocks used in clock constraints are also contained in the set of clocks.</li>
+ * <li>All location names used as source and target of switches are also contained in the set of
+ * locations.</li>
+ * </ul>
+ * @param {TimedAutomaton} ta
+ * @returns {(string)[]}
+ */
 export function findUnreachableLocations(ta: TimedAutomaton): (string)[];
-/**
-*/
 export enum ClockComparator {
   LESSER = 0,
   LEQ = 1,
   GEQ = 2,
   GREATER = 3,
 }
-/**
-*/
 export class Clause {
   free(): void;
-/**
-* @param {Clock} lhs
-* @param {ClockComparator} op
-* @param {number} rhs
-*/
+  /**
+   * @param {Clock} lhs
+   * @param {ClockComparator} op
+   * @param {number} rhs
+   */
   constructor(lhs: Clock, op: ClockComparator, rhs: number);
 }
-/**
-*/
 export class Clock {
   free(): void;
-/**
-* @param {string} name
-*/
+  /**
+   * @param {string} name
+   */
   constructor(name: string);
 }
-/**
-*/
 export class ClockConstraint {
   free(): void;
-/**
-* @param {(Clause)[]} clauses
-*/
+  /**
+   * @param {(Clause)[]} clauses
+   */
   constructor(clauses: (Clause)[]);
 }
-/**
-*/
 export class Location {
   free(): void;
-/**
-* @param {string} name
-* @param {boolean} is_initial
-* @param {ClockConstraint | undefined} [invariant]
-*/
+  /**
+   * @param {string} name
+   * @param {boolean} is_initial
+   * @param {ClockConstraint | undefined} [invariant]
+   */
   constructor(name: string, is_initial: boolean, invariant?: ClockConstraint);
 }
-/**
-*/
 export class Switch {
   free(): void;
-/**
-* @param {Location} source
-* @param {ClockConstraint | undefined} guard
-* @param {string} action
-* @param {(Clock)[]} reset
-* @param {Location} target
-*/
+  /**
+   * @param {Location} source
+   * @param {ClockConstraint | undefined} guard
+   * @param {string} action
+   * @param {(Clock)[]} reset
+   * @param {Location} target
+   */
   constructor(source: Location, guard: ClockConstraint | undefined, action: string, reset: (Clock)[], target: Location);
 }
-/**
-*/
 export class TimedAutomaton {
   free(): void;
-/**
-* @param {(Location)[]} locations
-* @param {(Clock)[]} clocks
-* @param {(Switch)[]} switches
-*/
+  /**
+   * @param {(Location)[]} locations
+   * @param {(Clock)[]} clocks
+   * @param {(Switch)[]} switches
+   */
   constructor(locations: (Location)[], clocks: (Clock)[], switches: (Switch)[]);
 }

package/timed_automata_analyzer.js

@@ -1,5 +1,5 @@
-
 import * as wasm from "./timed_automata_analyzer_bg.wasm";
+export * from "./timed_automata_analyzer_bg.js";
 import { __wbg_set_wasm } from "./timed_automata_analyzer_bg.js";
 __wbg_set_wasm(wasm);
-export * from "./timed_automata_analyzer_bg.js";
+wasm.__wbindgen_start();

package/timed_automata_analyzer_bg.js

@@ -24,35 +24,6 @@ function getStringFromWasm0(ptr, len) {
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
-const heap = new Array(128).fill(undefined);
-
-heap.push(undefined, null, true, false);
-
-let heap_next = heap.length;
-
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = obj;
-    return idx;
-}
-
-function getObject(idx) { return heap[idx]; }
-
-function dropObject(idx) {
-    if (idx < 132) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
 let WASM_VECTOR_LEN = 0;
 
 const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
@@ -127,11 +98,17 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_0.set(idx, obj);
+    return idx;
+}
+
 function passArrayJsValueToWasm0(array, malloc) {
     const ptr = malloc(array.length * 4, 4) >>> 0;
     const mem = getDataViewMemory0();
     for (let i = 0; i < array.length; i++) {
-        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+        mem.setUint32(ptr + 4 * i, addToExternrefTable0(array[i]), true);
     }
     WASM_VECTOR_LEN = array.length;
     return ptr;
@@ -146,39 +123,47 @@ function getArrayJsValueFromWasm0(ptr, len) {
     const mem = getDataViewMemory0();
     const result = [];
     for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(takeObject(mem.getUint32(i, true)));
+        result.push(wasm.__wbindgen_export_0.get(mem.getUint32(i, true)));
     }
+    wasm.__externref_drop_slice(ptr, len);
     return result;
 }
 /**
-* @param {TimedAutomaton} ta
-* @returns {(string)[]}
-*/
+ * Checks all locations of the input TA for reachability and returns all unreachable locations. The
+ * result will be empty if all locations are reachable.
+ *
+ * This function will throw an error if one or more validation checks fail. The following
+ * properties will be validated:
+ * <ul>
+ * <li>There exists exactly one initial location.</li>
+ * <li>The set of locations is non-empty.</li>
+ * <li>All invariants are downward-closed.</li>
+ * <li>The highest constant used in any clock constraint is not greater than the highest allowed
+ * value (536870909).</li>
+ * <li>All locations names are unique.</li>
+ * <li>All clock names are unique.</li>
+ * <li>All clocks used in clock constraints are also contained in the set of clocks.</li>
+ * <li>All location names used as source and target of switches are also contained in the set of
+ * locations.</li>
+ * </ul>
+ * @param {TimedAutomaton} ta
+ * @returns {(string)[]}
+ */
 export function findUnreachableLocations(ta) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        _assertClass(ta, TimedAutomaton);
-        var ptr0 = ta.__destroy_into_raw();
-        wasm.findUnreachableLocations(retptr, ptr0);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
-        wasm.__wbindgen_free(r0, r1 * 4, 4);
-        return v2;
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+    _assertClass(ta, TimedAutomaton);
+    var ptr0 = ta.__destroy_into_raw();
+    const ret = wasm.findUnreachableLocations(ptr0);
+    var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
 }
 
-/**
-*/
 export const ClockComparator = Object.freeze({ LESSER:0,"0":"LESSER",LEQ:1,"1":"LEQ",GEQ:2,"2":"GEQ",GREATER:3,"3":"GREATER", });
 
 const ClauseFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_clause_free(ptr >>> 0, 1));
-/**
-*/
+
 export class Clause {
 
     static __unwrap(jsValue) {
@@ -200,10 +185,10 @@ export class Clause {
         wasm.__wbg_clause_free(ptr, 0);
     }
     /**
-    * @param {Clock} lhs
-    * @param {ClockComparator} op
-    * @param {number} rhs
-    */
+     * @param {Clock} lhs
+     * @param {ClockComparator} op
+     * @param {number} rhs
+     */
     constructor(lhs, op, rhs) {
         _assertClass(lhs, Clock);
         const ret = wasm.clause_new(lhs.__wbg_ptr, op, rhs);
@@ -216,8 +201,7 @@ export class Clause {
 const ClockFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_clock_free(ptr >>> 0, 1));
-/**
-*/
+
 export class Clock {
 
     static __unwrap(jsValue) {
@@ -239,8 +223,8 @@ export class Clock {
         wasm.__wbg_clock_free(ptr, 0);
     }
     /**
-    * @param {string} name
-    */
+     * @param {string} name
+     */
     constructor(name) {
         const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
@@ -254,8 +238,7 @@ export class Clock {
 const ClockConstraintFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_clockconstraint_free(ptr >>> 0, 1));
-/**
-*/
+
 export class ClockConstraint {
 
     __destroy_into_raw() {
@@ -270,8 +253,8 @@ export class ClockConstraint {
         wasm.__wbg_clockconstraint_free(ptr, 0);
     }
     /**
-    * @param {(Clause)[]} clauses
-    */
+     * @param {(Clause)[]} clauses
+     */
     constructor(clauses) {
         const ptr0 = passArrayJsValueToWasm0(clauses, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
@@ -285,8 +268,7 @@ export class ClockConstraint {
 const LocationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_location_free(ptr >>> 0, 1));
-/**
-*/
+
 export class Location {
 
     static __unwrap(jsValue) {
@@ -308,10 +290,10 @@ export class Location {
         wasm.__wbg_location_free(ptr, 0);
     }
     /**
-    * @param {string} name
-    * @param {boolean} is_initial
-    * @param {ClockConstraint | undefined} [invariant]
-    */
+     * @param {string} name
+     * @param {boolean} is_initial
+     * @param {ClockConstraint | undefined} [invariant]
+     */
     constructor(name, is_initial, invariant) {
         const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
@@ -330,8 +312,7 @@ export class Location {
 const SwitchFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_switch_free(ptr >>> 0, 1));
-/**
-*/
+
 export class Switch {
 
     static __unwrap(jsValue) {
@@ -353,12 +334,12 @@ export class Switch {
         wasm.__wbg_switch_free(ptr, 0);
     }
     /**
-    * @param {Location} source
-    * @param {ClockConstraint | undefined} guard
-    * @param {string} action
-    * @param {(Clock)[]} reset
-    * @param {Location} target
-    */
+     * @param {Location} source
+     * @param {ClockConstraint | undefined} guard
+     * @param {string} action
+     * @param {(Clock)[]} reset
+     * @param {Location} target
+     */
     constructor(source, guard, action, reset, target) {
         _assertClass(source, Location);
         let ptr0 = 0;
@@ -381,8 +362,7 @@ export class Switch {
 const TimedAutomatonFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_timedautomaton_free(ptr >>> 0, 1));
-/**
-*/
+
 export class TimedAutomaton {
 
     __destroy_into_raw() {
@@ -397,10 +377,10 @@ export class TimedAutomaton {
         wasm.__wbg_timedautomaton_free(ptr, 0);
     }
     /**
-    * @param {(Location)[]} locations
-    * @param {(Clock)[]} clocks
-    * @param {(Switch)[]} switches
-    */
+     * @param {(Location)[]} locations
+     * @param {(Clock)[]} clocks
+     * @param {(Switch)[]} switches
+     */
     constructor(locations, clocks, switches) {
         const ptr0 = passArrayJsValueToWasm0(locations, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
@@ -416,35 +396,42 @@ export class TimedAutomaton {
 }
 
 export function __wbg_clock_unwrap(arg0) {
-    const ret = Clock.__unwrap(takeObject(arg0));
+    const ret = Clock.__unwrap(arg0);
     return ret;
 };
 
 export function __wbg_clause_unwrap(arg0) {
-    const ret = Clause.__unwrap(takeObject(arg0));
+    const ret = Clause.__unwrap(arg0);
     return ret;
 };
 
-export function __wbg_location_unwrap(arg0) {
-    const ret = Location.__unwrap(takeObject(arg0));
+export function __wbg_switch_unwrap(arg0) {
+    const ret = Switch.__unwrap(arg0);
     return ret;
 };
 
-export function __wbg_switch_unwrap(arg0) {
-    const ret = Switch.__unwrap(takeObject(arg0));
+export function __wbg_location_unwrap(arg0) {
+    const ret = Location.__unwrap(arg0);
     return ret;
 };
 
 export function __wbindgen_string_new(arg0, arg1) {
     const ret = getStringFromWasm0(arg0, arg1);
-    return addHeapObject(ret);
-};
-
-export function __wbindgen_object_drop_ref(arg0) {
-    takeObject(arg0);
+    return ret;
 };
 
 export function __wbindgen_throw(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 };
 
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_export_0;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+