Skip whitespace. This is a matching procedure.

Breadth-first walk of a connected graph (nodes are visited exactly once). Note that the graph can be a tree.

The second argument should be a function that, when given a node, generates the links from that node. If omitted, it defaults to:

     procedure defaultGenChildren(node)
        suspend !\node[2]
     end

Compute the current stack trace. Starting at level n above the current procedure. Here, n defaults to 0, which will include this procedure in the stack trace. ce defaults to ¤t. This only works with newer versions of Unicon!

deepcopy(A) produces a full copy of the structure A. All structures are handled, including all dags and cycylic graphs.

Given node represented by an indexable structure where the 2nd element is a list of links from that node, generate those links. Used as default in breadthwalk() and depthwalk().

Strip prefix from string s.

Strip suffix from string s.

Depth-first walk of a connected graph (nodes are visited exactly once). Note that the graph can be a tree.

The second argument should be a function that, when given a node, generates the links from that node. If omitted, it defaults to:

     procedure defaultGenChildren(node)
        suspend !\node[2]
     end

The third argument is used internally and should not be given by the user.

Produce a CVS-formatted string from a list of field values

Put a single field into legal CSV form.

A PDCO that produces only the even results from its argument. <[/p> First argument must be a co-expression.

Like find, but accepts a list of strings and finds them by their order of appearance in the subject string. The list of strings is searched in order. To locate the longest substring first, sort the list in reverse order, as in:

     findFirst(::reverse(::sort(a)))
 

Deprecated in favor of the FindFirst class.

 Add escape sequences to the subject.

 Convert an integer to a string.

 @param base   The desired base of the result.
 @param p      The minimum width of the result, padding with zeroes
 @             if necessary.

 Convert the subject integer into words, eg 231 to "Two Hundred and Thirty-One"

 Convert a numeric to a string.

 @param p  The number of decimal places to produce (default 4).
 @param f  A cset of flags.  If c contains {'e'} then the output is
 @         in scientific notation.  If c contains {','} then commas
 @         are introduced into the non-fractional part of the number;
 @         if c contains {'+'} then a leading + is added to positive
 @         numbers.
 @

 Convert a string to an integer.
 @param base  The base to use for the conversion (default is 16).

 Remove escape sequences from the subject.

Generate the fields from a CSV-encoded string. Fails on any field that isn't well-formed:

- fields with doubles quotes or embedded separators must be enclosed in double quotes
- double quotes in fields must be doubled: e.g. to embed "five", use ""five""
- leading and trailing whitespace (blanks and tabs) is stripped unless embedded inside a double-quoted field
- if blank and/or tab are used as separators, they are not considered whitespace
Also, any characters except double quotes and newlines may be used as separators.

Returns the field named s from the class instance c. The field is not dereferenced and thus can be assigned to.

Returns the method named s of the class instance c. The method is not dereferenced and thus can be assigned to. Methods of superclasses may be accessed by making s a period delimited list, for example getMethod(foo, "A.b") returns the method b of the superclass of type A that foo inherits from.

 Get the current time as a {Time} object
 @param z an optional {Timezone}.  If omitted, the system timezone is used.

 Utility to get next integer

 Convert a zone id into a Timezone

Shift all the characters in a string into characters outside of &ascii. This procedure is intended as aid when using hideEscapedChars() by making it easier to construct the third argument, as in:

    s := hideEscapedChars(s, s1, hideAllChars(s1))
 

Hide escaped instances of characters. Often, string scanning can be simplified if some characters are 'hidden' whenever they are escaped. (For example, consider running bal() on "(\))".) This procedure can be used to hide/unhide such escaped characters by converting them to other (typically in &cset--&ascii). Unhiding is accomplished by switching the second and third arguments.

The second and third parameters behave as in map(), except that s1 defaults to "(" and s2 defaults to a character string selected from &cset--&ascii. Note that accepting the defaults makes it more challenging to unhide the characters later!

The fourth parameter defaults to a backslash.

Probably doesn't work right when trying to hide escapes...

Initialize the random number seed to a 'random' value, so a different random sequence is generated on each run of the program. Meant to be called once, in procedure main(). . Unicon now initializes the seed by default, so this is largely moot.

 Initialize global data

Invert a table (will lose data unless tbl is a 1-1 mapping).

Succeed if string s ends in an odd number of escape characters. This is a specialty procedure - it's intended to simplify the task of determining if the 'next' character of the string that has s as a substring is escaped or not. If this procedure succeeds, that 'next' character is escaped and s is returned.

The second parameter defaults to a backslash, the traditional escape character.

This is not a scanning procedure, but is placed in this source file to avoid circular dependencies when building.

Pad a string on the left if it is too short. This method is similar to the function left except that lPad returns the original string if it is longer than the specified field, while left truncates the string to fit in the field.

Trim all characters in cs from the left edge of s. Same parameters and defaults as trim(s,cs).

Given two strings, produces the longest prefix they share in common.

Given two strings, produces the longest suffix they share in common.

Convert a list of strings into a single string. <[turns string formed by joining elements in a.

Generic binary operation across two matrices.

Swaps columns a and b of M

Additional optional arguments allow you to customize the operation by overriding various functions and constants used internally.

Creates a m x n matrix with ones on the diagonal and zeros everywhere else

Additional optional arguments allow you to customize the operation by overriding various functions and constants used internally.

Additional optional arguments allow you to customize the operation by overriding various functions and constants used internally.

The result is returned as a list [L, U, p] of matrices such that P*M = L*U, and p is a list representing the permutation to create P.

Additional optional arguments allow you to customize the operation by overriding various functions and constants used internally.

Additional optional arguments allow you to customize the operation by overriding various functions and constants used internally.

Swaps rows a and b of M

Generic unary operation across a matrix.

Output matrices.

A file argument changes output of subsequent arguments to that file (default is &output). String arguments are output as they appear. Matrices are output one row per line of output followed by a blank line.

Deprecated in favor of the MapBytes class

Do byte reorderings efficiently. Assumes that the length of string s is a multiple of the length of in. If this isn't the case, the remaining characters in s are appended unmapped.

The default action is the identity mapping

To work, in and out must be the same length.

Tabmatch a Unicon cset This is a matching procedure.

Tabmatch a Unicon string This is a matching procedure.

Tabmatch past a Unicon variable name. This is a matching procedure.

 Return the current time of day from the system clock, in milliseconds.

 Convert a month string to an month number, eg "feb"->2

A PDCO that wraps a result sequence sq and produces every nth result. n defaults to 1.

A PDCO that produces only the odd results from its argument. <[/p> First argument must be a co-expression

Produce a list of the fields from a CSV-formatted string.

 The classic quick sort procedure.

Pad a string on the right if it is too short. This method is similar to the function right except that rPad returns the original string if it is longer than the specified field, while right truncates the string to fit in the field.

Given a string and a table of strings (keys and entries), replaces occurrences of the table key values with the corresponding entry values. Finds longest sequence matching a key value.

replaceStrs is most useful in simple cases where you have only a few replacements to make on comparatively short text. For large numbers of replacements across a lot of text, the StringReplacer class is likely to faster.

Match strings the same way bal() matches characters. The input table is a tagged set of strings to match. The key is the start string while the value is the end string. This makes sure the start and stop strings are balanced w.r.t each other.

For example, given the table:

     t := table()
     t["begin"] := "end"

     if match("begin") then
        clause := sbal(t)

This is an unoptimized preliminary version that may contain bugs.

Similar to snapshot(), but displays only a portion of very long scan subjects. This is a (trivially) matching procedure.

A PDCO that wraps a result sequence sq and produces all results after the first n results. n defaults to 0.

Skip over n characters in subject string. This is similar to move(), but doesn't construct a substring.

Skip to a position in the subject string. This is similar to tab(), but doesn't construct a substring.

 Sleep for n milliseconds.  This is for backward compatibility;
 use the built-in function delay() instead.

Produce a 'snapshot' of string scanning showing the current scanning position. This is a (trivially) matching procedure.

Convert of string with (possibly) embedded separators into a list.

Tabmatch past the next unescaped character in cs Fails if no such unescaped character exists. This is a matching procedure.

Produce everything up to a substring and skip past that substring. This is a matching procedure. On success, the scanning position is left after the substring.

A PDCO that can be used to time expressions. (Only accurate to the millisecond level.)

Examples:

   write(" [",time { writes("fib(",n,") = ",fib(n)) }, "ms]" )

   write(" [", time { {every 1 to limit do {
                      f := fib(n)
                      }
                  writes("fib(",n,") = ",f, " run ",limit," times.")
                 }   # Note extra braces for compound expression!
               }
        , "ms]")

A PDCO that interleaves results from its arguments. For example, the following code produces a (very fast) 'spinner':

   every writes(weave{!|"-\\|/", !|"\b"})

Matches 0 or more whitespace characters (Cannot fail) This is a matching procedure.

Does string s start with prefix?

Does string s end in suffix?