Generate a secret key for the TOTP algorithm to use. Returns a 16 byte random buffer.

Takes a map with the parameters to be converted to a QR code or base64 encoded for Authy or Google Authenticator, etc.

Valid keys are:

Takes the TOTP secret and the code entered by the user, and validates the code

Returns the name of the (OS specific) directory where 8th stores data; this is almost the same as app:datadir , but is always the ".8th" directory.

Read an "asset", which is a resource bundled with the application. Returns a buffer containing the resource content. The parameter s refers to a "relative path". That path is relative to where the script or application appdata is located. So if the script is in src/app.8th then the asset "image/a.png" is in "src/image/a.png". For a compiled application, the appdata is created with bin/build .

given a map opt, arrange to launch the indicated application at a specific time. the keys in the map are: "exe" - a string which is the name of the executable to run (required); "args" - an array of strings which has the command-line arguments to the application; "when" - a date which indicates the time at which the application should be run (required); "dir" - the directory where the exe should run (not effective on linux/rpi).

Given a map opt, arrange to launch the indicated application at a specific time. The keys in the map are: "exe" - a string which is the name of the executable to run (required); "args" - an array of strings which has the command-line arguments to the application; "when" - a date which indicates the time at which the application should be run (required); "dir" - the directory where the exe should run (not effective on Linux/RPI).

given a map, arrange to launch the indicated application at a specific time. The keys in the map are:

• exe: string which is the name of the executable to run (required)
• args: array of strings which has the command-line arguments to the exe
• when: date which indicates the time at which the application should be run (required)
• dir: string directory where the exe should run (not effective on linux/rpi).

Requires "atd" be installed and running.

Returns a string which is the name of the (OS specific) application-accessible directory.

Returns the name of the executable 8th is named as. "8th" , unless compiled as a standalone program.

Given a base-name, return the OS-specific path to a "private" configuration file It is the result of app:privdir plus the base-name you give.

Launches a system-defined browser to the canonical 8th "current" page, with your user id and version of 8th. Will give you the option to refresh your build if you like.

Returns the OS specific name of the directory where this application stores data.

Invoked when the primary monitor has moved or changes position with another monitor. n is the index of the affected display.

Returns a string which is the running executable's full path name.

Invoked when the user changes the system locale. After this message is received, you can get the new current locale using os:lang and os:region , or all the user's chosen locales with os:locales .

Invoked if the OS is running low on memory. Free up resources if you can.

If you define a word with this name, your application will start there. Otherwise, the default version will run, which just invokes G:cold and the REPL.

A var which contains the name of the current application. The default value is "8th", so you probably want to change it, e.g. "myappname" app:name ! .

Invoked when the "back button" is pressed (Android only). The default d: behavior invokes bye .

If the application crashed, this word is invoked with a message.

Stores the value x under the key s for retrieval by app:opts@ .

Returns the value v stored in the key s by app:opts! . Values are application-global, and are typically used to pass information to libraries upon loading. Ex: G:help uses the "help.width" key.

Invoked (on mobile devices) when the device orientation has changed. n is 1 for 'upright', 2 for 'upside down', 3 for 'rotated clockwise' and 4 for 'rotated anti-clockwise'.

On mobile devices (Android only for the moment) sets the permitted orientation: 1 for 'upright', 2 for 'upside down', 3 for 'rotated clockwise' and 4 for 'rotated anti-clockwise'.

Returns the application's OS-specific process-id.

For non-mobile applications only. Invoked just after app:main exits.

For non-mobile applications only. Invoked prior to app:main .

Returns the os-specific "private dir" (e.g. "/etc/" on POSIX systems)

Sends ("raises") the given signal to the app. If it's a number, that signal number is raised; if it's a string, then the signal of that name is raised. Only signals which 8th traps by default can be named.

Ex: "USR1" app:raise works, but "KILL" app:raise does not.

Given the config-file base-name, return a buffer containing the contents of the file (or null, if there's nothing there)

Given the config-file base-name, return a map with values in the JSON formatted map in that file. Returns an empty map if the file does not contain one.

Given the config-file base-name, and the name of a variable (a key in the map therein), return the value of the key.

ANDROID: request the OS-specific permission (e.g. "android.permission.RECORD_AUDIO"). Returns true if the permission was granted.

Restarts the application from the beginning, launching a new process.

Mobile only. Invoked when the application is about to be resumed. TOS is true if app has been resumed, false if preparing to resume. Take care of restoring application state here, saved during app:suspended .

Invoked when the OS signal s has been received. Traps SIGINT, SIGTERM, and SIGABRT on all platforms. On other than Windows, it also traps SIGHUP, SIGUSR1, and SIGUSR2. The signal name is passed in s (e.g. "INT"). For signals trapped using app:trap and which are unknown to 8th, the numeric value of the signal is converted to a string and passed in. The default behavior is to print the name of the signal received and quit. A signal handler is not guaranteed to be invoked in any particular task, so be careful!

A var which holds the value true if the app is running as a built, standalone, application. It is false otherwise.

Sets app:standalone . If true , w:forget s words which are security risks. The build utility inserts true app:standalone! in built applications.

Returns the name of the subdirectory of the (OS specific) directory where 8th stores data. s may or may not exist on the system, this word simply returns a composed name.

Mobile only. Invoked when the application is about to be suspended. TOS is true if the app has been suspended, false if preparing to suspend. Take care of saving application state here, in preparation for app:resumed .

Invoked if the system requests that the application shut down. The default simply returns true , which means "quit". If you do not want to allow the system to close the application, you should return false instead.

Note: denying the OS doesn't mean you will succeed...

Invoked if the OS is terminating the application for some reason.

Gets the number of 'ticks' the app has been running, since the app was loaded.

Creates a background task which waits for n seconds before invoking app:timed-out (which does nothing, by default) and then invoking 1 die .

Tell 8th to trap the signal whose number is n (this will be OS-specific). If T is true, the signal should be trapped; otherwise, it should be ignored. The deferred word app:signal will be invoked if the signal is intercepted. The acceptable values of n are OS-specific.

Put the item x in the array at index ix . If the index is larger than the largest current index, the array will be resized and any empty spots created will be filled with null . If ix is negative, then the element at the index from the end of the array will be modified. For example, an index of "-1" will modify the last element.

Append contents of array a2 to a1 , modifying a1 .

Remove the item at index ix from the array a , moving other items over to fill the gap: a is modified. If you just want to remove an item from the array without changing the position of other elements, simply store null in the position of the item you want to remove. If ix is less than 0 the item that far from the end of the array is removed.

Splits an existing array into two parts at the index. If the index is less than 0, splits at that index from the end of the array. If given a word , then that word determines which array (a1 or a2) to split the item to. In that case the SED of the word must be ix x -- T where it returns true for a1 , or false for a2 .

Iterates over two arrays, invoking w for each corresponding element in them. w 's SED is: n x1 x2 -- ; that is, it is passed both the index of the items and the items themselves. The arrays are not available on the stack while it is running, to avoid consistency problems. w must consume its inputs. Will stop iterating on break or once the shorter of the two inputs is exhausted. Obeys G:step .

NOTE: You must not modify the array being iterated, while it is being iterated! Modifying the array while it is being iterated may throw an exception.

Similar to a:map , but takes two arrays and invokes w on the corresponding elements of them. If the arrays are not of equal size, will stop after processing the shorter one; thus, the result will be of the same length as the shorter of the two inputs.

Similar to a:2map , but takes additional parameters:

• n1 : the number of items of a to pass in each time
• n2 : number of items to advance before creating the next slice

The SED of w is a3 a4 -- x , where a3 is an n1 sized slice of a1 , and a4 of a2 .

By default, the initial slice index increments by 1 each iteration; by using step (inside w ) you can make that any value you wish. The result is a new array with the values returned by w on each iteration.

Ex: [1,2,3,4] [10,20,30,40] ( 2 a:close ) 2 1 a:2map+ yields: [[[1,2],[10,20]],[[2,3],[20,30]],[[3,4],[30,40]]]

Same as a:2map , but modifies the original array.

Swaps the array items at those indices. Ex: [10,20,30] 1 2 a:<> returns [10,30,20] .

Compares the two arrays using the word w to compare each item. The SED for w is: x1 x2 -- T , where T is true if the items are equal, otherwise false. Arrays must have equal length to be considered equal, and each compared element must have the same type.

Returns the item in the array at index ix . If ix is negative, get the item from the end of the array, e.g. "-1" corresponds to the last element. If ix is out of bounds, null is returned (though null might also be a valid element! Use a:exists? to distinguish). If the index is an array of numbers, returns another array with values corresponding to the indices in a1 .

Same as a:@ , but if the item at that index doesn't exist, supplies the default value x . If x is an array, then if ix is also an array, the value returned will be from the corresponding element of the x array (last element used for all corresponding elements beyond the original's bounds).

Same as a:! , but if the index n doesn't exist or is not an array, a new array is created, the existing value if any is pushed to it, and the new value is pushed into it. Basically, accumulates values to the index.

Ex: [10,20,30] 1 21 a:[]! results in [10,[20,21],30]

Same as a:@ , but removes the array from the stack.

Iterates the array, invoking w on each one. If all of the items return true from w then returns true; otherwise returns false. Short-circuits on first 'false' result.

Iterates the array, invoking w on each one. If any of the items returns true from w then returns true; otherwise returns false. Short-circuits on first 'true' result.

Search for the item x in a sorted array, using the comparison word w (which was used for the sort!), whose SED is: x1 x2 -- n , where n is a negative number if the first item is less than the second, 0 if they're equal, and positive if the first is greater than the second.

Returns the index of the matching item, or null if there was no match.

