Merge branch 'move-javascript-ffi-to-abc-interpreter' into 'master'

Move the JavaScript FFI to abc-interpreter to make it easier to use it in other programs

See merge request !375

Examples/Applications/Incidone/WebPublic/index.html

@@ -10,7 +10,6 @@
 
 	<!-- ABC interpreter -->
 	<script type="text/javascript" src="/js/abc-interpreter.js"></script>
-	<script type="text/javascript" src="/js/itasks-abc-interpreter.js"></script>
 
 	<!-- iTasks framework -->
 	<script type="text/javascript" src="/js/itasks-core.js"></script>

Examples/WasmTest.icl

@@ -2,7 +2,7 @@ module WasmTest
 
 import StdEnv
 import iTasks
-import iTasks.UI.JavaScript
+import ABC.Interpreter.JavaScript
 
 // This is a simple test program to try out things with the WebAssembly ABC interpreter.
 

Libraries/iTasks/Extensions/Clock.icl

@@ -4,10 +4,10 @@ implementation module iTasks.Extensions.Clock
 */
 import iTasks
 import iTasks.UI.Definition, iTasks.UI.Editor
-import iTasks.UI.JavaScript
 import iTasks.Extensions.DateTime
 import qualified Data.Map as DM, Data.Tuple, Data.Error
 import Text.HTML, Data.Func
+import ABC.Interpreter.JavaScript
 import StdEnv
 
 derive JSONEncode AnalogClock

Libraries/iTasks/Extensions/Dashboard.icl

 implementation module iTasks.Extensions.Dashboard
 import iTasks
-import iTasks.UI.Editor, iTasks.UI.Definition, iTasks.UI.JavaScript
+import iTasks.UI.Editor, iTasks.UI.Definition
 import qualified Data.Map as DM, Data.Error
 import Text.HTML, StdMisc, StdArray, Data.Func
+import ABC.Interpreter.JavaScript
 
 derive JSONEncode ControlLight
 derive JSONDecode ControlLight

Libraries/iTasks/Extensions/Editors/Ace.icl

@@ -2,7 +2,7 @@ implementation module iTasks.Extensions.Editors.Ace
 
 import iTasks
 import iTasks.UI.Editor, iTasks.UI.Editor.Modifiers, iTasks.UI.Definition
-import iTasks.UI.JavaScript
+import ABC.Interpreter.JavaScript
 import qualified Data.Map as DM
 import Data.Func, StdArray
 

Libraries/iTasks/Extensions/Form/Pikaday.icl

@@ -2,10 +2,11 @@ implementation module iTasks.Extensions.Form.Pikaday
 
 import StdEnv
 import iTasks, Data.Func
-import iTasks.UI.Definition, iTasks.UI.Editor, iTasks.UI.JavaScript
+import iTasks.UI.Definition, iTasks.UI.Editor
 import iTasks.UI.Editor.Modifiers, iTasks.UI.Editor.Controls
 import iTasks.Extensions.DateTime
 import qualified Data.Map as DM
+import ABC.Interpreter.JavaScript
 
 PIKADAY_JS_URL :== "/pikaday/pikaday.js"
 PIKADAY_CSS_URL :== "/pikaday/css/pikaday.css"

Libraries/iTasks/Extensions/GIS/Leaflet.icl

 implementation module iTasks.Extensions.GIS.Leaflet
 
 import iTasks
-import iTasks.UI.Definition, iTasks.UI.Editor, iTasks.UI.JavaScript
+import iTasks.UI.Definition, iTasks.UI.Editor
 import StdMisc, Data.Tuple, Data.Error, Data.Func, Text, Data.Functor
 import qualified Data.Map as DM
 //from Text.HTML import instance toString HtmlTag, instance toString SVGElt
 import Text.HTML
 from Text.Encodings.Base64 import base64Encode
 from iTasks.UI.Editor.Common import diffChildren, :: ChildUpdate (..)
+import ABC.Interpreter.JavaScript
 import StdArray
 
 LEAFLET_JS           :== "/leaflet-1.3.4/leaflet.js"

Libraries/iTasks/Extensions/SVG/SVGEditor.icl

 implementation module iTasks.Extensions.SVG.SVGEditor
 