Note: The array must have been sorted in ascending order using the same comparator w in order for this to work correctly!

Given an array of points, where each point is an array of x,y coordinates, return an array which consists of the centroids of those points. May be any dimension as long as each point is the same dimension.

Remove all elements from the array. Similar to repeatedly invoking a:pop drop .

Create an array from n items on the stack. This is the inverse of a:open . If n is 0 or negative, will only consume TOS (e.g. n ).

Compare two arrays. Similar to 'a:=', but given a comparator word (like s:cmp or n:cmp) The first non-equal element terminates the comparison, and 'n' is the result of the comparator on that element. Result 'n' is 0 if arrays compare 'equal', '-1' if a1 is 'less'

Removes from a1 all elements which are in a2 . The w word should return true if the items are equal.

Generalized "dot product" of the two arrays a1 and a2 . If they are not the same length, returns null . Otherwise, invokes the word w1 on each corresponding item in each array, and then invokes the word w2 on each pair of results, accumulating them into a result x . Ex: [1,2] [3,4] ' n:* ' n:+ a:dot results in the number 11.

Iterate over the array, invoking w for each element in it. The SED of w is ix x -- , where ix is the index of the item x in the array.

While running, the array is not available on the stack, to avoid consistency problems. w must consume both items.

NOTE: You must not modify the array being iterated, while it is being iterated! Modifying the array while it is being iterated may throw an exception.

Same as a:each , but only passes the item, omitting the index, to the word. The SED of w is x -- .

NOTE: You must not modify the array being iterated, while it is being iterated! Modifying the array while it is being iterated may throw an exception.

Splits the array into n sub-arrays and invokes a:each! on each of them in a separate task, then recombines them.

Split array arr into slices of size sz elements, and feed each slice to the word wrd. That callback gets the stack slicenumber slice on its stack.

Returns true if there is a value defined for the given index in the array. This is necessary because requesting an arbitrary index from an array will always succeed, returning null if the index does not exist as well as if the value stored is actually null . If the index is negative, it is taken as that many from the end.

Creates an array, whose elements are those from the initial array for which the word w returns true . The SED of w is x -- T , where x is each element of a in turn. It must consume each item it is given.

While this word is running, the original array is not on the stack so it is possible to access items which were under it.

Splits the array into n sub-arrays and invokes a:filter on each of them in a separate task, then recombines them.

Loops over the numeric range [n1, n2] , invoking w on each number. The result in TOS is pushed onto the resultant array.

If given only a word, then that word is invoked repeatedly with a SED of n -- x where n is the current index (starting at 0) and x is what TOS is after w is invoked. The repetition stops after break is invoked.

Group elements in an array, creating a map whose values are arrays containing items with the same grouping. The word used to group the items takes an array element and returns an item which is the group to which that element belongs, SED x -- s .

Search for the item x in the array, using the comparison word w , whose SED is: x1 x2 -- T . It takes two items of the given type and returns true if they match, or false otherwise.

Returns the index of the matching item, or null if there was no match.

Create a new array by inserting the contents of array a2 into the array a1 at offset ix . If the offset is negative, it means "from the end of the array". If ix is greater than the current number of items in a1 , the missing items will be null .

Produces the "intersection" of two arrays over the comparator word. The resultant array contains only those values common to the input arrays (without duplication).

Inverse of s:/ . Joins an array of strings, inserting the string sep between each pair of items; return new string s .

Returns the length of the array, e.g. the highest index occupied plus 1 (indices start at 0). The actual number of items contained may be less than the array's length, because one can insert an item at any index (subject to system memory constraints).

Same as a:len but does not leave the array on the stack.

Given two arrays, returns their respective lengths. Much faster and more efficient than the hard way.

Creates an array, whose elements are formed by executing the word w for each element of the original array. The SED of w is x -- x' , where x' may be the same as x . The mapping must consume the element given, producing a single result on TOS, which becomes the corresponding element in the new array.

While this word is running, the original array is not on the stack so it is possible to access items which were under it.

Similar to a:map , but takes additional parameters:

• n1 : the number of items of a to pass in each time
• n2 is the number of items to advance before creating the next slice

The SED of w is a -- x , where a is an n1 sized array slice of the original array. By default, the initial slice index increments by 1 each iteration; by using step (inside w ) you can make that any value you wish.

Splits the array into n sub-arrays and invokes a:map on each of them in a separate task, then recombines them.

Same as a:map , but modifies the original array.

Returns the maximum (character) length of an array of strings

Calculate the mean (average) value of an array of numbers. Should be faster than a:mean&variance if all you need is the arithmetic mean

Uses the Knuth variance algorithm to calculate mean and variance in one pass. Returns an array containing [sample variance, mean, count, population variance, stddev]

Combines the two arrays as in a 'merge sort', using the given word as a comparator. If the arrays are not already sorted, garbage will result.

Create a new, empty array.

Invokes w on the array contents at the specified index, replacing the current contents. Any operands to w should appear in their normal stack order under w .

"Open up" the contents of the array a , spilling it onto the stack. Faster and more clear than manually unpacking the array. Be careful not to overflow the stack! Useful for example after using G:unpack so you can access the data easily. Pair with a:close (you need to add back the length in TOS for that to work).

Performs a 'pigeonhole operation', meaning that x is compared using w to successive (ascending, ordered) values in a2 . The index of the item which is "greater" than x is used to look-up a value in a1 . Ex:

["red", "blue", "green"] [10,20] 15 ' n:cmp a:pigeon

returns "blue", since 15 is between 10 and 20.

"Pivots" the array. If it consists of arrays (all the same length) like [[x1,x2,...], [y1,y2,...]] then the pivot creates a new array [[x1,y1,...], [x2,y2,...]] . The length of the largest array element is taken to be the length of all elements (and null will be in the pivot for items not in smaller arrays). If any of the elements of a is not itself an array, returns null .

Pop the item x from the array; that is, from the highest index in the array. If the array was empty, returns null .

Note: Since it is possible that null was actually stored in the array, use a:exists? to remove ambiguity.

Push the item x onto the array. The array will expand as needed. After the push, x will occupy the highest index in the array.

The order may be either a x or x a . If x is itself an array, then you must use the order a x in order to achieve the desired result.

Same effect as a:push drop but more efficient.

Sorts the array using the "quicksort" algorithm and the comparison word w .

The SED of w is: x1 x2 -- n , where n is 0 if the items are equal, positive if x1 ≥ x2 , negative otherwise.

Note: If the comparison function modifies the elements it is given, they will be modified in the original array! It is typically slower than a:sort ; as well as not being a stable sort, but is uses less memory.

Same as a:each , but iterates the array in a random order. Because of that, it does not obey step .

NOTE: You must not modify the array while it is being iterated!

Iterate over the array, invoking w for each element in a with the accumulated value.

The SED of w is x elem -- x' , where elem is an element in a , and x is the accumulated value so far, starting with x .

While running, the original array is not on the stack.

Ex: [1,2,3] ' n:+ 0 a:reduce sums the array giving 6.

Same as a:reduce , but takes additional parameters:

• n1 : the number of items of a to pass in each time
• n2 : the number of items to advance before creating the next slice

As with a:map+ , invoking step (inside w ) will make it advance by step items. The SED of w is x a -- x' , where a is an array with n1 items from the original, and x is the accumulated value so-far.

Ex: [1,2,3,4,5,6] ( a:open n:* n:+ ) 0 2 1 a:reduce+ gives '70', which is 1*2 + 2*3 + 3*4 + 4*5 + 5*6 .

[1,2,3,4,5,6] ( a:open n:* n:+ ) 0 2 2 a:reduce+ gives '50', which is 1*3 + 2*4 + 3*5 + 4*6 .

Removes all instances of the item x from the array. Returns the number of instances found and removed.

Given an array, modifies it so the elements are in reverse order.

Same as a:indexof , but searches from the end of the array.

Removes the item x from the first position in the array (e.g. a[0] ) and puts it on TOS. This makes the array one element shorter, and shifts all remaining elements one lower. Like a:pop but from the start of the array.

Randomly shuffles the entries in the array Uses rand-pcg , so it is not cryptographically random.

Returns a slice of the array a beginning at index ix for n items. A negative value of ix means "take from the end of the array". If ix+n is greater than the number of items in a (starting from ix ), then the slice will be only as large as the number of items available in a . A negative value of n means "take the rest of the array".

Same was a:slice but also takes a "step" amount, which is how many items to advance before creating next slice.

Ex: [0,1,2,3,4] 1 -1 2 a:slice+ returns [1,3]

Puts x in the first position in the array (e.g. a[0] ), moving all remaining items up one index. Like a:push but at the beginning of the array.

Smears the last item in the array, duplicating it to fill the array up to n items. Ex: [1,2,3] 5 a:smear results in [1,2,3,3,3] .

Sorts the array using the "timsort" algorithm and the comparison word w . Exactly the same as a:qsort , but uses a stable sort instead.

The SED of w is: x1 x2 -- n , where n is 0 if the items are equal, positive if x1 ≥ x2 , negative otherwise.

Note: If the comparison function modifies the elements it is given, they will be modified in the original array! This sort is generally faster than a:qsort , but uses more memory.

Splits the array into one containing n equal sub-arrays. So [1,2,3,4] 2 a:split results in [[1,2],[3,4]] . If the number of items in a doesn't split evenly, the last entry in a' will have all the rest. If n is greater than the number of items in the array (or is less than 0) it is clamped to the number of items in the array.

Reduces an "array of arrays" to a array whose contents are the contents of the arrays. Ex: [[1],[20]] a:squash returns [1,20] . If an item in the array is not itself an array, it is simply placed as-is.

Swaps the items at the given array indices.

Creates an array a3 which is the union of two arrays over the comparator word. That means that the result contains all values in both inputs, excluding duplicates.

Removes consecutive equal elements of the array. w should return true if the items are equal. Assumes the input array is sorted.

Inverse of a:zip . Takes an array like [[1,2], [3,4]] and produces [1,3,2,4] . Iterates over all the sub-arrays in the original, and creates a new array containing the corresponding elements of each sub-array, in the order given.

Given an array containing pairs of words, it invokes the first word in each pair. If that word evaluates to true , then the second word is invoked. If none of the elements evaluates to true , then if there is a last (unpaired) item it is invoked.

Same as a:when , but invokes all words whose matching first part evaluates to true .

Same as a:x-each , but returns an array with the results from the processing. So w 's SED is n1 n2 x1 x2 -- x3 , where x3 is put in the resultant array. Modifying the arrays while it being iterated may throw an exception.

Iterate over two arrays, invoking w for all elements in them. The effect is to invoke w on every pair of items in the two inputs. w 's SED is: n1 n2 x1 x2 -- ; that is, it is passed the indices of both items, and the items themselves. The arrays are not available on the stack while it is running, to avoid consistency problems. w must consume its inputs. Will stop iterating on break or when all items have been iterated.

NOTE: You must not modify the array being iterated, while it is being iterated! Modifying the array while it is being iterated may throw an exception.

Stores a new value in the array at index ix , placing the current value on TOS. A negative index means "from the end of the array".

Given an array and a word whose SED is x1 x2 -- x3 , produces another array which is the result of applying w to consecutive elements of it. This will result in an array one element shorter than the input. If the input has fewer than two elements, a clone will be returned and w will not be invoked.

Takes two arrays, and "zips" them together (think like a "zipper" on clothing), producing a new array for each corresponding item in the first two. Ex: [1,2,3] [3,4,5] a:zip produce [1,3] [2,4] [3,5] . If the arrays are not of equal size, stops after processing the shorter one. Thus the number of resultant arrays will the minimum of the lengths of the two inputs.

Note: be careful not to use this on very long arrays or you may overflow the stack!

var with dawn angle of sun, v. Default is -7.

Do dawn calculation.

Do dusk calculation.

Do sunrise/sunset calculation (this is the default).

var with dusk angle of sun, degrees below horizon. Default is -7.

var with latitude coordinate of location (default is Jerusalem: 31.778). North is positive, south is negative.

Takes a location map from the geo/location and sets current latitude and longitude.

var with longitude coordinate of location (default is Jerusalem: 35.235). East is positive, west is negative.

For the given date d, return rise, set times. Assumes the location has been set already.

Return a pair of keys to be used for session authentication

Return a buffer which is the DH shared-secret of the keys

Return a random 16 character string (12 bytes of random data). This string is intended to identify the session from amongst a multitude of sessions over the channel. Save

Return a random session-key. A key is a cryptographically random buffer which can be used for encrypting the communications channel. The key should not be stored permanently.

With one party's public key and the other party's private key, validate that the 'key' is the result of 'auth:secret'

Set the given word as the callback for AWS:cmd to use (if the cb was null ; otherwise, use the cb given). The default callback sets the value returned by AWS:rc , which will contain the last return code from any AWS command. If you do multi-task AWS operations, this is probably not sufficient.

Set the aws CLI command string. The default is just aws , but you may need to provide a full path name.

Execute the given command and options, asynchronously shelling the aws CLI utility (which you must have installed on your system)

Issue the AWS CLI cp command to copy files to and from your AWS bucket.

Returns the last return-code returned from an AWS operation (unless you used AWS:cb , in which case it's on you).

Create a new block containing the string or buffer data item x and add it to the given chain

Prints the blocks in the given blockchain

Internal word which adds the given block to the chain. You will use bc:+block instead

Calculates the hash for the given block, assuming the values it contains are correct

Given a chain and a number block index, return the block. Return null if there is no such block. In future will accept the hash

Returns the first, or "genesis" block for the chain. NOTE: currently, all genesis blocks are identical

A global var which contains the name of the hash to be used. By default, this is 'blake'. NOTE: if you are using blockchains and you also need to use other hash algos, you should either make certain to save and restore the hash in your non-blockchain code, or ensure the blockchain code runs on a separate task (e.g. thread)

Returns the last block in the chain

Loads a BC_MEM blockchain from a file, where it was saved previously with bc:save

Sets the hash to use and initializes the blockchain. Returns a new and empty blockchain to use. The blockchain is set initially to be "in-memory". NOTE: a blockchain should not be shared between tasks, since the hash algo it sets is task-specific

For a BC_MEM blockchain, saves it to a file, so it may be restored with bc:load

Sets the chain to be a BC_SQL chain. If file-name doesn't exist, a new SQL file is created and the chain initialised. Otherwise, the chain is loaded from the file. If the file exists but is not a valid SQL file or doesn't contain a valid chain, false is returned on TOS; otherwise, true is returned.

Validate that the entire chain is valid

Validate that the block's hash is valid, and that its prior hash is the previous block's hash

Adds the string value to the Bloom filter

Create a new Bloom filter, which can have up to size items, using #hash different hashes.

Checks if the string value is in the Bloom filter. If it returns false, the value is definitely not in the filter. Otherwise, depending on the filter parameters, it is probably in it.

Given a bt created with bt:listen , waits for a connection to be created. When it is, returns bt2 which can be used with bt:read and bt:write . Returns null if there was an error.

Writes a BLE characteristic identified by the string uuid in the service identified by the string svcuuid on the BT connection given in bt . The buffer will be written; you must ensure that it contains data appropriate for the service and characteristic. Returns true if it succeeded initiating the write, false otherwise.

NOTE: Currently unimplemented as of 20.01

Reads a BLE characteristic identified by the string uuid in the service identified by the string svcuuid on the BT connection given in bt . A buffer will be returned (or null if it was unable to read).

NOTE: Currently unimplemented as of 20.01

Given a map representing information about a BT device, as returned from bt:scan , returns a new bt which may be used with bt:read and bt:write . If it fails to connect, returns null .

Additional keys in m may be:

• "l2cap": optional; if true use L2CAP protocol, otherwise use RFCOMM (the default)
• "port" - a number defining the port to use
• "uuid" - a string containing the UUID of the service to connect to

Given a bt returned from bt:connect or bt:leconnect , disconnect the connection (if the bt is currently connected).

Ensures the Bluetooth system is running; returns false if not.

Given a map returned from bt:lescan , returns a new bt which may be used with bt:read and bt:write . If it fails to connect, returns null .

Scans for nearby Bluetooth Low Energy (BLE) devices. w is invoked for any devices found. Its SED is: m -- T , where m has information about the device found, and the return value is true to continue scanning or false to stop scanning.

The scan will continue as long as any devices were found within n seconds. If no devices were found within n seconds, the scan will cease and w will be invoked with a parameter of null . w is invoked on a separate task (thread) and should not do more than save the information and set a flag or similar.

Given a map defining what service to bind to and listen on etc., returns a new bt item which may be used with bt:accept . If it fails to connect, returns null .

The keys in m are:

• "l2cap" - optional; if true use L2CAP protocol, otherwise use RFCOMM (default RFCOMM)
• "port" - a number defining the port to use
• "uuid" - a string containing the UUID of the service to publish

Returns true if the Bluetooth system of the machine is on, false otherwise.

Same as f:read but for a bt connection.

Scans for nearby Bluetooth (BT) devices for n seconds. The word w is invoked for each device found, and has the SED: m -- T , where m is a map with the device information. It is passed null when the scan is done. It must return true to continue scanning, or false to terminate the scan.

The map passed to w for each device will contain the keys "id" and "name", where "id" is the 48-bit identifier and "name" is the friendly name given the device by its owner.

Scans the BT device with string identifier s (as returned from bt:scan ) for services using the string UUID (or null for all services). Returns an array of service descriptors or null if none are available.

Takes a bt returned from bt:leconnect representing a BLE peripheral, and invokes w for each service the peripheral advertises. n is a timeout value in seconds for the service scan to complete.

Implemented on Android, iOS, and macOS.

Same as f:write but for a bt connection.

Parse a buffer of BSON data, invoking the callback w after each document (map or array). The SED of w is x -- T where x is a map or array parsed from the BSON (as a "document"), and the return value is true to continue or false to stop. If there is an error in parsing, null is passed to the callback, and t:err? explains the problem.

Put the byte n at offset ix in the buffer. If you wish to modify the original buffer, you must invoke b:writable on it first.

Appends the buffer b2 to the buffer b1 yielding a new buffer.

Split the buffer b at n , returning a two-element array [head, tail] . If n is negative, splits b from the end rather than at the start.

If an array of numbers a1 is given, then it returns an array containing buffers which represent the original b split at the sizes (not offsets) indicated. Ex: splitting a buffer with 20 bytes using [1,2] will give a three-element array with the first byte, then the next two bytes, with the remainder of 7 bytes in the last element.

Add 1 to the byte at offset ix in the buffer. Modifies b , so it must be writable.

Subtract 1 from the byte at offset ix in the buffer. Modifies b , so it must be writable.

Swaps the bytes at those indices in the buffer. Does modify the original buffer! If you don't want to modify the original, take care to clone it first.

Compare the two buffers, returning true if they are byte-wise equal.

Takes a string or buffer and converts it to a RFC-4648 base16 encoded string

Takes a string or buffer and converts it to a RFC-4648 base32 encoded string

Encode buffer (or string) in base64 encoding.

Takes a string or buffer and converts it to a RFC-4648 base85 encoded string

Convert the 'hex dump' string into the bytes it represents.

Converts any 8th item to a buffer containing the equivalent MessagePack binary format. TOS is true if the conversion succeeded, false otherwise.

Returns the byte at offset ix in the buffer. Returns null if the offset is beyond the bounds of the buffer.

Appends the buffer or string b2 to the buffer b1 , modifying the original buffer.

Takes a string encoded in RFC-4648 base16 and returns a decoded buffer.

Takes a string encoded in RFC-4648 base32 and returns a decoded buffer.

Decode string s from base64 encoding into a buffer.

Takes a string encoded in RFC-4648 base85 and returns a decoded buffer.

Sets the value of the bit at the given index to n , where position 0 is the low bit of the first byte in the buffer. ix must be within the bounds of b . n is evaluated as 1 if true , or 0 otherwise.

Modifies b , so it must be writable!

Gets the value of the bit at the given index in the buffer, treating it as an array of bits. Position 0 is the low bit of the first byte. Returns null if n is beyond the bounds of b .

Overwrites the contents of the b with 0.

Note: this modifies the original buffer itself!

Exactly analogous to s:compress .

Converts the buffer from the character encoding from to to , returning a converted buffer. If it was unable to perform the conversion, returns an error code and null .

Note: Linux and RPI users must have installed the "libiconv" library for this to work. The errcode (if null was returned) is one of:

• 1 : no libiconv library
• 2 : unknown charset
• 3 : error converting text

Invokes w for each byte of the buffer. The SED of w is: ix n -- , where ix is the index of the byte in the buffer and n is the value of the byte at that index. The original buffer is not present on the stack while this word is running.

Same as b:each , but only passes the byte value, omitting the index item, to the word. The SED of w is: n -- .

Invokes w for each slice n bytes wide of the buffer. It is w 's responsibility to consume the buffer. The SED of w is: ix b -- , where the ix is the index of the slice in the b , and b is the slice of b at ix times n bytes in the original. Each slice is n wide, with the possible exception of the last one.

Exactly analogous to s:expand .

Fills the contents of the b with the Unicode character n , or fill it with the contents of the string or buffer sb starting at offset ix in b .

Note: if you want to modify the original buffer, you must use b:writeable to permit that; otherwise, a new buffer is created.

Read a single byte from the given buffer. If no byte is available, null is returned.

Converts a buffer into its "hex dump" representation.

Returns the length of the buffer in bytes.

DANGEROUS! Returns a buffer containing a copy of the contents of the memory at address n for size bytes.

Note: if you give an invalid memory address and/or size, you may cause 8th to crash. Also, if you allow arbitrary code to access this word, you open a security hole, so use "w:forget" or "G:only" if you allow arbitrary code to be evaluated.

Moves n bytes of the buf from src to dst . The original buf is modified!

By default, the mpack words add a compatibility tag to all future versions of 8th to unpack older versions. However, that means 8th's packing is not decipherable to third-party programs. To make the encoding acceptable to outsiders, pass true to this word.

If true , then the b:>mpack word will convert a date into the MessagePack date extension format. This loses timezone information, but is necessary if you interoperate with 3rd-party software using standard MessagePack. The default is false , which means that date information will round-trip correctly between 8th instances. This only affects serialization; b:mpack> will still deserialize date data sent in 8th format, as well as MessagePack format.

If true , the b:mpack> word will ignore any extended types it doesn't know about. The default is false , which causes an error on unknown extended types.

Converts a buffer containing MessagePack binary data into the appropriate 8th item. Returns true and the item if successful, or false and null on failure to convert.

Inverse of b:n@ . Stores the number n' at the byte-offset ix in the buffer. The bits value n is one of 1,2,4 or 8.

Modifies b , so requires the buffer be writable, otherwise does nothing.

Adds the number to the byte at offset ix in the buffer. Modifies b , so it must be writable.

Gets values from the buffer as numbers of byte-size n , a byte-offset ix . If T is true , treat the number as signed, otherwise unsigned. n must be one of '1', '2', '4', or '8'.

Ex: 2 2 true b:n@ will get a signed 16-bit number from byte-offset 2 in the buffer.

If the index+bittedness is out of range of the buffer, null is returned.

Create a new buffer. If x is a:

• number: create a buffer of size x bytes which is NOT initialized (use b:clear or b:fill to do that)
• string: create a buffer as big as the contents of the string, with a copy of the string's contents
• buffer: create a clone of the original one
• array of numbers: create a buffer containing the byte-values of the numbers in the array (one byte per number only).

Takes two buffers and invokes the word w for each byte of source , and a corresponding byte from key (modulo the size of key ). The resultant byte goes into the corresponding byte of b .

This can be used, for example, to perform an "xor" of a password against a block of data. The result is a buffer the same size as source .

The SED of w is: n1 n2 -- n3 , where n1 is a byte from source , and n2 is a corresponding byte from key .

Invokes w on the byte at offset ix in the buffer, which must be writable. The SED of w is n -- n , the resultant value is placed back in b at offset ix .

Pad the given buffer to a multiple of 'len' bytes, using the number of bytes as the filler. Always pads the buffer, even if it is already a multiple of 'len' Can only use a 'len' up to 0xFF

Reverses the order of bytes in a buffer.

Search the buffer haystack for the first occurrence of the string or regex or number needle , returning the numeric offset in the buffer of the found data, or null . If ofs is given it's a number of bytes to search from the start of the buffer. If needle is a number, the lowest byte of it is searched for (e.g. it's treated as a "uint8_t").