-import iTasks.UI.JavaScript, iTasks.UI.Definition, iTasks.UI.Editor, iTasks.Internal.Serialization
+import iTasks.UI.Definition, iTasks.UI.Editor, iTasks.Internal.Serialization
 import Graphics.Scalable.Image
 import Graphics.Scalable.Internal.Image`
 import StdEnv
@@ -21,6 +21,7 @@ import Math.Geometry
 import Text
 import Text.GenJSON
 import Text.HTML
+import ABC.Interpreter.JavaScript
 
 import StdDebug
 trace_n` a b :== /*trace_n a*/ b

Libraries/iTasks/Extensions/ScaledEditor.icl

@@ -5,8 +5,8 @@ import Text.HTML, Text.GenJSON, Data.Error, Data.Func
 import iTasks.UI.Definition
 import iTasks.UI.Editor
 import iTasks.UI.Editor.Modifiers
-import iTasks.UI.JavaScript
 import iTasks.Internal.Serialization
+import ABC.Interpreter.JavaScript
 import qualified Data.Map as DM
 
 //Basic idea:

Libraries/iTasks/Internal/Serialization.icl

@@ -8,7 +8,7 @@ import Data.Error
 import Text.GenJSON
 import Data.Maybe
 
-import ABC.Interpreter
+import ABC.Interpreter.JavaScript
 
 import iTasks.Engine
 import iTasks.Internal.IWorld
@@ -53,5 +53,4 @@ dynamicJSONDecode _					= Nothing
 
 serializeForClient :: a !*VSt -> *(!String, !*VSt)
 serializeForClient graph vst=:{VSt| abcInterpreterEnv}
-	# serialized = serialize_for_prelinked_interpretation graph abcInterpreterEnv
-	= (base64Encode serialized, vst)
+	= (jsSerializeGraph graph abcInterpreterEnv, vst)

Libraries/iTasks/UI/Editor.dcl

@@ -4,9 +4,9 @@ definition module iTasks.UI.Editor
 * the interact core task uses these editors to generate and update the user interface
 */
 
-from ABC.Interpreter      import :: PrelinkedInterpretationEnvironment
+from ABC.Interpreter import :: PrelinkedInterpretationEnvironment
+from ABC.Interpreter.JavaScript import :: JSWorld, :: JSVal
 from iTasks.UI.Definition import :: UI, :: UIAttributes, :: UIChange, :: UIAttributeChange, :: TaskId
-from iTasks.UI.JavaScript import :: JSWorld, :: JSVal
 
 from iTasks.Internal.IWorld import :: IWorld
 from iTasks.Internal.Generic.Defaults import generic gDefault

Libraries/iTasks/UI/Editor.icl

@@ -4,10 +4,11 @@ import StdEnv
 import Data.Maybe, Data.Functor, Data.Tuple, Data.Func, Data.Error
 import iTasks.Internal.IWorld
 import iTasks.Internal.Serialization
-import iTasks.UI.Definition, iTasks.WF.Definition, iTasks.UI.JavaScript
+import iTasks.UI.Definition, iTasks.WF.Definition
 import qualified Data.Map as DM
 import Text, Text.GenJSON
 import Data.GenEq
+import ABC.Interpreter.JavaScript
 
 derive JSONEncode EditState, LeafState, EditMode
 derive JSONDecode EditState, LeafState, EditMode
@@ -153,7 +154,7 @@ withClientSideInit ::
 	!UIAttributes !DataPath !a !*VSt -> *(!MaybeErrorString (!UI, !st), !*VSt)
 withClientSideInit initUI genUI attr dp val vst=:{VSt| taskId} = case genUI attr dp val vst of
 	(Ok (UI type attr items,mask),vst)