Returns a buffer containing "shared memory", given a string to use as an identifier for an IPC shared-memory object, a number specifying its size, and a boolean indicating if the memory should be read-only (if true ). Returns null if this was not possible.

Returns a slice of the buffer b1 , semantically the same as s:slice . b2 is a "slice" of b1 , beginning at offset ix for n bytes (not characters!). A negative value of n means "take the rest of the buffer".

Replaces a portion of the buffer b1 starting at offset ix with the contents of the buffer b2 . If b1 is writable, then b1 itself is modified and returned.

Take the given byte and "unget" it, so that the next b:getb will return it.

Undoes the padding done by b:pad. Do not use it on a buffer which was not padded!

Make the buffer writable if T is true . Normally, attempting to modify a buffer will return a modified clone of the original. This allows modifying the original. Use with caution!.

Applies a byte-wise XOR between every byte of the buffer and either the Unicode character or the buffer b2 . Repeats until every byte of the input buffer has been XORed.

Note: if the original buffer is writable, its contents are overwritten; otherwise, a new buffer is created.

Returns a string with the given Hebrew date.

Returns a string corresponding to the Islamic date given.

Prints the given Hebrew date.

Prints the Islamic date given.

Convert Gregorian year gy to Hebrew year hy.

Converts a date to a "Julian day number" as used in astronomy

Constant representing the twelvth Hebrew month.

Constant representing the thirteenth Hebrew month, in a leap year.

Constant representing the fifth Hebrew month.

Constant representing the sixth Hebrew month.

Constant representing the eighth Hebrew month.

Constant representing the second Hebrew month.

Constant representing the ninth Hebrew month.

Constant representing the first Hebrew month.

Constant representing the eleventh Hebrew month.

Constant representing the third Hebrew month.

Constant representing the fourth Hebrew month.

Constant representing the tenth Hebrew month.

Constant representing the seventh Hebrew month.

How many days are in the given year?.

A var which controls whether the Hebrew date displays in Hebrew or English. Defaults to false.

Converts the fixed-date into the Hebrew date.

Convert the given fixed-date to the Islamic date.

Inserts the Hebrew "gershayim" character (0x05f4) as appropriate for a Hebrew number.

Returns the fixed-date of the first day of Hanukkah in the given Hebrew year.

Fixed date corresponding to the beginning of AM (anno mundi, Hebrew year).

Return 1 if yr is a Hebrew leap year or 0 otherwise.

Convert the Hebrew month, day and year given into a "fixed date", a number.

Returns a the Hebrew date corresponding to today.

Returns a string containing the name of the Hebrew month given as a number. Returns Hebrew if d:displaying-hebrew is true.

Returns the fixed-date of the start of the Islamic epoch.

Convert the given Islamic date to a fixed-date.

Returns the Islamic date corresponding to today.

Converts a "Julian day number" as used in astronomy to a date

Returns the last day of the given month in a particular year. Either 29 or 30, takes into account the dehiyot etc.

Returns a string which is the traditional Hebrew number corresponding to the number given.

Returns the "count of the omer" for the specific fixed-date. If that date is outside the omer period, returns 0.

Returns the fixed-date of Passover in the given Hebrew year.

Returns the fixed-date of Purim in the given Hebrew year.

Returns true if the given fixed-date is "Rosh Chodesh".

Returns the fixed-date of Rosh Hashana in the given Hebrew year.

Returns the fixed-date of Shavuot in the given Hebrew year.

Returns the fixed-date of the Fast of Esther in the given Hebrew year.

Returns the fixed-date of the Fast of the Ninth of Av in the given Hebrew year.

Returns the fixed-date of the Israeli Independence Day in the given Hebrew year.

Returns the fixed-date of Yom Kippur in the given Hebrew year.

Returns the color converted from ARGB to HSVA as an array [hue,saturation,value,alpha].

Returns a color "complimentary" to the given one.

Returns the "distance" between two colors, a value between 0 and 1 where 0 means identical.

Returns a gradient of colors from x1 to x2, in n steps.

Inverse of clr:>hsva . Takes an array of HSVA and returns the RGBA value.

"inverts" the given color

Takes a color name or value, and returns the name of the color most nearly matching it from our internal list of colors.

Converts a color definition (number, string, or array of values) to an RGBA number value of the color.

Multiplies two complex numbers.

Returns the complex product of the two inputs.

Adds two complex numbers returning their complex sum.

Adds two complex numbers.

Compares two complex numbers and returns true if they are equal.

Compares two complex numbers, returning true if they are equal.

Returns the complex number in "polar form"

Returns the complex number in "polar form".

Returns the "real" and "imaginary" components of the complex number.

Returns the "real" and "imaginary" components of the complex number.

Raises the complex number c to the exponent n, analagous to n:^ .

Raises the complex number c to the exponent n, analagous to n:^ .

Returns a the absolute-value (e.g. magnitude) of the input.

Returns the absolute-value of the complex number.

Returns the "argument" (e.g. angle of the radius, in radians) of the input.

Returns the "argument" (the angle of the radius in radians) of the complex number.

Returns the "complex conjugate" of the input. If c is 1+2i, c' is 1-2i.

Returns the complex-conjugate of the complex number.

Returns a number which is the "imaginary" component of the complex number c.

Returns the imaginary component of the complex

Returns the "principal value" of the natural logarithm of c .

Returns the "principal value" of the natural logarithm of c .

Converts a number to a complex, e.g. creates a new complex number, n + 0i

Converts a number to the complex c, represented as "n+0i".

Create a new complex number based on native doubles (not regular 8th numbers). This is a faster implementation than the one in the "math/complex" library, but it does not allow unlimited precision.

The parameters are either two numbers or an array of two numbers, in the order "real, imag". The numbers given must fit into a native double or they will be truncated, with unpredictable results. May return null if inappropriate values are given.

From either a pair of numbers, or an array containing two numbers, returns a new complex representing "real + i * imag".

Returns the complex number determined by the "polar coordinates" n1 (abs(c)), and n2 (arg(c)).

Returns the complex number determined by the "polar coordinates" n1 (abs(c)), and n2 (arg(c)).

Returns a number which is the "real" component of the complex number c.

Returns the real component of the complex

Redirects console output (from "." etc) to a string

Requests a string of maximum length n from the console (a length of 0 implies maximum, which is 4096 characters). If desired, a history array of strings may be provided (or null if no history is needed). The same editing keys as with regular console input are allowed. Returns the entered string or null if Ctrl+C was pressed.

If false , con:accept will not print an initial newline. The default is true .

Same as con:accept , except it does not display the characters entered. Instead, it shows '*' for each character. The same editing keys are allowed as with con:accept .

Invoked from the 'con:accept' words if an 'alert' is required. The default does nothing.

Returns true if the console supports ANSI sequences. Only relevant on Windows.

Set the console foreground color to black. Must be paired with one of the con:on... color commands.

Set the console foreground color to blue. Must be paired with one of the con:on... color commands.

Clear the current console line from the current position until the end of the line.

Clear the console screen and put the cursor on the first row.

If T is true , make the REPL only quit on Ctrl+D if the input buffer is empty. The default is false , meaning always quit when Ctrl+D is pressed.

Set the console foreground color to cyan. Must be paired with one of the con:on... color commands.

Move the console position down one.

Restore console history from a file. If T is true , overwrites current history; otherwise, appends to it.

Closes the console window.

Note: Windows OS only.

Returns the position of the console cursor.

Set the console cursor position.

Set the console foreground color to green. Must be paired with one of the con:on... color commands.

Set the history handling word. Its SED is s -- . The default handler saves to the file given in con:history>file , and runs in the REPL task. You can do other things if you like

Save console history to the named file, one line per item. If null is given, stop saving history. If the file name cannot be created or opened, history will not be saved.

Returns true if the console subsystem could be initialized; otherwise returns false and sets t:err? .

Returns the key-code of a pressed key, waiting for a key to be pressed.

Returns true if con:key would return a value without blocking, false otherwise.

Move the console position left one.

Load the console's history from the array of strings. If T is true , overwrite the current history; otherwise, append the array's contents to the current history.

Set the console foreground color to magenta. Must be paired with one of the con:on... color commands.

Changes the default console history size from 100 to n . The maximum is 100000.

Set the console background color to black.

Set the console background color to blue.

Set the console background color to cyan.

Set the console background color to green.

Set the console background color to magenta.

Set the console background color to red.

Set the console background color to white.

Set the console background color to yellow.

Print the string to the console, taking into account console text attributes and positioning.

Set the console foreground color to red. Must be paired with one of the con:on... color commands.

Stops console redirection and returns the captured string

Returns true if the input is redirected (from a pipe for instance).

Move the console position right one.

If given word, it is a callback for saving history whose SED is s -- . If null , stop saving history.

History is not saved by default. This word causes the history to be saved from the point it is invoked with a word, until the point it is invoked with null .

The library console/history implements history saving in a more easy-to-use manner.

Returns the current size of the console in columns and rows.

Move the console position up one.

Set the console foreground color to white. Must be paired with one of the con:on... color commands.

Set the console foreground color to yellow. Must be paired with one of the con:on... color commands.

Encrypt the buffer or string item with the buffer or string key using AES-128-GCM. The key will be converted into an appropriate buffer using cr:ensurekey. The encrypted buffer buf is returned.

Encrypts sb using AES-256-GCM using the key sb2 returning a buffer which can be decrypted with cr:aes256gcm> . If sb2 is not a 32-byte buffer, it will be converted to one using cr:ensurekey .

Takes a string or buffer sb , and a string or buffer key sb2 , encrypts using Chacha20Poly1305, returns a buffer which can be decrypted with cr:cp> . If sb2 is not a 32-byte buffer, it will be converted to one using cr:ensurekey .

Encrypts the string or buffer using the key b with Chacha20Poly1305, signs with the private Ed25519 key b2 , then boxes it up in a buffer b3 . That can be given to cr:cpe> to verify and decrypt.

Given a buffer key containing an encryption key (see cr:genkey or cr:randkey ) and a string or buffer with encrypted data, begins decryption and returns a crypt which must be passed to further crypt words, or null if there was an error. In GCM or "chacha1305" modes, the iv, add, and tag are also required.

If a map is given, it has the same keys as for cr:>encrypt .

Creates a "box" from a string or buffer s and an Ed25519 private key b (created using cr:ed25519 ), containing a header and the signature for the item and key.

Given a buffer key containing an encryption key (see cr:genkey or cr:randkey ) and a string or buffer sb with data to encrypt, starts encryption and returns a crypt which must be passed to further crypt words, or null if there was an error.

In modes other than ECB, and for the "chacha" and "chacha1305" ciphers, a buffer iv must be given. In GCM mode or with the "chacha1305" cipher, a buffer aad may be given (or null must be passed, if no additional data is to be given). With the "chacha" cipher, the aad must be a number, used as a counter.

If a map is given, then its keys are as follows:

The callback words, if present, have the following SEDs:

• read: -- m b

Convert a number into a (64-bit) buffer of the binary digits.

Creates a box containing a head and signature from the string or buffer sb and an RSA private key b (created using 64 cr:rsa_genkey ).

Creates a UUID string from a 16-byte buffer.

Returns true if the current crypto settings accept "additional authentication data".

This is the encryption header, which identifies the 'box' as being AES128GCM. The last three numbers are "id", "IV size", and "tag length" (in AEAD suites).

Inverse of cr:>aes128gcm. Decrypt the buffer buf with the buffer or string key using AES-128-GCM. The key will be converted into an appropriate buffer using cr:ensurekey. The decrypted buffer item is returned and flag is true, if the decryption was successful. Otherwise, the original buffer is returned and false is on TOS.

Returns a buffer containing the correct 8-byte signature for an AES-256-GCM box.

Decrypts a buffer which was encrypted with cr:>aes256gcm , using the key buffer b2 . Returns null if the decryption failed.

Sets the encryption mode to GCM, the cipher to AES, and the GCM tag size to 16.

Sets the current hash to "blake".

Returns a buffer containing the correct 8-byte signature for a Chacha20Poly1305 box.

Sets the current encryption cipher to "Chacha20Poly1305".

Set the cipher to use in this task. The string may be any of the ones returned by cr:ciphers . Throws an exception if given an unknown cipher name. The default value is "aes256-gcm".

Returns the current cipher algorithm name, suitable for passing to cr:cipher! .

Returns an array of the names of all supported ciphers.

Decrypts a buffer which was encrypted with cr:>cp , and a buffer key b2 which was used to encrypt it. Returns a buffer with the clear-text, or null if the decryption failed.

Decrypts the buffer b created by cr:>cpe , using the key b2 and verifying with the public Ed25519 key b3 . If the decryption or verification fail, null is returned; otherwise, a buffer of plain-text is returned.

Shorthand for cr:>decrypt cr:decrypt> .

Given a crypt returned by cr:>decrypt , add the contents of the string or buffer and return the same crypt for further processing, or null if there was an error.

Given a crypt returned by cr:decrypt or cr:decrypt+ , finalize the decryption and return a buffer with the decrypted data or null if there was an error.

In GCM mode or chacha1305 cipher, returns the tag as well.

If callbacks were used, then the buffer returned on TOS will be an empty one (since the results will have been written using the callback).

Creates an encryption box signature buffer from a three-byte buffer.

Returns an array of maps containing "id" and "name" of all supported ECC curves.

Returns a binary encoded ECC key-pair corresponding to n , or null if there was an error.

NOTE: valid values of n are the id values returned from cr:ecc-curves . Values outside of them are not accepted.

Generates an ECC shared secret using one party's private ECC key, and the other party's public ECC key. The result is a buffer with the shared secret, or null if there was a problem.

Signs the hash using ECDSA algorithms with the private key and returns an signature buffer in sig . Returns null on error.