-		# (initUI, vst) = serializeForClient (wrapInitUIFunction initUI) vst
+		# (initUI, vst) = serializeForClient (wrapInitFunction initUI) vst
 		# extraAttr = 'DM'.fromList
 			[("taskId",  JSONString taskId)
 			,("editorId",JSONString (editorId dp))

Libraries/iTasks/UI/JavaScript.dcl

-definition module iTasks.UI.JavaScript
-
-/**
- * This module provides ways to interact with JavaScript. All these functions
- * are supposed to be used from within a function that is wrapped by
- * `wrapInitUIFunction` (or hence, `withClientSideInit` in `iTasks.UI.Editor`),
- * which ensures that they are run within the WebAssembly runtime in the
- * browser. It does not make sense to use these functions on the server.
- *
- * The argument to `wrapInitUIFunction` receives a reference to the JavaScript
- * iTasks component it is related to, which must be used to share Clean values
- * with JavaScript (where indicated in documentation below).
- *
- * The JavaScript interfacing with this module can be found in itasks-core.js
- * and itasks-abc-interpreter.js.
- */
-
-import StdGeneric
-from StdMaybe import :: Maybe
-from StdOverloaded import class toString
-from Text.GenJSON import :: JSONNode
-
-/**
- * All impure interfacing with JavaScript is handled through the `*JSWorld`, as
- * native impure functionality is threaded through `*World`. `JSWorld` is not
- * unique to be able to instantiate Monad (in `iTasks.UI.JavaScript.Monad`).
- * Because all functions using `JSWorld` use it in a unique way, sharing is
- * still prohibited.
- */
-:: JSWorld
-
-:: JSVal
-:: JSFun :== JSVal
-:: JSObj :== JSVal
-
-generic gToJS a :: !a -> JSVal
-derive gToJS Int, Bool, String, Real
-derive gToJS JSVal, Maybe, [], (,), (,,), (,,,), (,,,,), JSONNode
-derive gToJS PAIR, FIELD of {gfd_name}, RECORD
-toJS x :== gToJS{|*|} x
-
-/**
- * Store a Clean value in the JavaScript heap. The value must be associated to
- * an iTasks component (typically given by `wrapInitUIFunction`). When the
- * iTasks component is destroyed, the value may eventually be garbage
- * collected. The value can be retrieved using `jsGetCleanReference`.
- * @param Any Clean value.
- * @param A reference to an iTasks component.
- * @result A JavaScript reference to the Clean value.
- */
-jsMakeCleanReference :: a !JSVal !*JSWorld -> *(!JSVal, !*JSWorld)
-
-/**
- * Retrieve a Clean value from the JavaScript heap. The value must have been
- * shared using `jsMakeCleanReference`.
- */
-jsGetCleanReference :: !JSVal !*JSWorld -> *(!Maybe b, !*JSWorld)
-
-/**
- * Remove a Clean value from the JavaScript heap. The value must have been
- * shared using `jsMakeCleanReference` or `jsWrapFun`.
- */
-jsFreeCleanReference :: !JSVal !*JSWorld -> *JSWorld
-
-jsTypeOf :: !JSVal -> JSVal
-
-jsIsUndefined :: !JSVal -> Bool
-jsIsNull :: !JSVal -> Bool
-
-jsValToInt :: !JSVal -> Maybe Int
-jsValToBool :: !JSVal -> Maybe Bool
-jsValToString :: !JSVal -> Maybe String
-jsValToReal :: !JSVal -> Maybe Real
-
-jsValToInt` :: !Int !JSVal -> Int
-jsValToBool` :: !Bool !JSVal -> Bool
-jsValToString` :: !String !JSVal -> String
-jsValToReal` :: !Real !JSVal -> Real
-
-/**
- * Retrieve a JavaScript iterable as a Clean list.
- * @param The JavaScript iterable.
- * @param The function to retrieve elements, called on every element of the
- *   iterable.
- * @result `Nothing` if the value is not iterable (has no `length` property) or
- *   if any of the elements could not be retrieved; otherwise `Just` with a
- *   list of the retrieved values.
- */
-jsValToList :: !JSVal !(JSVal -> Maybe a) !*JSWorld -> *(!Maybe [a], !*JSWorld)
-
-/**
- * Retrieve a JavaScript iterable as a Clean list.
- * @param The JavaScript iterable.
- * @param The function to retrieve elements, called on every element of the
- *   iterable.
- * @result A list of the retrieved values. If the JavaScript value is not
- *   iterable (has no `length` property), the empty list is returned.
- */
-jsValToList` :: !JSVal !(JSVal -> a) !*JSWorld -> *(![a], !*JSWorld)
-
-/**
- * Access properties of a JavaScript value.
- */
-class (.#) infixl 3 attr :: !JSVal !attr -> JSVal
-
-instance .# String // object access; may contain dots
-instance .# Int // array access
-
-/**
- * Retrieve a JavaScript value. This can be useful if the argument contains
- * computations which need to be shared among further usages of the result:
- *
- * ```
- * // object is a JavaScript object with a property 'prop' which requires computation
- * # (result,world) = object .# "prop" .? world
- * // continue to use result, so that object.prop is only evaluated once
- * ```
- *
- * However, if the argument does not contain computations, one can use a simple
- * Clean let: `# result = object .# "prop"`.
- *
- * @param The value to retrieve.
- * @result The retrieved value.
- */
-(.?) infixl 1 :: !JSVal !*JSWorld -> *(!JSVal, !*JSWorld)
-
-/**
- * Set a JavaScript value to another value.
- * @param The value to set.
- * @param The new value.
- */
-(.=) infixl 1 :: !JSVal !b !*JSWorld -> *JSWorld | gToJS{|*|} b
-
-/**
- * This is an internal class representing types which can be sent as function
- * arguments to JavaScript:
- *
- * - `Int`, `Bool`, and `String` map to their JavaScript equivalents
- * - `JSVal` requires no conversion
- * - `Maybe a` uses the conversion for the underlying type for `Just`, otherwise `null`
- * - `()` relates to no arguments; tuples relates to lists of arguments
- */
-class toJSArgs a :: !a -> {!JSVal}
-instance toJSArgs Int, Bool, String, JSVal, [a] | gToJS{|*|} a, (Maybe a) | gToJS{|*|} a, ()
-instance toJSArgs (a,b) | gToJS{|*|} a & gToJS{|*|} b
-instance toJSArgs (a,b,c) | gToJS{|*|} a & gToJS{|*|} b & gToJS{|*|} c
-instance toJSArgs (a,b,c,d) | gToJS{|*|} a & gToJS{|*|} b & gToJS{|*|} c & gToJS{|*|} d
-instance toJSArgs (a,b,c,d,e) | gToJS{|*|} a & gToJS{|*|} b & gToJS{|*|} c & gToJS{|*|} d & gToJS{|*|} e
-instance toJSArgs (a,b,c,d,e,f) | gToJS{|*|} a & gToJS{|*|} b & gToJS{|*|} c & gToJS{|*|} d & gToJS{|*|} e & gToJS{|*|} f
-
-/**
- * Call a JavaScript function and return the result.
- */
-(.$) infixl 2 :: !JSFun !b !*JSWorld -> *(!JSVal, !*JSWorld) | toJSArgs b
-
-/**
- * Call a JavaScript function and discard the result.
- */
-(.$!) infixl 2 :: !JSFun !b !*JSWorld -> *JSWorld | toJSArgs b
-
-/**
- * Use the JavaScript `new` keyword to create a new object.
- * @param The constructor name.
- * @param The constructor arguments.
- * @result The new object.
- */
-jsNew :: !String !a !*JSWorld -> *(!JSVal, !*JSWorld) | toJSArgs a
-
-/**
- * Create an empty JavaScript object (`{}`).
- */
-jsEmptyObject :: !*JSWorld -> *(!JSVal, !*JSWorld)
-
-/**
- * Delete a JavaScript value with the `delete` keyword.
- */
-jsDelete :: !JSVal !*JSWorld -> *JSWorld
-
-/**
- * Lift a String to a JavaScript value using the global address space.
- */
-jsGlobal :: !String -> JSVal
-
-jsNull :== jsGlobal "null"
-jsThis :== jsGlobal "this"
-jsWindow :== jsGlobal "window"
-jsDocument :== jsGlobal "document"
-
-/**
- * Wrap a function for use in JavaScript. This allows it to be used as the
- * callback for events and the like. The function must be associated to an
- * iTasks component (typically given by `wrapInitUIFunction`). When the iTasks
- * component is destroyed, the function may eventually be garbage collected.
- * @param The function to wrap. When called, it receives the JavaScript
- *   arguments as an array in its first parameter.
- * @param The iTasks component to link the function to.
- * @result A reference to the shared function.
- */
-jsWrapFun :: !({!JSVal} *JSWorld -> *JSWorld) !JSVal !*JSWorld -> *(!JSFun, !*JSWorld)
-
-/**
- * Like {{`jsWrapFun`}}, but the Clean function can return a result.
- */
-jsWrapFunWithResult :: !({!JSVal} *JSWorld -> *(JSVal, *JSWorld)) !JSVal !*JSWorld -> *(!JSFun, !*JSWorld)
-
-/**
- * Wrap a function receiving a reference to a JavaScript iTasks component to
- * one matching the calling convention for the JavaScript interface (i.e.,
- * receiving an array of JavaScript values) so that it can be called using the
- * `initUI` step from `itasks-core.js`. Internally, this also sets up part of
- * the WebAssembly backend. The first argument to the wrapped function is a
- * reference to an iTasks component which can be used in `jsWrapFun` and
- * `jsMakeCleanReference`.
- */
-wrapInitUIFunction :: !(JSVal *JSWorld -> *JSWorld) -> {!JSVal} -> *JSWorld -> *JSWorld
-
-/**
- * Deserialize a graph that was serialized using the tools in
- * `iTasks.Internal.Client.Serialization`.
- * @param The string to deserialize in base64 encoding.
- * @result The deserialized value.
- */
-jsDeserializeGraph :: !*String !*JSWorld -> *(!.a, !*JSWorld)
-
-/**
- * Load external CSS stylesheet by its URL.
- * @param The URL.
- */
-addCSSFromUrl :: !String !*JSWorld -> *JSWorld
-
-/**
- * Load an external JavaScript file by its URL.
- * @param The URL.
- * @param An optional callback function for when the script has loaded.
- */
-addJSFromUrl :: !String !(Maybe JSFun) !*JSWorld -> *JSWorld
-
-/**
- * A simple wrapper around JavaScript's `console.log`.
- * Use {{`jsTraceVal`}} to trace JavaScript values.
- * @param The value to log.
- * @param The value to return.
- */
-jsTrace :: !a .b -> .b | toString a
-
-/**
- * A simple wrapper around JavaScript's `console.log`.
- * Use {{`jsTrace`}} to trace Clean values.
- * @param The value to log.
- * @param The value to return.
- */
-jsTraceVal :: !JSVal .a -> .a

Libraries/iTasks/UI/JavaScript.icl

-implementation module iTasks.UI.JavaScript
-
-import qualified StdArray
-import StdEnv
-import StdGeneric
-import StdOverloadedList
-
-import Data.Func
-import Data.Maybe
-import Text.Encodings.Base64
-import Text.GenJSON
-
-:: JSWorld = JSWorld
-
-:: JSVal
-	= JSInt !Int
-	| JSBool !Bool
-	| JSString !String
-	| JSReal !Real
-
-	| JSVar !String
-	| JSNull
-	| JSUndefined
-	| JSTypeOf !JSVal
-	| JSDelete !JSVal // actually a statement, not an expression
-
-	| JSObject !{#JSObjectElement}
-	| JSArray !{!JSVal}
-
-	| JSCall !JSVal !{!JSVal}
-	| JSNew !String !{!JSVal}
-
-	| JSSel !JSVal !JSVal // x[y]
-	| JSSelPath !JSVal !String // x.path1.path2...pathn
-
-	| JSRef !Int // a reference to js
-	| JSCleanRef !Int // a reference to shared_clean_values
-
-	| JSTempPair !JSVal !JSVal
-	| JSTempField !String !JSVal
-
-	| JSUnused // used as always-False pattern match; see comments on abort_with_node.
-
-:: JSObjectElement =
-	{ key :: !String
-	, val :: !JSVal
-	}
-
-js_val_to_string :: !JSVal -> .String
-js_val_to_string v
-#! v = hyperstrict v
-#! (s,i) = copy v ('StdArray'._createArray (len v 0)) 0
-| i < 0
-	= abort_with_node v
-	= s
-where
-	copy :: !JSVal !*{#Char} !Int -> (!.{#Char}, !Int)
-	copy v dest i = case v of
-		JSInt n
-			-> copy_int n dest i
-		JSBool True
-			# dest & [i]='t',[i+1]='r',[i+2]='u',[i+3]='e'
-			-> (dest,i+4)
-		JSBool False
-			# dest & [i]='f',[i+1]='a',[i+2]='l',[i+3]='s',[i+4]='e'
-			-> (dest,i+5)
-		JSString s
-			# dest & [i] = '\''
-			# (dest,i) = copy_and_escape s 0 dest (i+1)
-			# dest & [i] = '\''
-			-> (dest,i+1)
-		JSReal r
-			// NB: this will trigger a warning in get_clean_string because the created String cannot be removed from the heap.
-			// Better would be to write a copy_real à la copy_int, but this is non-trivial.
-			// Another option is to walk the JSVal in JavaScript instead of creating a string.
-			-> copy_chars (toString r) dest i
-
-		JSVar v
-			-> copy_chars v dest i
-		JSNull
-			# dest & [i]='n',[i+1]='u',[i+2]='l',[i+3]='l'
-			-> (dest,i+4)
-		JSUndefined
-			# dest & [i]='u',[i+1]='n',[i+2]='d',[i+3]='e',[i+4]='f',[i+5]='i',[i+6]='n',[i+7]='e',[i+8]='d'
-			-> (dest,i+9)
-		JSTypeOf v
-			# dest & [i]='t',[i+1]='y',[i+2]='p',[i+3]='e',[i+4]='o',[i+5]='f',[i+6]=' '
-			-> copy v dest (i+7)
-		JSDelete v
-			# dest & [i]='d',[i+1]='e',[i+2]='l',[i+3]='e',[i+4]='t',[i+5]='e',[i+6]=' '
-			-> copy v dest (i+7)
-
-		JSObject elems
-			# dest & [i]='{'
-			| size elems==0
-				# dest & [i+1]='}'
-				-> (dest,i+2)
-			# (dest,i) = copy_elems elems 0 dest (i+1)
-			# dest & [i]='}'
-			-> (dest,i+1)
-			with
-				copy_elems :: !{#JSObjectElement} !Int !*{#Char} !Int -> (!.{#Char}, !Int)
-				copy_elems elems k dest i
-				# dest & [i]='"'
-				# {key,val} = elems.[k]
-				# (dest,i) = copy_chars key dest (i+1)
-				# dest & [i]='"'
-				# dest & [i+1]=':'
-				# (dest,i) = copy val dest (i+2)
-				| k+1>=size elems
-					= (dest,i)
-					= copy_elems elems (k+1) {dest & [i]=','} (i+1)
-		JSArray elems
-			# dest & [i]='['
-			| size elems==0
-				# dest & [i+1]=']'
-				-> (dest,i+2)
-			# (dest,i) = copy_with_commas elems 0 dest (i+1)
-			# dest & [i]=']'
-			-> (dest,i+1)
-		JSCall fun args
-			# (dest,i) = copy fun dest i
-			# dest & [i]='('
-			| size args==0
-				# dest & [i+1]=')'
-				-> (dest,i+2)
-			# (dest,i) = copy_with_commas args 0 dest (i+1)
-			# dest & [i]=')'
-			-> (dest,i+1)
-		JSNew cons args
-			# dest & [i]='n',[i+1]='e',[i+2]='w',[i+3]=' '
-			# (dest,i) = copy_chars cons dest (i+4)
-			# dest & [i]='('
-			| size args==0
-				# dest & [i+1]=')'
-				-> (dest,i+2)
-			# (dest,i) = copy_with_commas args 0 dest (i+1)
-			# dest & [i]=')'
-			-> (dest,i+1)
-
-		JSSel obj attr
-			# (dest,i) = copy obj dest i
-			# dest & [i]='['
-			# (dest,i) = copy attr dest (i+1)
-			# dest & [i]=']'
-			-> (dest,i+1)
-		JSSelPath obj path
-			# (dest,i) = copy obj dest i
-			# dest & [i]='.'
-			-> copy_chars path dest (i+1)
-
-		JSRef n
-			# dest & [i]='A',[i+1]='B',[i+2]='C',[i+3]='.',[i+4]='j',[i+5]='s',[i+6]='['
-			# (dest,i) = copy_int n dest (i+7)
-			# dest & [i]=']'
-			-> (dest,i+1)
-		JSCleanRef n
-			# dest & [i]='A',[i+1]='B',[i+2]='C',[i+3]='.',[i+4]='a',[i+5]='p',[i+6]='('
-			# (dest,i) = copy_int n dest (i+7)
-			# dest & [i]=')'
-			-> (dest,i+1)
-	where