Verifies the hash signature versus the public key of the sender, using ECDSA algorithms and returns true on successful verification or false otherwise.

Generates an "ed25519" key-pair in two buffers, corresponding to the new private-key and public-key.

Generates an ed25519 shared secret using one party's private key priv , and the other party's public key pub . The result is a buffer which is the shared secret, or null if there was an error.

Given a buffer containing an ed25519 Diffie-Hellman private key of the sender, and another buffer containing a hash (could be a full message, but typically it's just a hash) of a message, signs the hash using DH algorithms and returns an signature buffer in sig or null if there was an error.

Given a buffer containing an ed25519 Diffie-Hellman public key (of the sender), another buffer containing a hash which was presumably signed by the sender, and another buffer containing the DH signature, verifies the hash signature using DH algorithms and returns true on successful verification or false otherwise.

Returns a buffer containing the correct 8-byte signature for a Chacha20Poly1305Ed25519 box.

Given an Ed25519 public key b , a string or buffer sb , and a "box" b2 which was created using cr:>edbox , verify that the signature is correct; returning true if it is.

Shorthand for cr:>encrypt cr:encrypt> .

Given the crypt cr returned by cr:encrypt , add the contents of the string or buffer and return the same crypt for further processing, or null if there was an error.

Given the crypt returned by cr:>encrypt or cr:encrypt+ , finalize the encryption and return a buffer b with the encrypted results or null if there was an error.

In GCM mode or if using "chacha1305", a buffer tag will also be returned, which is used to verify the decryption succeeded.

Ensures that a buffer of n bytes is created from the string (or non n-sized buffer). If it needs to create b , it will use the salt value "salty8thtears" and 10000 as parameters to cr:genkey . Otherwise, if sb is already a properly sized buffer, it will just past it on.

Takes the password string or buffer pwd , the string salt , the number of iterations iter and returns a PBKDF2 compliant key in a 32 byte buffer key , or null if there was an error.

Returns the hash of a string or buffer as a crypt, or null if there was an error. The specific hash algorithm to use is determined by cr:hash! , with "blake3" being the default hash. The hash being used is task-specific, so separate tasks may use different hash functions simultaneously without concern. See also: cr:hmac .

Set the hash to use in this task. The string may be any of the values returned by cr:hashes . The default value is "blake3".

Throws an exception if given an unknown hash name.

Take the string or buffer and add its data to the current hash in the crypt (returned from cr:hash or cr:hmac ). Returns the crypt it was given, or null if there was an error.

Finalize the hash calculation of crypt cr , and return the hash value as a binary buffer, or null if there was an error.

Finalize the hash calculation of crypt cr , returning the hash value as a readable string, or null if there was an error.

Returns the current hash algorithm name, suitable for passing to cr:hash! .

Returns an array of the names of all supported hashes.

Take the string or buffer and return a crypt cr which is its HMAC-hash using the key key (which may be a string or a buffer), or null if there was an error. The rest of its semantics are exactly the same as cr:hash .

Same as cr:totp, but uses an incrementing counter rather than the time.

Returns true if the current crypto settings require an "IV" (initialization vector).

Reads a PEM-encoded item. If given a string, reads from that named file. If given a buffer, the PEM data are in-memory. Returns a map with "name", "header", and "data"; or null if the read failed.

Takes strings 'name' and 'header' and 'filename', and a buffer; writes them in PEM format to the file. Returns true if successful, otherwise false .

Determines whether or not the given password meets the minimum requirements given in the map, which has numbers corresponding to cr:pwd/

Splits the given password string into components for analysis as to its fitness. The returned map has "uc", "lc", and "len", which are counts of number of uppercase, lowercase, and total string length. It will also have the count of characters by script, e.g. "number", "symbol", "latin", "cyrillic" etc (as per s:script? ).

Given a password string and a number indicating how many random bytes of salt to create, returns a random salt string as well as the salted hash of the password

Generate a 64-bit cryptographically-secure pseudo-random number using the "ChaCha20" generator. Much slower than the other PRNGs, but suitable for crypto work. Each task has its own PRNG.

Generate a buffer of size n filled with pseudo-random bytes from the cryptographically strong random source.

Returns a buffer containing a pseudo-random key for encryption, using a cryptographically strong random number generator, suitable for the currently chosen cipher.

Restores the crypto settings to what they were when cr:save was invoked.

A var which contains "root certificates" which you can give as the "rootcert" key of a net transaction

Decrypt the string or buffer sb using the RSA private-key b , putting the results in b , or null on error.

Encrypt the string or buffer sb with the RSA public key b , returning the encrypted data b . The RSA corresponding private key is required to decrypt.

Sign the hash of a message with the RSA private key , returning the signed buffer or null on error.

Verify the hash of a message with the RSA public key , against the RSA signature sig given by cr:rsa_sign . Returns true if the hash was verified, false otherwise.

Returns a buffer containing the correct 8-byte signature for a AES-256-GCM-RSA box.

Verifies that the signature box b2 created using cr:>rsabox is correct given the RSA public key b and a string or buffer sb , returning true if it is.

Generate an RSA key-pair of size n . Valid values of n are 1024, 2048 and 4096. Returns the DER encoded key-pair as two buffers priv and pub , or null if there was an error.

Returns an item encoding the current crypto settings. Use cr:restore to restore those settings.

Creates an "signature box signature" buffer from a three-byte buffer.

Returns the SHA1-HMAC hash of the buffer or string msg given the buffer key.

Uses Shamir Secret Sharing to split a string or buffer into n shards, of which any m may be used to recreate the original secret. Using fewer than m shards is guaranteed to provide insufficient information to recover any of the secret. Returns an array of buffers, each of which is a shard of the original secret. Returns null if there was an error. Use cr:unshard to recover the original s .

Returns true if the current crypto settings return a "tag" value under the encrypted data, or require a tag value for decryption. Currently, this is the same as cr:aad? , but may change as new cipher suites and modes are added.

Given a key *buffer, a number time, and a number #digits to return, returns a "Time-based One-Time Password".

A var containing the epoch to use for the TOTP. Defaults to 0.

A var containing the time-step to use for TOTP. Defaults to 30 seconds.

Recombines an array containing buffers of shards produced by cr:shard to form the original (as a buffer). Returns null if there was an error.

Note: un-sharding might not fail to produce a result, even if the number of shards given was incorrect, or if the shards were incorrect; the result will simply be incorrect (and have nothing to do with the secret which was processed by cr:shard ).

Returns a cryptographically strong random UUID (RFC 4122 compliant).

Returns a buffer 16 bytes long representing the given UUID, or null if the string is not in the correct format.

Takes a string fname which is a file whose PGP signature(s) are to be validated, and runs gpg --verify synchronously. It returns a number ok which is 0 if the signature is valid; otherwise, the gpg return code (-1 if gpg couldn't be launched). Requires 'gpg' be installed and in your PATH.

Validates the hash matches the password and salt as returned by cr:pwd>hash .

Factor of d:time which prints the time to a string

Add n whole days to the date d . It may be a negative number, in which case the days are subtracted from d .

Returns a date a certain mumber of days from the given date.

Returns a date a certain mumber of hours from the given date.

Returns a date a certain mumber of minutes from the given date.

Advances the date by n milliseconds. n may be negative, in which case the date is decreased.

Returns the difference n , in days (and fractions of a day), between the dates.

Print the number as HH:MM

Split the date into an array containing, in order: year, month, day, hour, minute, second, tzHH, tzMM (time-zone offset in hours and minutes from GMT), msec, and "approx" (if not zero, how uncertain the date is in days).

Returns true if the dates are equal. If the dates are "approximate", then they will be considered equal if their approximate regions overlap.

Returns the "fixed" time value corresponding to the date d .

Convert a millisecond value to a string like "1h 23m 5.678s". If x is a date, converts to msec first. Leaves off leading 0 values, e.g. if less than an hour, or minute.

Convert a millisecond value to a string like "1:23:05.678". If x is a date, converts to msec first. Leaves off leading 0 values, e.g. if less than an hour, or minute.

Returns the number of milliseconds since Jan 01 1970 corresponding to the date. It takes the TZ of the date into account, normalizing to UTC.

Returns the Unix time-stamp n corresponding to the date d .

Returns the year, month and day for a given date.

Return true if the dates d1 and d2 are approximately equal, based on a maximum day-difference of n. Takes into account if the date is approximate as well.

Returns the number corresponding to Friday.

Returns the number corresponding to Monday.

Returns the number corresponding to Saturday.

Returns the number corresponding to Sunday.

Returns the number corresponding to Thursday.

Returns the number corresponding to Tuesday.

Returns the number corresponding to Wednesday.

Adjusts the date d according to the number 0-6 of the dst-zone, n. See d:dst for the meaning of that number.

Set (if a map on TOS) or remove (if a date on TOS) an "alarm". The alarm will go off at or very close to the time requested (within a second). The map has the key word which is a word, or task which is a task to signal. A word will be invoked in the context of the alarm task, and must do its job quickly to avoid missing other alarms. Its SED is m -- , which is the map passed initially (so other data can be held inside) A task will have that map pushed to its queue, and then be signalled. In the even

Sets the uncertainty, in days, of the given date, modifying it.

Returns the uncertainty, in days, of the given date.

Set the regex to use for approximate date matches. Pass an array of strings each of which is indicates "approximate". Be careful to not use text which matches your localized month names.

Like n:between , but for dates. true if d2 ≤ d1 ≤ d3 .

Compare the two dates, similar to n:cmp . If d1 is chronologically before d2 , returns -1; 0 if the same, 1 if after. If either date is "approximate", then the comparison takes that into account and will consider them equal if their approximate regions overlap.

Format and print the given date in "YYYY-MM-DD" format.

If true (the default), makes d:parse and d:join assume "now" as current values for all missing fields; if false , 0 is assumed.

For a given date, return the day in the year (counting Jan 1 as '1').

Given a time-zone name and a date, returns the correct GMT offset in minutes for that date and tz

Determines if the date d is in DST (Daylight Savings Time) or not, in accordance with the number n of the dst-zone. The values are 0=OFF, 1=ON, 2=USA, 3=EU, 4=Israel, 5=Mexico, 6=Australia.

Queries the 'libs/date/dst.db' database for the DST information for the given string zone (e.g. "America/New_York") or its numeric code (e.g. zones.id) Returns an array consisting of arrays with the "code", "name", "abbrev", "time_start" (in unix timestamp), "gmt_offset", and "dst" indicator.

Queries the 'libs/date/dst.db' database for the DST information for the given string zone (e.g. "America/New_York") between the dates start and end. Returns an array consisting of arrays with the "code", "name", "abbrev", "time_start" (in unix timestamp), "gmt_offset", and "dst" indicator.

Returns an array of known country-time-zones for DST queries.

Returns the number of ticks since timer n was started.

Returns a string like "10h 23m 15.234s" if T is true , otherwise "10:23:15.234".

Returns the number of milliseconds since timer n was started.

Returns the number of seconds since timer n was started.

Returns a date for the first day-of-week in the month of the given date.

Returns a new date corresponding to the number which is a "fixed" time value. The range of valid n is 0..3652059, corresponding to 1-1-1 to 9999-12-31.

Returns the day-of-week (Sunday is 0) for a given date.

Format a date according to the format string s . If a "%" character appears, the following character is a format-specifier; otherwise, it is output directly.

Valid format specifiers are:

Inverse of d:/ : takes an array of numbers with year, month, day, hour, minute, second, tzHH, tzMM, msec, and approx, and returns a date.

If the array is shorter than 10 items, the missing items will be given default values from the current date and time.

Returns a date for the last day-of-week in the month of the given date.

Returns a date one month before the given date.

Returns a date one week before the given date.

Returns a date one year before the given date.

Returns true if the date is in a leap-year.

Returns the number of days in the date's month.

Returns the current time as number of milliseconds since Jan 01, 1970.

Returns a new date corresponding to the number of milliseconds since Jan 01 1970. It takes the current notion of timezone into account (that can be set using d:updatetz ).

Create a new date d , initialized with the current time.

Returns a date for the corresponding day-of-week on or after the given date.

Returns a date one month after the given date.

Returns a date one week after the given date.

Returns a date one year after the given date.

Attempt to parse a valid date and/or time from a string, and return the date appropriately set if successful, or null otherwise.

The string should be in one of the ISO-8601 formats or the RFC5322 format.

It may also be "UNK" or "UNKNOWN", which returns a date which is "unknown"; "NOW", "TODAY", or "CURRENT", which return the current date; or something like "Nov 1896", in which case it will return an approximate date with the month of November, the year of 1896, and whatever the current day of the month is.

The year must be less than 100 or greater than 1000; to create a date with a year of 150 (for example), use d:join .

Same as d:parse, but understands meaning of various "approximate" indicators like "ABT" or "CA". The list of words which is understood can be set using d::approximates!

Parse a "date range", e.g. "BET 2001 AND 2005"

Returns a date for the corresponding day-of-week on or before the given date.

Format a date as per RFC-5322

Starts a "high-resolution timer" accessed by the number n. Use d:elapsed-timer or d:elapsed-timer-seconds to read

Returns a number of "ticks", which is a "high-resolution" timing counter. The specific resolution can be retrieved using d:ticks/sec .

Returns the resolution in "ticks per second" of the "high-resolution" timer.

Establishes a timer running on a separate task, in accordance with the options in the map. Keys are:

Controls a timer returned from d:timer . The map keys may be "repeat", the number of seconds to repeat; or "stop" which stops the timer if true .

Applies a "time zone adjustment" of n minutes offset from GMT to the date, returning a new date with the given time-zone offset. Ex: convert current time to GMT: d:new 0 d:tzadjust

Or perhaps: "2019-06-23T12:00:00+02:00" d:parse 0 d:tzadjust . resulting in 2019-06-23T10:00:00+00:00 .

Returns a new date corresponding to the Unix time-stamp n .

Returns the singleton "unknown" date.

Returns true if the date is "unknown".

Sets the current time-zone offset in minutes from GMT. If n is null , refreshes the notion of the system's time-zone programmatically.

Returns the year from the given date d.

Format a given date as YYYY-MM-DD, returning a string.

Returns a date (at midnight) for a given year, month and day.

Invokes the SQL query without returning values.

Returns an array (possibly empty) of the results of the SQL query. The rows are returned as an array of the column values.

Returns an array (possibly empty) of the results of the SQL query. The rows are returned as a map of named column, value pairs.

Adds a new SQLite function implemented in 8th to the open database. The map may contain the following keys:

Consult the SQLite documentation for definitions and semantics of "window", "aggregate", and "scalar".

Returns true if the addition was successful. The "func" word receives an array of parameters from the SQL call. It is its responsibility to ensure the parameters are the correct type for whatever it's going to do. Whatever it leaves on TOS is the function result, but only number, string, buffer, and null are valid SQLite types. Anything else should be converted to a string first. More details in the manual.

If true , sets the SQLite cipher used for encrypted databases to AES+256+GCM. The default is Chacha20Poly1305, which is set if T is false .

(SQLite only) Returns true if the last action on the database returned a "busy" or "locked" status.

Equivalent of issuing the SQL "BEGIN TRANSACTION" for the database.

Bind parameters to the prepared SQL query in preparation for db:exec or db:exec-cb . The alternatives are:

• x is an item to bind to parameter number n
• a is an array of items to bind, in order the appear in the SQL statement
• m is a map whose keys correspond to named parameters

Combines bind and exec for a named sql. The s parameter is the name of a sql created previously with db:prep-name . x is an array or map of the parameters to bind to the sql. w is either null , or a word to invoke with each SQL result row as for db:exec-cb .

Like db:bind-exec , but returns an array of results from the SELECT statement. The results contain one array for each row of the result, as db:col[] is invoked on each row. An empty array is returned if no results were available, null is returned if there was an error.

Same as db:bind-exec[] , but returns one map for each row as db:col{} is invoked for each.

Close the database. It may not be read from or written to after this.

Used only inside a db:exec-cb callback! Returns the value of the query column n from the sql.

May be used only inside a db:exec-cb callback; retrieves all the columns of the query sql into an array, in the order they appear in the query.

May be used only inside a db:exec-cb callback; retrieves all the columns of the query into a map, where the keys are the column names.

Commits the transaction opened with db:begin , and returns true if the commit succeeded.

Returns the current database.

Opens the database file based on the string or map it's given. The opened database is pushed onto the list of open databases, and that database is accessible by number with db:use . The first database pushed is the default one, until db:use is invoked.

Closes the database #n and makes it unavailable.

Iterates over the keys in a KV database. The starting point is the key key (if null , starts from the beginning). s is the name of the database, as in the get/set words. fwd is true if the iteration order should be "forward", otherwise it's "backward". The word w is invoked with the SED: k v -- , and it can stop iteration by invoking break .

Note: the callback w must not change the database in any way!

Sets the error handler for the SQL words. If a SQL error occurs, it will be invoked with a SED of s -- . The default handler throws the string it's passed.

Execute the prepared statement sql , or the SQL string s on the database, running until finished.

Like db:exec , but invokes the word w as a callback for each row retrieved. The SED for w is sql -- . Use db:col within the callback to retrieve the column data. Note: you must adhere to the callback SED!

Same as db:exec-cb , but uses the sql stored under the name s in the db . If w is null , acts the same as db:exec , using the index or named sql. Note: you must adhere to the callback SED as per db:exec-cb !

Like db:bind-exec[] , but takes a SQL SELECT string (or prepared statement) without parameters.

Like db:bind-exec{} , but takes a SQL SELECT string (or prepared statement) without parameters.

Get the value associated with the give key in the "kv" database. The key may be anything, but a string is preferred. It must have the same value as what was used with db:set . The value is converted back from mpack format into whatever it originally was.

Same as db:get , but gets from the named sub-database.

Tells the SQLite engine it should use that key as the encryption key for the database. The database must have been created encrypted in order for this to work, and the key must exactly match the one used originally. The buffer given must be 32-bytes long, most likely created with cr:genkey from a password string entered by the user. Alternatively, you may pass the key in the 'key' key of the map given to db:open .

The key used can be changed using db:rekey .

Returns one of "SQLITE", "MYSQL", "ODBC", "SQLITE ENC", or "KV" for the open db.

Gets the last row-id inserted (specific to SQLite databases).

Returns true if MySQL support is currently available. If true , you may use the db words to access MySQL databases. This support is provided by a third-party library which must be installed separately from 8th, from here: https://dev.mysql.com/downloads/connector/c/ .

MySQL support is only available for Pro+, so this word will always report false on less capable SKUs.

Returns true if ODBC support is currently available, false otherwise. If true , you may use the db words to access an ODBC database.

On Linux/RPI you need to have installed unixodbc or iodbc. On macOS you need to have configured an ODBC source. On mobile devices there is no ODBC support at present.

ODBC support is only available on Pro+, so this word will always report false on less capable SKUs.

Open the SQLite (Pro+: MySQL/ODBC/KV) database indicated by the string, buffer, or map. If passed a:

If a map is passed, uses these keys to create a SQLite database (possibly encrypted):

Limits are some of:

Pro+: creates a MySQL, ODBC, or KV database using the map keys below:

Returns null if it was unable to open the database for some reason; otherwise returns a valid db.

Open a presumed SQLite file. Returns 0 if the file is invalid, 1 if it is empty, and 2 if it has been initialized

Same effect as db:prepare , but stores the query under the given name s in the db item. The stored sql will be null if there was an error creating it.

Prepare a SQL query from the string s , for execution against that database. Returns a sql, or null if there was an error.

Execute a query on the database db, and return the first row, as an array of items.

Execute a query on the database db, and return all rows, as an array of arrays of items.

Tell the SQLite engine it should use the new key as the encryption key for the database. If the database was not encrypted, it will be from now on; otherwise, it will be re-encrypted with the new key.

Note: a system failure (power outage etc) during the rekeying will likely corrupt the database and render it unusable. So operate on a copy of the database when rekeying!

Rolls back the transaction started with db:begin .

Puts a key-value pair into the database opened as type "kv". The key may be anything, but a string is preferred; the value can be anything. It is converted to a buffer using G:mpack before storing. Use db:get to retrieve the stored value. If null is stored, it deletes the (k,v) pair from the database. Thus, null cannot be stored (though the string "null" can).

Same as db:set , but sets to the named sub-database.

Retrieve the sql indicated by the string. The return value may be null , if db:prep-name failed or if no sql exists by the given name or index.

Same as SQL[ , but not "immediate-mode", so the SQL can be built at runtime.

Same as sql[] but takes no parameters for the SQL

Same as sql{} but takes no parameters for the SQL

Same as SQL{ , but not "immediate-mode", so the SQL can be built at runtime.

Makes the database #n the current one to access. Only necessary if more than one db:push has been invoked.

Add compress() and expand() SQL functions to the open database

Linux/RPI only: call the D-Bus interface as specified in the map, returns a string result The map keys are:

Note: the args array must have as its first element a string containing the D-Bus signature of each following argument. Follow the D-Bus documentation for details on what that means.

Linux/RPI only: connect to the D-Bus system. n is 0 for the login-session bus, 1 for the system bus, and 2 for the bus that started us, if any.

Prints the current task's state (for debugging only).

Set a breakpoint at the word w . This is a "one-shot" breakpoint, and gets reset once you do dbg:go .

Once dbg:stop puts you into the debug mode, invoking dbg:bt will show the backtrace of how you got where you are.

Returns the task from which the last exception was thrown, or null if there wasn't one. Resets the last-exception task to null .

Continue operation after dbg:stop or a breakpoint from dbg:bp .

Same as G:prompt but in "debug" mode.

Display the contents of an 8th word. Useful for debugging compilation issues.

Stops and enters an interpreter waiting for commands. Use dbg:go to continue.

Turns "tracing" on or off. If on, new words will include invocations of the words set by dbg:trace-enter and dbg:trace-leave .

If dbg:trace is on, invoke w upon entry to any compiled word. If w is null, turns off the trace. The word must consume TOS. The SED of w is w -- .

If dbg:trace is on, invoke w upon exit from any compiled word. If null, turns off the trace. The word must consume TOS. The SED of w is w -- .

Adds DOM2 as a child of DOM1 , and assigns DOM1 as the parent of DOM2 .

Removes DOM2 from the children of DOM1 , making DOM2 parentless.

Sets the attribute with that name in the DOM. If a map is given, it is added to the DOM attributes (per key,val).

Gets the attribute with that name from the DOM. Returns null if the attribute doesn't exist.

Returns the "attributes" of the DOM node, which may be null.

Gets an array (perhaps empty) containing the child nodes of the DOM.

Takes a string or buffer containing CSS, and parses it into a map which can be used by DOM:css-apply . Only understands a subset of CSS3 at the moment. Returns null on error.

Iterates the DOM, passing the word w each element in turn. Iteration is stopped with G:break , and will not go farther down the DOM than 'n' nodes.

The SED of w is DOM n -- , where 'n' is the current depth.

Similar to DOM:each , but the SED of w is dom n -- T , where true means keep this item, and 'n' is the depth of the item from the source DOM. The DOM nodes found are returned in an array.

Create a new DOM node, with the string "type", and DOM "parent" -- either or both may be null.

Returns the "type" of the DOM node, which may be null.

Separates the "path" s into an array [drive,path,filename,extension,separator] . Inverse of f:join .

Converts any Windows backslash \ characters in the string to POSIX forward / slashes.

Given a file or string containing a file name, returns a string containing the absolute path of the original file name.

Like f:abspath, but assumes x is relative to the path given by rel

Seek to the end of the file in preparation for appending to it.

"Associate" the application named app as the default for opening the file extension ext , with, a short description of desc and a long description of longdesc . The short description must not have spaces in it.

Note: only on Windows currently

Returns a time-stamp of when the file was last accessed.

Makes the file automatically delete itself when the program ends, or when the its refcount goes to 0.

Returns true if it is possible to write to the named file, or false otherwise. If the file does not exist, it determines whether or not the parent directory is writeable.

Change the access "mode" of the file to that indicated in the string or number. If the mode is a string, it can contain "r" = "readable", "w" = "writeable", "x" = "executable". By default, it only affects "owner-modes". To affect "group" modes, use 'g'; to affect 'other' modes, use 'o'; to affect all, use 'a'.

Ex: "o+x" will add execute permissions for 'others'. In order to apply to more than one you issue two separate stanzas, e.g. "o+xg+x". If a "+" is included then the modes are added to the existing one, if "-" they are removed, otherwise they are set exactly.

The file given may be an open file or a string with the name of a file. If the mode is a number, then that OS-specific mode will be set exactly without interpretation by 8th.

Close the file. I/O to that file will not be possible if, for example, a var stored f .

Try to copy the file named src to a new file named dest , which will be removed if it already exists. If dest is a directory, an appropriately named file will be created there. If the copy succeeds, true will be on TOS, otherwise false .

Try to recursively copy the directory named src to a new one named, dest . If the copy succeeds, true will be on TOS, otherwise false .

Create the file named by the string s , returning the file f .

Note: an existing file by the same name will be destroyed. If that is not your intention, use f:open instead.

Returns the 'creation' time of the file or string naming a file, as a date.

Returns true if the s represents a directory.

Returns the path of the filename, excluding the file name as returned by f:fname .

Similar to f:eachline , but passes a buffer of up to n bytes to the word w, whose SED is b -- . Responds to break .

NOTE: the same actual buffer is passed to w each time.

Similar to s:eachline , but leaves the file on TOS when done. The SED of w is s -- . Responds to break . If a string is passed rather than a file, it is assumed to be the name of a file, and the string is not left on TOS after running.

If the file cannot be read (or opened, if a string), t:err? will report an error.

NOTE: the same actual string is passed to w each time, so if you want to store the data you must clone it (or use const ).

Ensure that the file name given by the string ends with the OS-appropriate directory-separator. Use this instead of hard-coding "\" or "/".

Returns true if the file is at "end of file".

Attempts to execute the file as 8th code, unpacking and decrypting it if necessary. Throws on failure.

Returns true if the s represents a file or directory which exists.

Make sure any buffers containing unwritten data in the file are written.

Returns the last part (exclusive of path) of the filename.

Read a single byte from the given file. If no byte is available, null is returned.

Read a single Unicode character from the given file. If no character is available, null is returned.

Read one line from the file f . "line" means up to but not including a newline or carriage-return character ("\n" or "\r"). Returns null if no data are available (or trying to read past end-of-file).

Returns the OS-specific numeric "mode" of the file. See your OS documentation for the specific interpretation of the "mode". It may be given an open file or a string representing the name of a file.

Returns an array of file names matching the string pattern s . The "glob" pattern is not a regex but rather the usual "*" and "?" file matching.

If true , then f:rglob will descend into directories which are symbolic links. The default is to not do so.

If T is true , then make the f:glob word case-insensitive; otherwise it is case-sensitive.

The default for this setting is true on Windows and macOS, and false on all other systems.

"gzip -d" equivalent. Takes a read callback word to get buffers of data to decompress, and a write callback to write the decompressed data. Returns 0 on success, or a 'miniz' error code.

The SED for readcb is -- b ; if no more data is available, returns null . The SED for writecb is b -- .

Returns the home-directory for the current user

Sets the value returned by f:homedir . Useful if running as 'root' but not installed in the root directory.

Read the named file and interpret it as 8th code. Looks for the file in this order:

1. the file name as given, then
2. that name in the "incs" asset, then
3. in the app:datadir , then
4. in the directory pointed to by the EIGHTHLIB environment variable (if any), then finally
5. in app:8thdir .

Throws an exception if it cannot load the file.

(NOT Windows) Issues an ioctl system call on the given file or net (socket). The parameter req is a number indicating which ioctl call is to be performed, and x is either an integer number, a string, or a buffer, depending on the IOCTL call.

Returns a number and the value x' is of the same type as x .

Note: This is OS and ioctl-call specific. Use with caution!

If f isn't a file or a net, or if x is an invalid type, returns null. On ioctl error, sets t:err? return value.

Joins the array containing strings [drive,path,filename,extension,separator] into a file name. Inverse of f:/ . Returns null if any of the components is not a string or is missing.

Launches the named file. If it is executable, executes it; if it is a document, starts the appropriate application to open it; if it is a folder, displays it in the OS-specific folder viewer.

Give the parameter string params (may be null ) if needed.

On mobile devices this is the same as passing s to net:launch.

Makes a symbolic link named link , to the file named orig . Returns true on success, or false on failure.

Note: Only on macOS, Linux, and RPI.