| A | ||
|---|---|---|
| abs | n/a | integer.str |
| abspath | Return the absolute path of a pathname | file-abstractions.str |
| access | n/a | file.str |
| add | Adds two numbers (integer or real) | integer.str |
| add-extension | Adds an extension (second argument) to a path (first argument) | file.str |
| add-indices | Adds indices to the elements of a list | index.str |
| add-inf | n/a | integer.str |
| add-inf1 | n/a | integer.str |
| add-inf2 | n/a | integer.str |
| add-lists | Adds together multiple lists of numbers | integer.str |
| add-times | n/a | time.str |
| add2(ATerm scpid, ATerm tbl2, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| add2(ATerm scpid, ATerm tbl2, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| addi | Adds two integers | integer.str |
| addr | Adds two reals | integer.str |
| address | Give the address of a term | common.str |
| address-lt | Compare the address of two terms and succeeds if the address of the first is smaller than the address of the second | common.str |
| addS | n/a | integer.str |
| Alert(ATerm ) | n/a | log.str |
| align-center | n/a | string.str |
| align-helper(ATerm c, ATerm n) | n/a | string.str |
| align-left | n/a | string.str |
| align-right | n/a | string.str |
| all-dist(Strategy s) | n/a | environment.str |
| all-l(Strategy s) | n/a | list.str |
| all-l-dist(Strategy s) | n/a | list-environment.str |
| all-lines(Strategy s) | Applies a strategy to all lines in a string | string.str |
| alldownup2(Strategy s1, Strategy s2) | n/a | simple.str |
| alldownup2-l(Strategy s1, Strategy s2) | n/a | list.str |
| AllSignals | Table containing all signals | signal.str |
| alltd(Strategy s) | n/a | simple.str |
| alltd-fold(Strategy s1, Strategy s2) | n/a | simple.str |
| alltd-fold-l(Strategy s1, Strategy s2) | n/a | list.str |
| alltd-l(Strategy s) | n/a | list.str |
| and(Strategy s1, Strategy s2) | and(s1, s2) applies s1 and s2 to the current term and succeeds if both succeed | conditional.str |
| Anno(ATerm , ATerm ) | n/a | annotation.str |
| annotation | Primitives for getting and setting term annotations | annotation.str |
| apply(ATerm i) | n/a | index.str |
| apply-and-check(Strategy name, Strategy s, Strategy in-term, Strategy check) | n/a | sunit.str |
| apply-and-check(Strategy s, ATerm name, ATerm in-term, ATerm check) | n/a | sunit.str |
| apply-and-fail(Strategy name, Strategy s, Strategy in-term) | n/a | sunit.str |
| apply-and-fail(Strategy name, Strategy s, Strategy in-term, Strategy out) | n/a | sunit.str |
| apply-and-fail(Strategy s, ATerm name, ATerm in-term) | n/a | sunit.str |
| apply-and-fail(Strategy s, ATerm name, ATerm in-term, ATerm out) | n/a | sunit.str |
| apply-and-show(Strategy name, Strategy s, Strategy in-term) | n/a | sunit.str |
| apply-and-show(Strategy s, ATerm name, ATerm in-term) | n/a | sunit.str |
| apply-int-to-str-tuple(Strategy s) | n/a | integer.str |
| apply-rm-set(ATerm rmset) | n/a | dynamic-rules.str |
| apply-test(Strategy name, Strategy s, Strategy in-term, Strategy out) | n/a | sunit.str |
| apply-test(Strategy name, Strategy s, Strategy in-term) | n/a | sunit.str |
| apply-test(Strategy s, ATerm name, ATerm in-term, ATerm out) | n/a | sunit.str |
| apply-test(Strategy s, ATerm name, ATerm in-term) | n/a | sunit.str |
| April(ATerm ) | n/a | time.str |
| Arg2Option(Strategy is-flag, Strategy label) | n/a | parse-options.str |
| Arg2Option(Strategy is-flag, Strategy label, Strategy s) | n/a | parse-options.str |
| Arg2Option(Strategy is-flag, Strategy label, Strategy s) | n/a | parse-options.str |
| ArgOption(Strategy is-flag, Strategy label, Strategy s) | n/a | parse-options.str |
| ArgOption(Strategy is-flag, Strategy label) | n/a | parse-options.str |
| ArgOption(Strategy is-flag, Strategy label, Strategy s) | n/a | parse-options.str |
| ArgOption(Strategy is-flag, Strategy handlers, ATerm msg) | The handlers argument of this ArgOption variant must be an OptionHandler | parse-options.str |
| ArgOption(Strategy is-flag, Strategy handlers, ATerm msg) | Handle a special action, which is specified by a tuple | parse-options.str |
| assert(Strategy ns) | n/a | scoped-finite-map.str |
| at-depth(Strategy depth, Strategy s) | n/a | common.str |
| at-end(Strategy s) | Apply s to the Nil of a list | common.str |
| at-index(Strategy s) | Apply s at the specified index The first element has index 0 | index.str |
| at-index(Strategy s, ATerm i) | Apply s at the specified index i | index.str |
| at-index-tail(Strategy s, ATerm i) | Apply s to the list containing the elements from index i onwards from the original list | index.str |
| at-init(Strategy s1, Strategy s2) | Applies s1 to all elements in a list, except the last, where s2 is applied | common.str |
| at-last(Strategy s) | Apply s to the last Cons ([_]) of a list | common.str |
| at-suffix(Strategy s) | Apply a strategy to some suffix of a list | common.str |
| at-suffix-rev(Strategy s) | Apply a strategy to some suffix of a list | common.str |
| at-tail(Strategy s) | Apply a strategy to the tail of a list | common.str |
| atan2 | n/a | real.str |
| aterm-lib-options | Allow all flag starting with -at-* (these are ATerm library flags) | options.str |
| aterm-output-option | Option specifications for ATerm output | options.str |
| atmostonce(Strategy s) | n/a | collect.str |
| August(ATerm ) | n/a | time.str |
| average | Returns the average of all integers in a list of integers | integer.str |
| B | ||
| back-split-at(ATerm n) | Splits a list in two, with the second part containing the last n elements and and first part containing all elements except the last n | common.str |
| bag | This module contains strategies for handling bags | bag.str |
| bag-insert | Inserts a new element into a bag | bag.str |
| bag-insert(Strategy equ) | Inserts a new element into a bag | bag.str |
| bag-union | Takes the union of two bags | bag.str |
| bag-union(Strategy equ) | Takes the union of two bags | bag.str |
| base-filename | Strips the directory from a pathname | file.str |
| begin-scope(Strategy ns) | n/a | scoped-finite-map.str |
| bin-chars-to-int | n/a | integer.str |
| bin-string-to-int | n/a | integer.str |
| bottomup(Strategy s) | n/a | simple.str |
| bottomup-l(Strategy s) | n/a | list.str |
| bottomup-para(Strategy s) | A variation on bottomup is a traversal that also provides the original term as well as the term in which the direct subterms have been transformed | simple.str |
| bottomup-para-l(Strategy s) | n/a | list.str |
| bottomupS(Strategy s, Strategy stop) | n/a | simple.str |
| bottomupS-l(Strategy s, Strategy stop) | n/a | list.str |
| breadthfirst(Strategy s) | n/a | simple.str |
| BreakCS(ATerm , ATerm ) | n/a | dynamic-rules.str |
| bu-collect(Strategy s) | n/a | collect.str |
| C | ||
| call | Call a program with list of string arguments | process-abstractions.str |
| call(Strategy init-child) | n/a | process-abstractions.str |
| call(ATerm opt-fdin, ATerm opt-fdout, ATerm opt-fderr) | n/a | process-abstractions.str |
| call-noisy | Call program with a list of strings arguments and print information to stderr | process-abstractions.str |
| can-create-file | n/a | file-abstractions.str |
| can-execute-file | n/a | file-abstractions.str |
| can-read-file | n/a | file-abstractions.str |
| can-write-file | n/a | file-abstractions.str |
| cart(Strategy s) | Create the cartesian product of two lists, i | zip.str |
| case-char(Strategy s) | Applies a strategy to the upper-case variants of two characters | string.str |
| Catch(ATerm , ATerm ) | n/a | dynamic-rules.str |
| catch-annos | n/a | annotation.str |
| change1-no | n/a | common.str |
| change1-yes | n/a | common.str |
| change2-no | n/a | common.str |
| change2-yes | n/a | common.str |
| ChangeSet(ATerm , ATerm , ATerm ) | n/a | dynamic-rules.str |
| char | Character based in-/output | char.str |
| char-to-digit | n/a | integer.str |
| char-to-digit | n/a | integer.str |
| char-to-digit | n/a | integer.str |
| chdir | Change current working directory | file.str |
| check-for-failures | Internal: fails if there was a failure | sunit.str |
| checksum | Give checksum of a term | common.str |
| cify | n/a | string.str |
| clock | n/a | time.str |
| clock-to-seconds | n/a | time.str |
| close | Closing a file | file.str |
| close-filter-pipe(Strategy s) | n/a | pipe-abstractions.str |
| close-pipe | n/a | pipe-abstractions.str |
| coll(Strategy s) | n/a | environment.str |
| collect | Collecting subterms | collect.str |
| collect(Strategy s) | Synonym of collect-om | collect.str |
| collect(Strategy s, Strategy skip) | n/a | collect.str |
| collect-all(Strategy s) | collect all subterms for which s succeeds | collect.str |
| collect-all(Strategy s, Strategy un) | collect all subterms with user-defined union operator | collect.str |
| collect-all(Strategy s, Strategy un, Strategy reduce) | collect all subterms with user-defined union operator and a skip argument | collect.str |
| collect-exc(Strategy base, Strategy special) | n/a | collect.str |
| collect-om(Strategy s) | collect outermost subterms for which s succeeds | collect.str |
| collect-om(Strategy s, Strategy op) | collect outermost subterms with user-defined union operator | collect.str |
| collect-om(Strategy s, Strategy un, Strategy skip) | collect outermost subterms with user-defined union operator and a skip argument | collect.str |
| collect-one(Strategy s) | collect a single, outermost value from a tree | collect.str |
| collect-split(Strategy f, Strategy g) | Produces pair of a reduced term and a list of extracted subterms | collect.str |
| collect-split(Strategy splitter) | n/a | collect.str |
| collect-split'(Strategy splitter) | n/a | collect.str |
| CollectSplit(Strategy s, Strategy splitter) | Helper of collect-split | collect.str |
| CollectSplit(Strategy s, Strategy f, Strategy g) | Helper of collect-split | collect.str |
| common | Get and set values in the configuration table | common.str |
| common | Some primitives for the manipulation of terms | common.str |
| common | This module contains basic functionality for manipulating lists | common.str |
| common | n/a | common.str |
| common | n/a | common.str |
| common | This module defines generic strategies for packing a set of modules reachable from a root module and for flattening a set of modules into a single program | common.str |
| common-prefix | Returns the common prefix of two lists | common.str |
| comp-comp(Strategy s1, Strategy s2) | n/a | integer.str |
| ComponentTime(ATerm , ATerm , ATerm ) | n/a | time.str |
| conc | Concatenates all lists of a tuple | common.str |
| Conc(ATerm , ATerm ) | Concatenation of two lists | cons.str |
| conc-strings | Concats a tuple of two Strings | string.str |
| concat | Concatenates a list of lists into one list | common.str |
| concat-strings | Concats a list of Strings | string.str |
| conditional | Conditionals | conditional.str |
| cons | Lists are represented by means of the constructors Nil and Cons | cons.str |
| Cons(ATerm , ATerm ) | Element of a list | cons.str |
| cons | Overlay for pairs | cons.str |
| ContinueCS(ATerm , ATerm ) | n/a | dynamic-rules.str |
| copy | n/a | common.str |
| copy(Strategy s) | Makes n copies of a term into a list of duplicates, applying the strategy s to every copy | common.str |
| copy-char | n/a | string.str |
| copy-file | Alternative to the POSIX+XSI copy-file | file.str |
| copy-file | Copy a file using memory mapped I/O | file.str |
| copy-pipe-to-file | n/a | pipe-abstractions.str |
| cos | n/a | real.str |
| count-bottomup(Strategy s) | n/a | environment.str |
| Counter | n/a | integer.str |
| creat | Opening a file | file.str |
| create-dep-file(Strategy dep-base) | n/a | modules.str |
| Critical(ATerm ) | n/a | log.str |
| crush(Strategy nul, Strategy sum) | n/a | common.str |
| crush(Strategy nul, Strategy sum, Strategy s) | n/a | common.str |
| csystem-time | n/a | time.str |
| cuser-time | n/a | time.str |
| D | ||
| d(Strategy s) | n/a | environment.str |
| Date(ATerm , ATerm , ATerm ) | n/a | time.str |
| date-format | This module offers strategies to format a ComponentTime to a String | date-format.str |
| date-format | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-int | n/a | date-format.str |
| date-pattern-to-string | n/a | date-format.str |
| date-pattern-to-string | n/a | date-format.str |
| date-pattern-to-string | n/a | date-format.str |
| date-pattern-to-string | n/a | date-format.str |
| date-pattern-to-string | n/a | date-format.str |
| date-pattern-to-string | n/a | date-format.str |
| date-pattern-to-string | n/a | date-format.str |
| day-of-week2abbr | n/a | date-format.str |
| day-of-week2abbr | n/a | date-format.str |
| day-of-week2abbr | n/a | date-format.str |
| day-of-week2abbr | n/a | date-format.str |
| day-of-week2abbr | n/a | date-format.str |
| day-of-week2abbr | n/a | date-format.str |
| day-of-week2abbr | n/a | date-format.str |
| day-of-week2index | n/a | time.str |
| day-of-week2index | n/a | time.str |
| day-of-week2index | n/a | time.str |
| day-of-week2index | n/a | time.str |
| day-of-week2index | n/a | time.str |
| day-of-week2index | n/a | time.str |
| day-of-week2index | n/a | time.str |
| day-of-week2text | n/a | date-format.str |
| day-of-week2text | n/a | date-format.str |
| day-of-week2text | n/a | date-format.str |
| day-of-week2text | n/a | date-format.str |
| day-of-week2text | n/a | date-format.str |
| day-of-week2text | n/a | date-format.str |
| day-of-week2text | n/a | date-format.str |
| DayTime(ATerm , ATerm , ATerm ) | n/a | time.str |
| dbg(ATerm msg) | Logs the specified message as a debug | log.str |
| Debug(ATerm ) | n/a | log.str |
| debug | Prints the current term to stderr without changing it | term.str |
| debug(Strategy msg) | Prints the term produced by applying msg followed by the current term to stderr | term.str |
| debug-area(Strategy s, ATerm msg) | n/a | log.str |
| debug-depth | n/a | term.str |
| debug-depth(Strategy depth) | n/a | term.str |
| debug-depth(Strategy depth, Strategy s) | n/a | term.str |
| dec | Decrements a number | integer.str |
| dec-chars-to-int | n/a | integer.str |
| dec-string-to-int | n/a | integer.str |
| December(ATerm ) | n/a | time.str |
| default-no | n/a | common.str |
| default-system-about | Just shows the name of the program | parse-options.str |
| default-system-usage | Default system usage that invokes the short-description and long-description hook | parse-options.str |
| default-system-usage(Strategy short, Strategy long) | Display usage info containing a short description of the program | parse-options.str |
| diff | Computes the difference between two sets | set.str |
| diff(Strategy eq) | Computes the difference between two sets | set.str |
| diff | n/a | unification.str |
| diff-times | n/a | time.str |
| dir | Strategies for exploring directories | dir.str |
| dirname | Returns directory portion of pathname in a POSIX compatible way | file.str |
| Disambiguate(Strategy paren) | n/a | parenthesize.str |
| Disambiguate(Strategy paren) | n/a | parenthesize.str |
| DistBinding(Strategy s) | n/a | rename.str |
| DistBinding(Strategy s, Strategy boundin) | n/a | rename.str |
| div | Divides two numbers (integer or real) | integer.str |
| div2 | n/a | string.str |
| divi | Divides two integers | integer.str |
| divr | Divides two reals | integer.str |
| divS | n/a | integer.str |
| do-test(Strategy nr, Strategy s) | n/a | sunit.str |
| do-test(Strategy s, ATerm nr) | n/a | sunit.str |
| do-while(Strategy s, Strategy c) | Apply s at least once and then repeat while c succeeds | iteration.str |
| don't-stop(Strategy s) | A unit for topdownS, bottomupS and downupS | simple.str |
| double-quote | Adds double quotes to the start and end of a string | string.str |
| double-quote-chars | Adds double quotes to the start and end of a list of characters | string.str |
| downup(Strategy s) | n/a | simple.str |
| downup(Strategy s1, Strategy s2) | n/a | simple.str |
| downup-l(Strategy s) | n/a | list.str |
| downup-l(Strategy s1, Strategy s2) | n/a | list.str |
| downup2(Strategy s1, Strategy s2) | n/a | simple.str |
| downup2-l(Strategy s1, Strategy s2) | n/a | list.str |
| downupS(Strategy s, Strategy stop) | n/a | simple.str |
| downupS(Strategy s1, Strategy s2, Strategy stop) | n/a | simple.str |
| downupS-l(Strategy s, Strategy stop) | n/a | list.str |
| downupS-l(Strategy s1, Strategy s2, Strategy stop) | n/a | list.str |
| dr-add-fail(ATerm scpid, ATerm tbl, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-add-rule(ATerm name, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-add-rule(ATerm name, ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-add-rule-vis(ATerm name, ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-add-scope | n/a | dynamic-rules.str |
| dr-add-to-rule-set(ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-add-to-rule-set(ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-add-to-rule-set(Strategy add, ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-add-to-rule-set(Strategy add1, ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-add-to-rule-set-vis(ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-add-to-rule-set-vis(Strategy add, Strategy rm, ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-add-to-rule-set-vis(Strategy add1, Strategy rm1, ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-all-keys(ATerm name) | n/a | dynamic-rules.str |
| dr-all-keys(ATerm removed, ATerm result) | Fetch all keys defined in a rule set | dynamic-rules.str |
| dr-all-keys(ATerm removed, ATerm result) | n/a | dynamic-rules.str |
| dr-all-keys(ATerm removed, ATerm result) | n/a | dynamic-rules.str |
| dr-apply-change(ATerm tbl) | commit to ruleset is finding the first ChangeSet (any) *or* the first RuleScope that has the appropriate scopeid (i | dynamic-rules.str |
| dr-apply-removal | n/a | dynamic-rules.str |
| dr-begin-scope(ATerm name) | n/a | dynamic-rules.str |
| dr-begin-scopes(ATerm names) | n/a | dynamic-rules.str |
| dr-break(ATerm rulename) | n/a | dynamic-rules.str |
| dr-break(ATerm rulename, ATerm label) | n/a | dynamic-rules.str |
| dr-break-bp(ATerm rulename) | n/a | dynamic-rules.str |
| dr-build-aggregated-change-set | This strategy takes a pair of lists of change sets and rule scopes and returns a change set which contains all the changes from the change sets in the left member of the input pair which refer to rule scopes in the right member of the input pair | dynamic-rules.str |
| dr-build-bp-change-set(ATerm rmset, ATerm tbl, ATerm ruleset) | n/a | dynamic-rules.str |
| dr-build-bp-change-set(ATerm rmset, ATerm tbl, ATerm ruleset) | n/a | dynamic-rules.str |
| dr-clone-change-set | n/a | dynamic-rules.str |
| dr-commit-change-set(ATerm name) | n/a | dynamic-rules.str |
| dr-commit-change-set | n/a | dynamic-rules.str |
| dr-commit-change-set(Strategy destroy) | The strategy destroy indicates whether the change set should also be destroyed after the commmit | dynamic-rules.str |
| dr-commit-labels(ATerm labelset) | n/a | dynamic-rules.str |
| dr-commit-to-change-set(ATerm scpid, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-commit-to-rule-scope(ATerm scpid, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-commit-to-rule-set(ATerm scpid, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-complete-catch(Strategy merge, Strategy s, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-complete-catch-intersect(Strategy s, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-complete-catch-union(Strategy s, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-complete-exception-block(Strategy merge, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-complete-exception-block-intersect(ATerm rulenames) | n/a | dynamic-rules.str |
| dr-complete-exception-block-union(ATerm rulenames) | n/a | dynamic-rules.str |
| dr-complete-finally(Strategy merge, Strategy s, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-complete-finally-intersect(Strategy s, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-complete-finally-union(Strategy s, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-continue(ATerm rulename) | n/a | dynamic-rules.str |
| dr-continue(ATerm rulename, ATerm label) | n/a | dynamic-rules.str |
| dr-debug-rule-set(ATerm name) | n/a | dynamic-rules.str |
| dr-debug-rule-set(ATerm name, ATerm msg) | n/a | dynamic-rules.str |
| dr-define-ignoreB(ATerm csid, ATerm label) | n/a | dynamic-rules.str |
| dr-define-ignoreC(ATerm csid, ATerm label) | n/a | dynamic-rules.str |
| dr-define-ignoreT(ATerm csid) | n/a | dynamic-rules.str |
| dr-destroy-and-unmark | n/a | dynamic-rules.str |
| dr-destroy-change-set | n/a | dynamic-rules.str |
| dr-destroy-scope | n/a | dynamic-rules.str |
| dr-discard-change-set(ATerm name) | n/a | dynamic-rules.str |
| dr-discard-change-set | n/a | dynamic-rules.str |
| dr-end-scope(ATerm name) | n/a | dynamic-rules.str |
| dr-end-scopes(ATerm names) | n/a | dynamic-rules.str |
| dr-eq-rule-sets | n/a | dynamic-rules.str |
| dr-fix-and-intersect(Strategy s, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-fix-and-intersect(Strategy s, ATerm rulenames, ATerm label) | n/a | dynamic-rules.str |
| dr-fix-and-intersect-union(Strategy s, ATerm rulenames1, ATerm rulenames2) | Iterate combined union and intersection of two rule-sets | dynamic-rules.str |
| dr-fix-and-merge(Strategy merge, Strategy s, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-fix-and-merge(Strategy merge, Strategy s, ATerm rulenames, ATerm label) | n/a | dynamic-rules.str |
| dr-fix-and-merge(Strategy merge1, Strategy merge2, Strategy s, ATerm rulenames1, ATerm rulenames2) | n/a | dynamic-rules.str |
| dr-fix-and-merge-internal(Strategy merge, Strategy s, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-fix-and-union(Strategy s, ATerm rulenames) | Iterate union of two rule-sets | dynamic-rules.str |
| dr-fix-and-union(Strategy s, ATerm rulenames, ATerm label) | n/a | dynamic-rules.str |
| dr-fix-change-set | Fixes references in change set that point to rule scopes that will no longer be part of the merged ruleset | dynamic-rules.str |
| dr-fold-and-intersect(Strategy empty, Strategy hd, Strategy tl, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-fold-and-intersect(Strategy empty, Strategy hd, Strategy tl, ATerm rulenames, ATerm rs0) | n/a | dynamic-rules.str |
| dr-fork-and-intersect(Strategy s1, Strategy s2, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-fork-and-intersect-union(Strategy s1, Strategy s2, ATerm rulenames1, ATerm rulenames2) | Fork and combined union and intersection of two rule-sets | dynamic-rules.str |
| dr-fork-and-merge(Strategy merge, Strategy s1, Strategy s2, ATerm rulenames) | Fork and merge two rule-sets | dynamic-rules.str |
| dr-fork-and-merge(Strategy merge1, Strategy merge2, Strategy s1, Strategy s2, ATerm rulenames1, ATerm rulenames2) | n/a | dynamic-rules.str |
| dr-fork-and-union(Strategy s1, Strategy s2, ATerm rulenames) | Fork and union of two rule-sets | dynamic-rules.str |
| dr-friendly-debug-rule-set(ATerm name) | n/a | dynamic-rules.str |
| dr-friendly-debug-rule-set(ATerm name, ATerm msg) | n/a | dynamic-rules.str |
| dr-friendly-print-rule-set(ATerm name) | n/a | dynamic-rules.str |
| dr-friendly-print-rule-set | n/a | dynamic-rules.str |
| dr-friendly-print-rule-set-msg(ATerm msg) | n/a | dynamic-rules.str |
| dr-friendly-print-rule-set-msg(ATerm msg) | n/a | dynamic-rules.str |
| dr-friendly-print-rule-sets(ATerm names) | n/a | dynamic-rules.str |
| dr-friendly-print-scope | n/a | dynamic-rules.str |
| dr-friendly-print-scope | n/a | dynamic-rules.str |
| dr-get-first-scope-label(Strategy s, ATerm name) | Get the first scope label for which s succeeds starting with the inner, most recent, scope | dynamic-rules.str |
| dr-get-first-scope-label(Strategy s) | Get the first scope label for which s succeeds | dynamic-rules.str |
| dr-get-inner-scope | n/a | dynamic-rules.str |
| dr-get-rule-set(ATerm name) | n/a | dynamic-rules.str |
| dr-get-scope-labels(ATerm name) | Get all scope labels ordered from inner, most recent, to outer, oldest | dynamic-rules.str |
| dr-get-scope-labels | n/a | dynamic-rules.str |
| dr-ignore-state(Strategy s, ATerm name) | Apply s in a state where the current dynamic rules for name are ignored | dynamic-rules.str |
| dr-ignore-states(Strategy s, ATerm names) | Apply s in a state where the current dynamic rules for names are ignored | dynamic-rules.str |
| dr-init-exception-block(Strategy has-finally, ATerm catch-tags, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-intersect-rule-sets | Intersection of two rule-sets | dynamic-rules.str |
| dr-intersect-rule-sets-symm | Symmetric intersection of two rule-sets | dynamic-rules.str |
| dr-intersect-symm(ATerm name) | Intersect live rule-set with given rule set changing both | dynamic-rules.str |
| dr-intersect-with(ATerm name) | Intersect live rule-set with given rule set changing the live rule set | dynamic-rules.str |
| dr-label(Strategy merge, Strategy s, ATerm rulenames, ATerm label) | n/a | dynamic-rules.str |
| dr-label-intersect(Strategy s, ATerm rulenames, ATerm label) | n/a | dynamic-rules.str |
| dr-label-scope(ATerm name, ATerm label) | n/a | dynamic-rules.str |
| dr-label-scope(ATerm label) | n/a | dynamic-rules.str |
| dr-label-union(Strategy s, ATerm rulenames, ATerm label) | Label current point in data-flow with <label> to accommodate break's | dynamic-rules.str |
| dr-leave-scope | n/a | dynamic-rules.str |
| dr-left-choice(Strategy s1, Strategy s2, ATerm rulenames) | Left choice with dynamic rule roll-back in case s1 fails | dynamic-rules.str |
| dr-lookup-all-rules(ATerm name, ATerm key) | n/a | dynamic-rules.str |
| dr-lookup-all-rules(ATerm key) | Fetch all definitions for key | dynamic-rules.str |
| dr-lookup-all-rules(Strategy look, ATerm key, ATerm removed) | n/a | dynamic-rules.str |
| dr-lookup-all-rules(Strategy look1, ATerm key, ATerm removed) | n/a | dynamic-rules.str |
| dr-lookup-rule(ATerm name, ATerm key) | n/a | dynamic-rules.str |
| dr-lookup-rule(ATerm key) | n/a | dynamic-rules.str |
| dr-lookup-rule(Strategy look, ATerm key, ATerm removed) | n/a | dynamic-rules.str |
| dr-lookup-rule(Strategy look1, ATerm key, ATerm removed) | n/a | dynamic-rules.str |
| dr-lookup-rule-in-scope(ATerm key, ATerm scpid) | Version of dr-lookup-rule that looks for definition of a key in a particular scope | dynamic-rules.str |
| dr-lookup-rule-in-scope-cs(ATerm key, ATerm scpid) | n/a | dynamic-rules.str |
| dr-lookup-rule-in-scope-rs(ATerm key, ATerm scpid) | n/a | dynamic-rules.str |
| dr-lookup-rule-pointer(ATerm name, ATerm key) | n/a | dynamic-rules.str |
| dr-lookup-rule-pointer(ATerm key) | Fetch the most recent definition for key and return a pointer to the table that defines it | dynamic-rules.str |
| dr-lookup-rule-pointer(Strategy look, ATerm key, ATerm removed) | n/a | dynamic-rules.str |
| dr-lookup-rule-pointer(Strategy look1, ATerm key, ATerm removed) | n/a | dynamic-rules.str |
| dr-map-and-intersect(Strategy s, ATerm rulenames) | fork and intersect over a list | dynamic-rules.str |
| dr-merge-continue-change-sets(Strategy merge, ATerm label) | n/a | dynamic-rules.str |
| dr-merge-rule-sets(Strategy merge-rs, Strategy merge-cs) | n/a | dynamic-rules.str |
| dr-merge-rule-sets1(Strategy merge-rs, Strategy merge-rec) | n/a | dynamic-rules.str |
| dr-merge-rule-sets2(Strategy merge-cs, Strategy merge-rec) | n/a | dynamic-rules.str |
| dr-new-change-set | n/a | dynamic-rules.str |
| dr-new-rule-set | n/a | dynamic-rules.str |
| dr-new-scope | n/a | dynamic-rules.str |
| dr-print-rule-set(ATerm name) | n/a | dynamic-rules.str |
| dr-print-rule-set | n/a | dynamic-rules.str |
| dr-print-rule-set-msg(ATerm msg) | n/a | dynamic-rules.str |
| dr-print-rule-sets(ATerm names) | n/a | dynamic-rules.str |
| dr-print-scope | n/a | dynamic-rules.str |
| dr-print-scope | n/a | dynamic-rules.str |
| dr-remove-from-change-set(ATerm scpid, ATerm key) | n/a | dynamic-rules.str |
| dr-remove-from-rule-scope(ATerm scpid, ATerm key) | n/a | dynamic-rules.str |
| dr-remove-from-rule-set(ATerm scpid, ATerm key) | n/a | dynamic-rules.str |
| dr-rm-fail(ATerm scpid, ATerm tbl, ATerm key) | n/a | dynamic-rules.str |
| dr-rm-fail(ATerm scpid, ATerm tbl, ATerm key) | n/a | dynamic-rules.str |
| dr-rule-sets-hashtable | Retrieve the primitive dynamic rules hashtable | dynamic-rules.str |
| dr-save-rule-set | n/a | dynamic-rules.str |
| dr-scope(Strategy s, ATerm name) | n/a | dynamic-rules.str |
| dr-scopes(Strategy s, ATerm names) | n/a | dynamic-rules.str |
| dr-set-fail(ATerm scpid, ATerm tbl, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-set-in-rule-set(ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-set-in-rule-set(ATerm label, ATerm key, ATerm value) | set a rule in the scope with specified label | dynamic-rules.str |
| dr-set-in-rule-set(Strategy set, ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-set-in-rule-set(Strategy set1, ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-set-in-rule-set-vis(ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-set-in-rule-set-vis(ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-set-in-rule-set-vis(Strategy set, Strategy rm, ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-set-in-rule-set-vis(Strategy set1, Strategy rm1, ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-set-rule(ATerm name, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-set-rule(ATerm name, ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-set-rule-set(ATerm name) | n/a | dynamic-rules.str |
| dr-set-rule-vis(ATerm name, ATerm label, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| dr-set-rules-vis(ATerm name, ATerm label, ATerm key, ATerm values) | n/a | dynamic-rules.str |
| dr-start-change-set(ATerm name) | n/a | dynamic-rules.str |
| dr-start-change-set | n/a | dynamic-rules.str |
| dr-switch-rule-set(ATerm name) | n/a | dynamic-rules.str |
| dr-throw(Strategy eq-test, ATerm tag, ATerm rulename) | n/a | dynamic-rules.str |
| dr-transaction(Strategy s, ATerm rulenames) | n/a | dynamic-rules.str |
| dr-undefine-rule(ATerm name, ATerm key) | n/a | dynamic-rules.str |
| dr-undefine-rule(ATerm name, ATerm label, ATerm key) | n/a | dynamic-rules.str |
| dr-undefine-rule-vis(ATerm name, ATerm label, ATerm key) | n/a | dynamic-rules.str |
| dr-union-rule-sets | Union of two rule-sets | dynamic-rules.str |
| dr-union-rule-sets-symm | n/a | dynamic-rules.str |
| dr-union-symm(ATerm name) | Merge live rule-set with give rule set using union changing both | dynamic-rules.str |
| dr-union-with(ATerm name) | Merge live rule-set with given rule set using union changing the live rule set | dynamic-rules.str |
| DRCount | n/a | dynamic-rules.str |
| DRCount | n/a | dynamic-rules.str |
| DRCount | n/a | dynamic-rules.str |
| DRCount | n/a | dynamic-rules.str |
| DRFriendlyName | n/a | dynamic-rules.str |
| DRFriendlyName | n/a | dynamic-rules.str |
| drop(ATerm n) | Drops the first n elements from a list | common.str |
| drop(Strategy isn) | Drops a number of terms from the front of a list | common.str |
| drop-until(Strategy s) | Drops elements from the start of a list until s succeeds | common.str |
| drop-while(Strategy s) | Drops elements from the start of a list while s succeeds | common.str |
| DR_BREAK | n/a | dynamic-rules.str |
| DR_BREAK | n/a | dynamic-rules.str |
| DR_BREAK | n/a | dynamic-rules.str |
| DR_BREAK | n/a | dynamic-rules.str |
| DR_BREAK | n/a | dynamic-rules.str |
| DR_BREAK | n/a | dynamic-rules.str |
| DR_BREAK | n/a | dynamic-rules.str |
| DR_BREAK | n/a | dynamic-rules.str |
| DR_EXCEPTION | n/a | dynamic-rules.str |
| DR_EXCEPTION | n/a | dynamic-rules.str |
| DR_EXCEPTION | n/a | dynamic-rules.str |
| DR_EXCEPTION | n/a | dynamic-rules.str |
| DR_EXCEPTION | n/a | dynamic-rules.str |
| DR_EXCEPTION | n/a | dynamic-rules.str |
| DR_EXCEPTION | n/a | dynamic-rules.str |
| DR_EXCEPTION | n/a | dynamic-rules.str |
| DR_EXCEPTION | n/a | dynamic-rules.str |
| dtime | n/a | time.str |
| dup | Duplicating a file descriptor | file.str |
| dup2 | n/a | file.str |
| Dupl(ATerm , ATerm ) | n/a | time.str |
| Dupl | n/a | common.str |
| dynamic-rules | n/a | dynamic-rules.str |
| E | ||
| echo | n/a | term.str |
| echo(Strategy msg) | n/a | term.str |
| edge(Strategy mkvar) | n/a | share.str |
| elem | Succeeds if the term is in the list | common.str |
| elem(Strategy eq) | Succeeds if the term is in the list, using the given strategy for determining equality | common.str |
| eliminate-common-suffix | Eliminates all elements at the end of the two lists that are equal | common.str |
| Emergency(ATerm ) | n/a | log.str |
| end-scope(Strategy ns) | n/a | scoped-finite-map.str |
| env-alltd(Strategy s) | n/a | environment.str |
| env-alltd-l(Strategy s) | n/a | list-environment.str |
| env-bottomup(Strategy s) | n/a | environment.str |
| env-bottomup-l(Strategy s) | n/a | list-environment.str |
| env-oncetd(Strategy s) | n/a | environment.str |
| env-topdown(Strategy s) | n/a | environment.str |
| env-topdown(Strategy s, Strategy skip) | n/a | environment.str |
| env-topdown-l(Strategy s) | n/a | list-environment.str |
| env-topdown-l(Strategy s, Strategy skip) | n/a | list-environment.str |
| environment | Traversals that carry an environment | environment.str |
| epoch2local-time | n/a | time.str |
| epoch2utc | n/a | time.str |
| epoch2UTC | n/a | time.str |
| EpochTime(ATerm ) | n/a | time.str |
| eq | n/a | conditional.str |
| equal | n/a | unification.str |
| equal(Strategy fltr) | n/a | unification.str |
| equal(Strategy fltr1, Strategy fltr2) | The following equality strategy has an additional filter that can be used for checking equality modulo alpha renaming | unification.str |
| equal | Tests whether two terms are equal | conditional.str |
| equal(ATerm x) | Tests whether current term is equal to argument term | conditional.str |
| equal(ATerm x, ATerm y) | Tests whether two argument terms are equal to each other | conditional.str |
| err(ATerm msg) | Logs the specified message as an error | log.str |
| err-msg(ATerm msg) | Logs the specified message as an error | log.str |
| Error(ATerm ) | n/a | log.str |
| error | n/a | error.str |
| error | Prints a list of terms to stderr using fprintnl | term.str |
| error | Error handling for system strategies | error.str |
| ErrorNumber(ATerm ) | n/a | error.str |
| escape | Escapes double quotes, backslash and linefeed to C like escape sequences | string.str |
| Escape | n/a | string.str |
| escape-chars | Escapes double quotes, backslash and linefeed to C like escape sequences | string.str |
| even | n/a | integer.str |
| ExceptionCS(ATerm , ATerm ) | n/a | dynamic-rules.str |
| EXDEV | n/a | error.str |
| exec-filter-pipe(Strategy s) | n/a | pipe-abstractions.str |
| Execute | n/a | file-abstractions.str |
| execv | Replaces the current process image with a new process image | process.str |
| execvp | Replaces the current process image with a new process image | process.str |
| Existence | n/a | file-abstractions.str |
| exit | Abort execution with exit value n | process.str |
| exit-name-space(Strategy ns) | n/a | scoped-finite-map.str |
| exited | Succeeds if the process of this WaitStatus exited | process-abstractions.str |
| explode-string | Explodes a String to a list of chars | string.str |
| explode-term | Decompose a term into a constructor name and a list of terms | common.str |
| extend-assert(Strategy ns) | n/a | scoped-finite-map.str |
| extend-assert-undefined(Strategy ns) | n/a | scoped-finite-map.str |
| extend-config | Extends the list of values of the specified key with new values | common.str |
| extend-override-key(Strategy ns) | n/a | scoped-finite-map.str |
| extend-override-key-undefined(Strategy ns) | n/a | scoped-finite-map.str |
| extend-rewrite(Strategy ns) | n/a | scoped-finite-map.str |
| F | ||
| fallback-posix | n/a | fallback-posix.str |
| false | false is a synonym for id | conditional.str |
| fatal-err(ATerm msg) | Logs the specified message as critical and terminates the program with exit code 1 | log.str |
| fatal-err-msg(ATerm msg) | Logs the specified message as critical and terminates the program with exit code 1 | log.str |
| fatal-error | Prints a list of terms to stderr using fprintnl and exits with code 1 | term.str |
| fclose | Dissociates the named stream from its underlying file or set of functions | file.str |
| fdcopy | n/a | file.str |
| fdopen | The fdopen function associates a stream with the existing file descriptor, fd | file.str |
| February(ATerm ) | n/a | time.str |
| fetch(Strategy s) | Find first list element for which s succeeds | common.str |
| fetch-elem(Strategy s) | Return first list element for which s succeeds | common.str |
| fflush | n/a | file.str |
| fgetc | fgetc() reads the next character from the stream and returns the ASCII code of the character as an Int | file.str |
| file | n/a | file.str |
| file | Portable file operations | file.str |
| file | This module provides standard fallbacks to important Stratego strategies | file.str |
| file | n/a | file.str |
| file-abstractions | n/a | file-abstractions.str |
| file-exists | n/a | file-abstractions.str |
| file-from-pipe | n/a | pipe-abstractions.str |
| file-newer | n/a | file-abstractions.str |
| file-to-pipe | n/a | pipe-abstractions.str |
| filemode | n/a | file.str |
| fileno | The function fileno examines the argument stream and returns its integer descriptor | file.str |
| filter | This module contains strategies for filtering and partitioning lists | filter.str |
| filter(Strategy s) | n/a | filter.str |
| filter(Strategy s, Strategy tail) | n/a | filter.str |
| filter-text-file(Strategy more, Strategy done) | Filters the contents of a textfile character chunk by character chunk | char.str |
| Finally(ATerm ) | n/a | dynamic-rules.str |
| finally(Strategy s, Strategy f) | Applies s followed by f whether s failed or not | conditional.str |
| find-file(ATerm ext, ATerm path) | Finds one file with a specific file extension in a list of directories | file-abstractions.str |
| find-file(ATerm ext) | n/a | file-abstractions.str |
| find-file(Strategy mkpath, Strategy ext) | Finds one file with a specific file extension in a list of directories | file-abstractions.str |
| find-in-path(Strategy strict, ATerm path) | Finds a file in a list of directories (a path) | file-abstractions.str |
| find-in-path(ATerm path) | Finds a file in a list of directories (a path) | file-abstractions.str |
| find-in-path | n/a | file-abstractions.str |
| first-last | Returns a list with the first and the last element of the input list | common.str |
| fixpoint | A collection of strategies that keeps traversing a term until no more applications of some strategy to the nodes can be found | fixpoint.str |
| flatten(Strategy imp, Strategy nameeq, Strategy getcontent) | <flatten> (root, mods)| produces a flattened version of the root module | common.str |
| flatten-list | Completely flattens a list and its sublists to a single list | common.str |
| flip(Strategy s) | n/a | common.str |
| foldl(Strategy s) | Left folds a list | common.str |
| foldr(Strategy s1, Strategy s2) | Right folds a list | common.str |
| foldr(Strategy s1, Strategy s2, Strategy f) | Right folds a list | common.str |
| fopen | Opens the file whose name is the string pointed to by pathname and returns a Stream associated with this file | file.str |
| for(Strategy i, Strategy c, Strategy s) | Repeat application of s after initialization with i while c fails | iteration.str |
| for(Strategy s, ATerm low, ATerm up) | Apply s for each integer from low to up (inclusive) | iteration.str |
| for-each-pair(Strategy s) | n/a | common.str |
| fork(Strategy child) | Executes "child" in the child process and returns a tuple of the pid of the child process and the current term in the parent process | process-abstractions.str |
| fork(Strategy child, Strategy parent) | n/a | process-abstractions.str |
| fork | Creates a child process almost equivalent to the parent process | process.str |
| fork-and-wait(Strategy child) | n/a | process-abstractions.str |
| fork-rule-sets | n/a | dynamic-rules.str |
| forward | n/a | nested.str |
| fprint | Prints the terms to a stream | term.str |
| fprintnl | fprint, followed by a newline | term.str |
| fputc | Writes a Char to a Stream | file.str |
| fputs | n/a | file.str |
| free-variables | n/a | free-variables.str |
| free-vars(Strategy getvars, Strategy boundvars) | n/a | free-variables.str |
| free-vars(Strategy getvars, Strategy boundvars, Strategy boundin) | n/a | free-variables.str |
| free-vars(Strategy getvars, Strategy boundvars, Strategy boundin, Strategy eq) | n/a | free-variables.str |
| free-vars2(Strategy getvars, Strategy boundvars) | n/a | free-variables.str |
| free-vars2(Strategy getvars, Strategy boundvars, Strategy boundin) | n/a | free-variables.str |
| free-vars2(Strategy getvars, Strategy boundvars, Strategy boundin, Strategy eq) | n/a | free-variables.str |
| Friday(ATerm ) | n/a | time.str |
| Fst | n/a | common.str |
| F_OK(ATerm ) | n/a | file.str |
| G | ||
| gcd | n/a | integer.str |
| gcd' | n/a | integer.str |
| gen-left | n/a | parenthesize.str |
| gen-non-assoc | n/a | parenthesize.str |
| gen-none | n/a | parenthesize.str |
| gen-right | n/a | parenthesize.str |
| general-options | n/a | options.str |
| generic-chars-to-int | n/a | integer.str |
| generic-string-to-int | n/a | integer.str |
| GenGreaterThan | n/a | parenthesize.str |
| GenLeftAssoc | n/a | parenthesize.str |
| GenRightAssoc | n/a | parenthesize.str |
| geq | n/a | integer.str |
| geqS | n/a | integer.str |
| get-annos | Alias of get-annotations | annotation.str |
| get-annotations | Returns the list of annotations of the current term | annotation.str |
| get-appl-arguments | Get the arguments of a term application | common.str |
| get-appl-arguments(Strategy s) | Get the arguments of a term application, applying s to the individual arguments | common.str |
| get-arguments | Get the arguments of a term | common.str |
| get-config | Get the value for the specified key from the config table | common.str |
| get-config-keys(Strategy pred) | Get all config keys for which pred succeeds | common.str |
| get-configs(Strategy pred) | Get all values of config keys for which 'pred' succeeds | common.str |
| get-constructor | Get the constructor of a term | common.str |
| get-counter | n/a | integer.str |
| get-errno | n/a | error.str |
| get-extension | Get extension from filename | file.str |
| get-imports(Strategy imp) | n/a | common.str |
| get-index | Get index of element in list | index.str |
| get-index0(Strategy s) | n/a | index.str |
| get-keep | Give the current 'keep' level | keep.str |
| get-last-error | n/a | error.str |
| get-lines | Gets all newline(\n, \r\n or \r)-separated lines in a string | string.str |
| get-matching-id(Strategy eq-test, ATerm tag, ATerm rulename) | n/a | dynamic-rules.str |
| get-matching-id(ATerm catchID, ATerm rulename) | n/a | dynamic-rules.str |
| get-pid | Return process identifier of current process | process.str |
| get-placeholder | Returns the placeholder of an ATerm placeholder | placeholder.str |
| get-random-max | Gets the maximum random number that will be returned by the next-random number generator | integer.str |
| get-statistics | Give the current 'statistics' level | stats.str |
| getcwd | Returns the current working directory | file.str |
| getenv | The getenv() function searches the environment list for a string that matches the string pointed to by name | dir.str |
| getfirst(Strategy s) | Find first element of a list to which s applies | lookup.str |
| giving-up | Prints giving-up to stderr and exits with code 1 | term.str |
| GnExit | n/a | graph.str |
| GnInit | n/a | graph.str |
| GnInitRoots | n/a | graph.str |
| GnNext(Strategy get-node, Strategy out-edges, Strategy add-node) | n/a | graph.str |
| GnNextChangeGraph(Strategy get-node, Strategy out-edges, Strategy add-node) | n/a | graph.str |
| GnUndefined | n/a | graph.str |
| graph(Strategy mkvar) | The graph of a term is obtained by turning each node \verb|F(t1, | share.str |
| graph | A generic algorithm for mapping a graph to a collection of nodes reachable from a given root node | graph.str |
| graph-nodes(Strategy get-node, Strategy out-edges, Strategy add-node) | The strategy 'graph-nodes' is a generic algorithm for mapping a graph to a collection of nodes reachable from a given root node | graph.str |
| graph-nodes-roots(Strategy get-node, Strategy out-edges, Strategy add-node) | n/a | graph.str |
| graph-nodes-undef(Strategy get-node, Strategy out-edges, Strategy add-node) | n/a | graph.str |
| graph-nodes-undef-chgr(Strategy get-node, Strategy out-edges, Strategy add-node) | n/a | graph.str |
| graph-nodes-undef-roots(Strategy get-node, Strategy out-edges, Strategy add-node) | n/a | graph.str |
| graph-nodes-undef-roots-chgr(Strategy get-node, Strategy out-edges, Strategy add-node) | n/a | graph.str |
| GraphLet(ATerm , ATerm ) | n/a | share.str |
| GreaterThan | n/a | parenthesize.str |
| gt | n/a | integer.str |
| gti | n/a | integer.str |
| gtr | n/a | integer.str |
| gtS | n/a | integer.str |
| guarantee-extension(ATerm ext) | Drops the current extension and replaces it with the specified extension | file.str |
| H | ||
| has-annos | Succeeds if a term has annotations | annotation.str |
| has-annotation | n/a | annotation.str |
| has-extension(ATerm ext) | Checks if the file extension is ext | file.str |
| Hashtable(ATerm ) | Represents a reference to a hashtable | common.str |
| hashtable-clear | Clears the contents of an existing hashtable | common.str |
| hashtable-copy | Create a new hashtable and copies the entire contents of the current table into the new one | common.str |
| hashtable-destroy | Destroys and deallocates memory consumed by an existing hashtable | common.str |
| hashtable-eq | Checks whether two hashtables have equal contents | common.str |
| hashtable-eq(Strategy eq) | n/a | common.str |
| hashtable-fold(Strategy s, ATerm t) | Apply an iterative fold left (starting with first element) over the keys of a hash table; useful for applying an operation to each key without constructing a list of keys | common.str |
| hashtable-fold-keys(Strategy s, ATerm t) | Apply an iterative fold left (starting with first element) over the keys of a hash table; useful for applying an operation to each key without constructing a list of keys | common.str |
| hashtable-fold-values(Strategy s, ATerm t) | Apply an iterative fold left (starting with first element) over the values of a hash table; useful for applying an operation to each value without constructing a list of values | common.str |
| hashtable-get(ATerm key) | Gets the value for a key | common.str |
| hashtable-getlist | Get the contents of a hashtable as a list of key-value tuples | common.str |
| hashtable-init | Create a new hashtable and initialize it from a key-value pair list | common.str |
| hashtable-intersect(ATerm tbl2) | n/a | common.str |
| hashtable-intersect-symm-wempty(ATerm emptyElt) | Intersect hashtables symmetrically with default element | common.str |
| hashtable-intersect-symm-wempty-ignore-left(ATerm emptyElt) | Intersect hashtables symmetrically with default element | common.str |
| hashtable-intersect-wempty(ATerm tbl2, ATerm emptyElt) | Intersect hashtables with default element | common.str |
| hashtable-keys | Get a list containing all keys of a hashtable | common.str |
| hashtable-merge(Strategy symm, Strategy iterate1, Strategy iterate2, Strategy remove, Strategy merge, Strategy default, Strategy change1, Strategy change2, Strategy lookup1, Strategy lookup2) | n/a | common.str |
| hashtable-merge(Strategy symm, Strategy iterate1, Strategy iterate2, Strategy remove, Strategy merge, Strategy default, Strategy lookup1, Strategy lookup2) | Version without change arguments for backward compatibility | common.str |
| hashtable-merge-func(Strategy iterate1, Strategy iterate2, Strategy remove, Strategy merge, Strategy default, Strategy lookup1, Strategy lookup2) | Merge hashtables creating a new one | common.str |
| hashtable-peek(ATerm key) | Gets the top value from the stack for key (the stack remains untouched) Current term is the hashtable, output is the top value | common.str |
| hashtable-peekpop(ATerm key) | Gets the top value from the stack for key and pops it off the stack | common.str |
| hashtable-pop(ATerm key) | Pops off the top element of the stack for key | common.str |
| hashtable-push(ATerm key, ATerm value) | Pushes value on top of the stack for key | common.str |
| hashtable-pushlist(ATerm key, ATerm value) | Pushes values on top of the stack for key | common.str |
| hashtable-pushunion(ATerm key, ATerm value) | Pushes union of values and already present values Current term is the hashtable | common.str |
| hashtable-put(ATerm key, ATerm value) | Puts a new key, value pair into the hash table | common.str |
| hashtable-remove(ATerm key) | Removes a key (with its associated value) from the hashtable | common.str |
| hashtable-union(ATerm tbl2) | n/a | common.str |
| hashtable-union-symm-wempty(ATerm emptyElt) | n/a | common.str |
| hashtable-union-wempty(ATerm tbl2, ATerm emptyElt) | n/a | common.str |
| hashtable-values | Get a list containing all values of a hashtable | common.str |
| hex-chars-to-int | n/a | integer.str |
| hex-string-to-int | n/a | integer.str |
| home-dir | n/a | dir.str |
| I | ||
| if(Strategy c, Strategy b) | n/a | conditional.str |
| if(Strategy c, Strategy b1, Strategy b2) | n/a | conditional.str |
| if-annotation(Strategy s1, Strategy s2) | n/a | annotation.str |
| if-keep(Strategy s, ATerm t) | n/a | keep.str |
| if-keep1(Strategy s) | n/a | keep.str |
| if-keep2(Strategy s) | n/a | keep.str |
| if-keep3(Strategy s) | n/a | keep.str |
| if-keep4(Strategy s) | n/a | keep.str |
| if-keep5(Strategy s) | n/a | keep.str |
| if-keep6(Strategy s) | n/a | keep.str |
| if-keep7(Strategy s) | n/a | keep.str |
| if-less-keep(Strategy s, ATerm t) | n/a | keep.str |
| if-less-keep1(Strategy s) | n/a | keep.str |
| if-less-keep2(Strategy s) | n/a | keep.str |
| if-less-keep3(Strategy s) | n/a | keep.str |
| if-less-keep4(Strategy s) | n/a | keep.str |
| if-less-keep5(Strategy s) | n/a | keep.str |
| if-less-keep6(Strategy s) | n/a | keep.str |
| if-less-keep7(Strategy s) | n/a | keep.str |
| if-less-statistics(Strategy s, ATerm t) | n/a | stats.str |
| if-less-statistics1(Strategy s) | n/a | stats.str |
| if-less-statistics2(Strategy s) | n/a | stats.str |
| if-less-statistics3(Strategy s) | n/a | stats.str |
| if-less-statistics4(Strategy s) | n/a | stats.str |
| if-less-statistics5(Strategy s) | n/a | stats.str |
| if-less-statistics6(Strategy s) | n/a | stats.str |
| if-less-statistics7(Strategy s) | n/a | stats.str |
| if-less-verbose(Strategy s, ATerm t) | n/a | verbose.str |
| if-less-verbose1(Strategy s) | n/a | verbose.str |
| if-less-verbose2(Strategy s) | n/a | verbose.str |
| if-less-verbose3(Strategy s) | n/a | verbose.str |
| if-less-verbose4(Strategy s) | n/a | verbose.str |
| if-less-verbose5(Strategy s) | n/a | verbose.str |
| if-less-verbose6(Strategy s) | n/a | verbose.str |
| if-less-verbose7(Strategy s) | n/a | verbose.str |
| if-log-severity(Strategy s, ATerm severity) | n/a | log.str |
| if-not-silent(Strategy s) | n/a | options.str |
| if-statistics(Strategy s, ATerm t) | n/a | stats.str |
| if-statistics1(Strategy s) | n/a | stats.str |
| if-statistics2(Strategy s) | n/a | stats.str |
| if-statistics3(Strategy s) | n/a | stats.str |
| if-statistics4(Strategy s) | n/a | stats.str |
| if-statistics5(Strategy s) | n/a | stats.str |
| if-statistics6(Strategy s) | n/a | stats.str |
| if-statistics7(Strategy s) | n/a | stats.str |
| if-verbose(Strategy s, ATerm t) | n/a | verbose.str |
| if-verbose1(Strategy s) | n/a | verbose.str |
| if-verbose2(Strategy s) | n/a | verbose.str |
| if-verbose3(Strategy s) | n/a | verbose.str |
| if-verbose4(Strategy s) | n/a | verbose.str |
| if-verbose5(Strategy s) | n/a | verbose.str |
| if-verbose6(Strategy s) | n/a | verbose.str |
| if-verbose7(Strategy s) | n/a | verbose.str |
| IgnoreB(ATerm ) | n/a | dynamic-rules.str |
| IgnoreC(ATerm ) | n/a | dynamic-rules.str |
| IgnoreT(ATerm ) | n/a | dynamic-rules.str |
| implode-string | Implodes a list of chars to a string | string.str |
| inc | Increments a number | integer.str |
| indent-text(ATerm n) | Indents every line in a string with spaces | string.str |
| index | This module contains strategies for working on lists using indexes | index.str |
| index | Get the n-th element of a list | index.str |
| index(ATerm i) | Get the i-th element of a list | index.str |
| index2day-of-week | n/a | time.str |
| index2day-of-week | n/a | time.str |
| index2day-of-week | n/a | time.str |
| index2day-of-week | n/a | time.str |
| index2day-of-week | n/a | time.str |
| index2day-of-week | n/a | time.str |
| index2day-of-week | n/a | time.str |
| index2month | n/a | time.str |
| index2month | n/a | time.str |
| index2month | n/a | time.str |
| index2month | n/a | time.str |
| index2month | n/a | time.str |
| index2month | n/a | time.str |
| index2month | n/a | time.str |
| index2month | n/a | time.str |
| index2month | n/a | time.str |
| index2month | n/a | time.str |
| index2month | n/a | time.str |
| index2month | n/a | time.str |
| indexed | Interface to ATerm's IndexedSets | indexed.str |
| IndexedSet(ATerm ) | n/a | indexed.str |
| Infinite(ATerm ) | n/a | integer.str |
| Info(ATerm ) | n/a | log.str |
| init | n/a | common.str |
| init-name-space(Strategy ns) | n/a | scoped-finite-map.str |
| init-parenthesation-rules | n/a | parenthesize.str |
| init-record | n/a | sunit.str |
| inline-graph(Strategy always, Strategy mklet) | n/a | share.str |
| innermost(Strategy s) | n/a | fixpoint.str |
| innermost'(Strategy s) | n/a | fixpoint.str |
| innermost-memo(Strategy s) | n/a | fixpoint.str |
| innermost-old(Strategy s) | n/a | fixpoint.str |
| innermost-tagged(Strategy s) | innermost-tagged(s) reduces the subject term by applying s to innermost redices first | fixpoint.str |
| input(Strategy s) | Wraps a strategy into a strategy that handles input options | options.str |
| input-option | Option specifications for reading input | options.str |
| input-options | n/a | options.str |
| input-wrap(Strategy s) | n/a | options.str |
| input-wrap(Strategy extra-opts, Strategy s) | n/a | options.str |
| insert | Insert element in list | index.str |
| insert(ATerm k, ATerm v) | n/a | common.str |
| int | n/a | integer.str |
| int-add(ATerm y) | Adds two integers | integer.str |
| int-dec | Decrements an integer | integer.str |
| int-gt(ATerm y) | n/a | integer.str |
| int-inc | Increments an integer | integer.str |
| int-leq(ATerm y) | n/a | integer.str |
| int-lt(ATerm y) | n/a | integer.str |
| int-sort | n/a | integer.str |
| int-subt(ATerm y) | Subtracts two integers | integer.str |
| int-to-string | n/a | integer.str |
| integer | Integer arithmetic and comparison | integer.str |
| integer | This module contains a collection of strategies for working with lists of integers | integer.str |
| io(Strategy s) | Wraps a strategy into a strategy that handles io options | options.str |
| io-options | Handles all common options for a transformation tool | options.str |
| io-stream(Strategy s) | n/a | options.str |
| io-stream-wrap(Strategy s) | Wraps a strategy into a strategy that handles input and output options | options.str |
| io-stream-wrap(Strategy extra-opts, Strategy s) | n/a | options.str |
| io-stream-wrap(Strategy extra-opts, Strategy usage, Strategy about, Strategy s) | n/a | options.str |
| io-wrap(Strategy s) | Wraps a strategy into a strategy handling options and io of terms | options.str |
| io-wrap(Strategy extra-opts, Strategy s) | n/a | options.str |
| io-wrap(Strategy extra-opts, Strategy usage, Strategy about, Strategy s) | n/a | options.str |
| ior(Strategy s1, Strategy s2) | ior(s1, s2) implements 'inclusive or', that is, the inclusive choice of s1 and s2 | conditional.str |
| is-abspath | Succeeds if the input pathname is an absolute path | file.str |
| is-alpha | Succeeds if the character is part of the lowercase or uppercase alphabet | string.str |
| is-alphanum | n/a | string.str |
| is-ascii | Succeeds if this string only contains printable ASCII characters | string.str |
| is-char | Predicate that checks if the supplied term is a printable character | string.str |
| is-double-quoted | n/a | string.str |
| is-double-quoted-chars | Predicate that checks if a character list is double quoted | string.str |
| is-executable | n/a | file-abstractions.str |
| is-hexnum | Succeeds if applied to a character that is a hexidecimal digit, i | string.str |
| is-inner-node | Succeeds if the current term has at least one direct subterm | properties.str |
| is-int | n/a | integer.str |
| is-interval | Succeeds if the input term is a list of monotonously increasing integers and the difference between two adjacent integers is always one | integer.str |
| is-interval-from | n/a | integer.str |
| is-leaf | Succeeds if the current term has no direct subterms | properties.str |
| is-list | Succeeds if the input term is a list | common.str |
| is-lower | Succeeds if this character is lower-case | string.str |
| is-num | n/a | string.str |
| is-placeholder | Checks if the current term is a placeholder | placeholder.str |
| is-proper-subterm | Succeeds if the first argument (x) is a subterm of the second (y) and x is not y | properties.str |
| is-proper-subterm-set | n/a | properties.str |
| is-proper-superterm | Succeeds if the first argument (x) is a superterm of the second (y) and x is not y | properties.str |
| is-proper-superterm-set | n/a | properties.str |
| is-quoted(ATerm c) | Predicate that checks if a string is quoted with the given character | string.str |
| is-quoted-chars(ATerm c) | Predicate that checks if a list of characters is quoted with the character given by the term argument | string.str |
| is-readable | n/a | file-abstractions.str |
| is-real | n/a | real.str |
| is-relpath | Succeeds if the input pathname is a relative path | file.str |
| is-single-quoted | Predicate that checks a string is quoted with single quotes | string.str |
| is-single-quoted-chars | Predicate that checks if a character list is single quoted | string.str |
| is-string | Predicate that checks if the supplied term is a string | string.str |
| is-substring(Strategy s) | Succeeds if the string produced by s is a substring of the argument string | string.str |
| is-subterm | Succeeds if the first argument is a subterm of the second | properties.str |
| is-superterm | Succeeds if the first argument (x) is a superterm of the second (y) | properties.str |
| is-tuple | n/a | common.str |
| is-upper | Succeeds if this character is upper-case | string.str |
| is-whitespace | Succeeds if the character is whitespace | string.str |
| is-writable | n/a | file-abstractions.str |
| isatty | Succeeds if file descriptor refers to a terminal device | file.str |
| isblk | n/a | file.str |
| ischr | n/a | file.str |
| isdir | Succeeds when applied to a File which is a directory | file.str |
| isect | Take the intersection of two sets | set.str |
| isect(Strategy eq) | Take the intersection of two sets | set.str |
| iset-add(Strategy on_old, ATerm elem) | Adds elem to the set | indexed.str |
| iset-add(ATerm elem) | Ensures that elem is in the set | indexed.str |
| iset-addlist(ATerm lst) | Ensures that all elems in the specified list are in the set | indexed.str |
| iset-clear | Removes all elements from the set | indexed.str |
| iset-contains(ATerm elem) | Fails if elem is not in the set | indexed.str |
| iset-destroy | Releases all memory occupied by the set | indexed.str |
| iset-elements | Returns all elements of the set | indexed.str |
| iset-eq(ATerm set2) | Checks whether a set has equal contents as another | indexed.str |
| iset-fixpoint(Strategy s) | Applies s to the elements of a Set until it no more elements are added to this set | indexed.str |
| iset-get-elem(ATerm index) | Gets the element at index in the set | indexed.str |
| iset-get-index(ATerm elem) | Gets the index of elem in the set | indexed.str |
| iset-isect(ATerm set2) | Intersects a set with another | indexed.str |
| iset-remove(ATerm elem) | Removes elem from set | indexed.str |
| iset-subset(ATerm set2) | Checks whether one set is a subset of another | indexed.str |
| iset-union(ATerm set2) | Unites a set with another | indexed.str |
| isfifo | n/a | file.str |
| islnk | n/a | file.str |
| isort-list(Strategy s) | Sorts a list when given a suitable comparsion strategy s | sort.str |
| isreg | n/a | file.str |
| issock | n/a | file.str |
| iterate1-no | n/a | common.str |
| iterate1-yes | n/a | common.str |
| iterate2-no | n/a | common.str |
| iterate2-yes | n/a | common.str |
| iteration | Various iteration strategies | iteration.str |
| J | ||
| January(ATerm ) | n/a | time.str |
| join(Strategy s) | Creates the cartesian product of two lists and select only those combined elements <s>(x, y) that succeed | zip.str |
| July(ATerm ) | n/a | time.str |
| June(ATerm ) | n/a | time.str |
| just-date | n/a | time.str |
| just-day-time | n/a | time.str |
| K | ||
| keep | n/a | keep.str |
| keep-option | Option specifcation for level of keeping intermediate results | options.str |
| kill | Sends the specified signal to the specified process | process.str |
| L | ||
| Label(ATerm ) | n/a | dynamic-rules.str |
| last | Returns the last element of a list | common.str |
| leaves(Strategy s, Strategy is-leaf, Strategy skip) | n/a | simple.str |
| leaves(Strategy s, Strategy is-leaf) | n/a | simple.str |
| left-match | Succeeds if the first list of terms starts with the second list of terms | string.str |
| LeftAssoc | n/a | parenthesize.str |
| length | Returns the length of a list | common.str |
| leq | n/a | integer.str |
| leq-leq | n/a | integer.str |
| leq-lt | n/a | integer.str |
| leqS | n/a | integer.str |
| libstrategolib | Obsolete: import libstratego-lib | libstrategolib.str |
| lines | Makes one newline-separated string out of a list of strings | string.str |
| link-file | link-file creats a hard link from file 'new' to file 'old' | file.str |
| list(Strategy s) | n/a | common.str |
| list | This module defines a collection of generic one-pass traversals over lists | list.str |
| list-accum(Strategy s) | Reduces a list, applying s successively between the head and tail of the list | integer.str |
| list-combinations | Returns a list of combinations by choosing one element from every list, in every possible combination | common.str |
| list-edge(Strategy mkvar) | n/a | share.str |
| list-environment | Traversals that carry an environment | list-environment.str |
| list-fold(Strategy s, ATerm acc) | n/a | common.str |
| list-loop(Strategy s) | Iterative loop over a list applying s to each element | common.str |
| list-max | Returns the highest integer in a list of integers | integer.str |
| list-min | Returns the lowest integer in a list of integers | integer.str |
| list-some(Strategy s) | Apply a strategy to some elements in a list | common.str |
| list-tokenize(ATerm sep) | Breaks a list into multiple parts (tokens) | common.str |
| list-tokenize(Strategy sep) | Breaks a list into multiple parts (tokens) | common.str |
| listbu(Strategy s) | Applies a strategy to a list in bottom up order | common.str |
| listbu1(Strategy s) | n/a | common.str |
| listdu(Strategy s) | n/a | common.str |
| listdu2(Strategy s1, Strategy s2) | n/a | common.str |
| listtd(Strategy s) | n/a | common.str |
| ListToTuple | n/a | common.str |
| LMerge(Strategy s) | Merges the first and a particular element of the list, determined by the strategy argument s | sort.str |
| log | Strategies for logging | log.str |
| log(ATerm severity, ATerm msg, ATerm term) | n/a | log.str |
| log(ATerm severity, ATerm msg) | n/a | log.str |
| log-puts | n/a | log.str |
| log-src | n/a | log.str |
| log-stream | n/a | log.str |
| log2 | n/a | integer.str |
| long-description(Strategy s) | No default short description | parse-options.str |
| look2 | n/a | dynamic-rules.str |
| look2 | n/a | dynamic-rules.str |
| look2 | n/a | dynamic-rules.str |
| lookup | n/a | lookup.str |
| lookup | Lookup the first value associated with a key in an associative list | lookup.str |
| lookup(Strategy keyeq) | Looks up the first value associated with a particular key in an associative list, using keyeq to do key comparisons | lookup.str |
| lookup-table(ATerm name) | Retrieves a named table by looking it up in the table-table | common.str |
| lower-case | Converts all characters of this string to lower case | string.str |
| lower-case-chars | Converts a list of characters to lower case | string.str |
| LSort(Strategy s) | Moves a particular element of a list to the front, determined by the strategy argument s | sort.str |
| lt | n/a | integer.str |
| lt-inf | n/a | integer.str |
| lt-leq | n/a | integer.str |
| lt-lt | n/a | integer.str |
| ltrim(Strategy s) | n/a | common.str |
| ltrim-chars(Strategy s) | Trims leading characters from a string | string.str |
| ltS | n/a | integer.str |
| lzip(Strategy s) | n/a | zip.str |
| lzipFetch(Strategy s) | n/a | zip.str |
| M | ||
| make-placeholder | Creates a placeholder | placeholder.str |
| make-set | Removes duplicate elements from a list | set.str |
| makeConc | Concats two elements if both elements are lists | common.str |
| manybu(Strategy s) | n/a | simple.str |
| manytd(Strategy s) | n/a | simple.str |
| map(Strategy s) | Apply a strategy to each element of a list | common.str |
| map-intermediate(ATerm xs) | n/a | common.str |
| map-with-index(Strategy s) | Apply strategies that require some knowledge of the index of an element to the elements of the list | index.str |
| map-xs(ATerm intermediate, ATerm tail) | This is just a foldr, but Stratego does not support specialization of map-xs to an intermediate without introducing tuples, which means that we cannot use a generic fold | common.str |
| mapconcat(Strategy s) | Transform the elements of a list into lists (map) and concatenate into a single list (concat) | common.str |
| March(ATerm ) | n/a | time.str |
| MatchVar(Strategy isvar) | n/a | unification.str |
| matrix-transpose | Transposes an n by m matrix | common.str |
| max | n/a | integer.str |
| maxS | n/a | integer.str |
| May(ATerm ) | n/a | time.str |
| maybe(Strategy s) | n/a | conditional.str |
| maybe(Strategy s1, Strategy s2) | n/a | conditional.str |
| maybe(Strategy s1, Strategy s2) | n/a | conditional.str |
| member | Succeeds if the first input term is a member of the second | common.str |
| memo | The memo operator makes a strategy into a memoizing strategy that looks up the term to be transformed in a memo table and only computes the transformation if the term is not found | memo.str |
| memo(Strategy s) | <memo(tbl, s)> t first looks up the term t in the memo table | memo.str |
| Memo | n/a | memo.str |
| memo-scope(Strategy s) | n/a | memo.str |
| merge-rule-sets(Strategy merge) | n/a | dynamic-rules.str |
| min | n/a | integer.str |
| minS | n/a | integer.str |
| MkCons | Makes a Cons out of a tuple with head and tail | common.str |
| mkdir(ATerm mode) | Create directory | file.str |
| mkdir | n/a | file.str |
| mkdtemp | n/a | file.str |
| mkstemp | n/a | file.str |
| mkterm | Build a term given a constructor name and a list of terms | common.str |
| mod | Returns the modulo (remainder after division) of two integers or reals | integer.str |
| modi | Returns the modulo (remainder after division) of two integers | integer.str |
| modification-time | Returns the modification time of a file in sections since epoch | file.str |
| modr | Returns the modulo (remainder after division) of two floats | integer.str |
| modS | n/a | integer.str |
| modules | CHANGES (by Joost Visser) | modules.str |
| Monday(ATerm ) | n/a | time.str |
| month2abbr | n/a | date-format.str |
| month2abbr | n/a | date-format.str |
| month2abbr | n/a | date-format.str |
| month2abbr | n/a | date-format.str |
| month2abbr | n/a | date-format.str |
| month2abbr | n/a | date-format.str |
| month2abbr | n/a | date-format.str |
| month2abbr | n/a | date-format.str |
| month2abbr | n/a | date-format.str |
| month2abbr | n/a | date-format.str |
| month2abbr | n/a | date-format.str |
| month2abbr | n/a | date-format.str |
| month2index | n/a | time.str |
| month2index | n/a | time.str |
| month2index | n/a | time.str |
| month2index | n/a | time.str |
| month2index | n/a | time.str |
| month2index | n/a | time.str |
| month2index | n/a | time.str |
| month2index | n/a | time.str |
| month2index | n/a | time.str |
| month2index | n/a | time.str |
| month2index | n/a | time.str |
| month2index | n/a | time.str |
| month2text | n/a | date-format.str |
| month2text | n/a | date-format.str |
| month2text | n/a | date-format.str |
| month2text | n/a | date-format.str |
| month2text | n/a | date-format.str |
| month2text | n/a | date-format.str |
| month2text | n/a | date-format.str |
| month2text | n/a | date-format.str |
| month2text | n/a | date-format.str |
| month2text | n/a | date-format.str |
| month2text | n/a | date-format.str |
| month2text | n/a | date-format.str |
| mul | Multiplies two numbers (integer or real) | integer.str |
| muli | Multiplies two integers | integer.str |
| mulr | Multiplies two reals | integer.str |
| mulS | n/a | integer.str |
| N | ||
| need-help(Strategy u) | n/a | options.str |
| neg | n/a | integer.str |
| neg-chars-to-int | n/a | integer.str |
| nested | n/a | nested.str |
| NestedTable(ATerm ) | n/a | nested.str |
| nestedtable-get(ATerm keys) | n/a | nested.str |
| nestedtable-get(Strategy forward, ATerm keys) | n/a | nested.str |
| nestedtable-get-aux(Strategy forward, ATerm tbl) | n/a | nested.str |
| nestedtable-get-aux(Strategy forward, ATerm tbl) | n/a | nested.str |
| nestedtable-get-aux(Strategy forward, ATerm tbl1) | n/a | nested.str |
| nestedtable-put(ATerm keys, ATerm value) | n/a | nested.str |
| nestedtable-put(Strategy forward, ATerm keys, ATerm value) | n/a | nested.str |
| nestedtable-put(Strategy forward, Strategy changed, ATerm keys, ATerm value) | n/a | nested.str |
| nestedtable-put-aux(Strategy forward, Strategy changed, ATerm tbl, ATerm value) | n/a | nested.str |
| nestedtable-put-aux(Strategy forward, Strategy changed, ATerm tbl, ATerm value) | n/a | nested.str |
| nestedtable-put-aux(Strategy forward, Strategy changed, ATerm tbl1, ATerm value) | n/a | nested.str |
| new | Generates a unique new string of the form 'c_d', where c is one char and d is a positive integer | string.str |
| new-counter | n/a | integer.str |
| new-hashtable | Create a new hashtable with default size and load | common.str |
| new-hashtable(ATerm initial_size, ATerm max_load) | Create a new hashtable with specified size and load | common.str |
| new-iset | Creates a new set with default initial size and maximum load | indexed.str |
| new-iset(ATerm initial_size, ATerm max_load) | Creates a new set with specified initial size and maximum load | indexed.str |
| new-temp-dir | Safe, mkdtemp based, creation of temporary directory | file.str |
| new-temp-file | Safe, mkstemp based, creation of temporary file | file.str |
| newname | Generates a unique new string with user-defined prefix the form 'sd', where s is a string and d is a positive integer | string.str |
| NewTable(ATerm ) | n/a | nested.str |
| next(ATerm j) | n/a | index.str |
| next(ATerm j) | n/a | index.str |
| next-counter | n/a | integer.str |
| next-random | Returns a random number between 0 and get-random-max | integer.str |
| Nil(ATerm ) | Empty list | cons.str |
| nmap(Strategy s, ATerm i) | Map a strategy over a list where the strategy takes the index as a term argument | index.str |
| node-size | n/a | common.str |
| None(ATerm ) | n/a | option.str |
| Notice(ATerm ) | n/a | log.str |
| notice(ATerm msg) | Logs the specified message as a notice | log.str |
| notice-msg(ATerm msg) | Logs the specified message as a notice | log.str |
| November(ATerm ) | n/a | time.str |
| now-epoch-time | n/a | time.str |
| now-local-time | n/a | time.str |
| now-UTC | n/a | time.str |
| nub | Removes duplicate elements from a list | set.str |
| number(Strategy s) | n/a | common.str |
| number-from-signal | n/a | signal.str |
| number-from-signal | n/a | signal.str |
| nzip(Strategy s) | n/a | zip.str |
| nzip0(Strategy s) | n/a | zip.str |
| O | ||
| obsolete(Strategy msg) | Logs an obsolete strategy message with the given message | term.str |
| occurrences(Strategy s) | n/a | common.str |
| oct-chars-to-int | n/a | integer.str |
| oct-string-to-int | n/a | integer.str |
| October(ATerm ) | n/a | time.str |
| om-occurrences(Strategy s) | n/a | common.str |
| oncebu(Strategy s) | n/a | simple.str |
| oncetd(Strategy s) | n/a | simple.str |
| oncetd-skip(Strategy s, Strategy skip) | n/a | simple.str |
| one-dist(Strategy s) | n/a | environment.str |
| open | n/a | options.str |
| open | n/a | file.str |
| open(Strategy file) | n/a | term.str |
| open-stream | Opens a Stream associated to a FileLoc | file.str |
| Option(Strategy is-flag, Strategy label, Strategy s) | n/a | parse-options.str |
| Option(Strategy is-flag, Strategy label) | n/a | parse-options.str |
| Option(Strategy is-flag, Strategy label, Strategy s) | Registere usage info, when Option is applied to the term "register-usage-info" | parse-options.str |
| Option(Strategy is-flag, Strategy handlers, ATerm msg) | The handlers argument of this ArgOption variant must be an OptionHandler | parse-options.str |
| Option(Strategy is-flag, Strategy handlers, ATerm msg) | Handle a special action, which is specified by a tuple | parse-options.str |
| option | n/a | option.str |
| option(Strategy s) | n/a | option.str |
| option-defined(Strategy s) | n/a | parse-options.str |
| option-wrap(Strategy opts, Strategy s) | n/a | options.str |
| option-wrap(Strategy opts, Strategy usage, Strategy announce, Strategy s) | n/a | options.str |
| option-wrap(Strategy opts, Strategy usage, Strategy about, Strategy announce, Strategy s) | Read options, display help, report success or failure, call strategy | options.str |
| OptionCheck(Strategy exit, Strategy checks, ATerm msg) | The exit parameter can - be <exit> 1 for immediate failure - be <set-config> "--help" to report the usage and exit | parse-options.str |
| OptionHandler(Strategy user) | n/a | parse-options.str |
| OptionHandler(Strategy init, Strategy user, Strategy default) | n/a | parse-options.str |
| OptionHandler(Strategy init, Strategy user, Strategy default) | n/a | parse-options.str |
| OptionHandler(Strategy init, Strategy user, Strategy default) | n/a | parse-options.str |
| OptionHandlerHelper(Strategy is-flag, Strategy handlers) | n/a | parse-options.str |
| OptionHandlerHelper(Strategy is-flag, Strategy handlers) | n/a | parse-options.str |
| OptionNotCombinedCheck(Strategy is-flag, Strategy other-flags) | Checks that this option is not used together with other options | parse-options.str |
| OptionOneCheck(Strategy is-flag) | Checks that this option is used exactly once | parse-options.str |
| OptionOneOrMoreCheck(Strategy is-flag) | Checks that this option is used one or more times | parse-options.str |
| options | This module contains strategies for handling command line options and simple serialization/unserialization of ATerms | options.str |
| OptionZeroOrOneCheck(Strategy is-flag) | Checks that this option is specified just once, or not at all | parse-options.str |
| or(Strategy s1, Strategy s2) | or(s1, s2) is similar to ior(s1,s2), but the application of the strategies is only tested | conditional.str |
| outermost(Strategy s) | n/a | fixpoint.str |
| output(Strategy s) | Wraps a strategy into a strategy that handles output options | options.str |
| output-option | Option specifications for writing output | options.str |
| output-options | n/a | options.str |
| output-wrap(Strategy s) | n/a | options.str |
| output-wrap(Strategy extra-opts, Strategy s) | n/a | options.str |
| override-key(Strategy ns) | n/a | scoped-finite-map.str |
| override-system-about | No override of the default system about | parse-options.str |
| override-system-usage | No override of the default system usage | parse-options.str |
| P | ||
| pack(Strategy parser, Strategy imp) | Packing a module consists of collecting all modules into a single file | common.str |
| pack-modules(Strategy pack) | n/a | modules.str |
| pack-modules(Strategy pack, Strategy dep-base) | n/a | modules.str |
| pack-options | n/a | modules.str |
| PackInit | n/a | common.str |
| padd-with(Strategy s) | n/a | string.str |
| Pair(ATerm x, ATerm y) | Overlay for a pair, converts two terms to a 2-tuple | cons.str |
| pair-term-zip-bu(Strategy leaf, Strategy node) | n/a | zip.str |
| parenthesize | This module defines a generic strategy for placing parentheses in abstract syntax trees based on priority and associativity declarations | parenthesize.str |
| parenthesize(Strategy paren, Strategy prios) | n/a | parenthesize.str |
| parenthesize(Strategy paren) | n/a | parenthesize.str |
| parse-options | Strategies for handling command-line options | parse-options.str |
| parse-options(Strategy s) | Invokes system-usage and system-about on help and about | parse-options.str |
| parse-options(Strategy s, Strategy usage, Strategy about) | Parse options | parse-options.str |
| parse-options'(Strategy s) | Register all usages of all defined switches; then parse switches as specified by the user | parse-options.str |
| partition(Strategy s) | n/a | filter.str |
| partition(Strategy s1, Strategy s2) | Partitions a list into a tuple of two lists | filter.str |
| pass-keep | Builds command-line parameter for 'keep' levels for calling XT tools | keep.str |
| pass-statistics | Builds command-line parameter for 'statistics' levels for calling XT tools | stats.str |
| pass-verbose | Builds command-line parameter for verbosity levels for calling XT tools | verbose.str |
| Path(ATerm ) | n/a | file.str |
| pattern-match(Strategy isvar) | n/a | unification.str |
| perror | Print a system error message | error.str |
| pipe | Pipe creates a pair Pipe(fd1, fd2) of file descriptors, pointing to a pipe inode, and places them in the array pointed to by filedes | file.str |
| Pipe(ATerm , ATerm ) | n/a | file.str |
| pipe-abstractions | n/a | pipe-abstractions.str |
| pipe-abstractions | n/a | pipe-abstractions.str |
| pipe-sink(Strategy prog, Strategy args) | n/a | pipe-abstractions.str |
| pipe-source(Strategy prog, Strategy args) | n/a | pipe-abstractions.str |
| placeholder | Primitives for ATerm placeholders | placeholder.str |
| pos | n/a | integer.str |
| pos-chars-to-int | n/a | integer.str |
| post-extend-config | Extends the list of values of the specified key with new values | common.str |
| postorder-collect(Strategy s) | n/a | collect.str |
| postorder-collect(Strategy s, Strategy acc) | n/a | collect.str |
| prefix-lines(ATerm p) | Prefixes all lines in a string with a string | string.str |
| preserve-annos(Strategy s) | n/a | annotation.str |
| preserve-annotation(Strategy s) | Alias of preserve-annos | annotation.str |
| prim-tuple-to-ComponentTime | n/a | time.str |
| print-failure | n/a | sunit.str |
| print-failure(ATerm msg) | n/a | sunit.str |
| print-stacktrace | n/a | stacktrace.str |
| printstring | n/a | term.str |
| process | Run-time process information | process.str |
| process | n/a | process.str |
| process-abstractions | n/a | process-abstractions.str |
| profile(Strategy s) | n/a | time.str |
| profile(Strategy msg, Strategy s) | n/a | time.str |
| profile'(Strategy msg, Strategy s) | n/a | time.str |
| Program(ATerm ) | n/a | parse-options.str |
| properties | n/a | properties.str |
| pseudo-innermost3(Strategy s) | n/a | fixpoint.str |
| puts | Writes a String to stdout with a trailing newline and returns stdout | file.str |
| P_tmpdir | n/a | file.str |
| Q | ||
| qsort(Strategy swap) | Sort a list using the quick-sort algorithm | sort.str |
| quick-sort(Strategy swap) | n/a | sort.str |
| quick-sort(Strategy swap, ATerm tail) | n/a | sort.str |
| quick-sort(Strategy swap, ATerm tail) | n/a | sort.str |
| quote(Strategy c) | n/a | string.str |
| quote-chars(Strategy c) | n/a | string.str |
| quote-chars | n/a | string.str |
| R | ||
| range | Generates range of numbers in the form of an integer list | integer.str |
| range | Generates a range of numbers in the form of an integer list | integer.str |
| range(ATerm step) | Generates a sequence of integers, using a specified step size | integer.str |
| range(ATerm step) | Generates a sequence of integers, using a specified step size | integer.str |
| range(Strategy next) | Generates a sequence of numbers using a generator strategy | integer.str |
| range(Strategy next) | n/a | integer.str |
| Read | n/a | file-abstractions.str |
| read-from-prog(Strategy prog, Strategy args) | n/a | pipe-abstractions.str |
| read-from-prog'(Strategy prog, Strategy args) | n/a | pipe-abstractions.str |
| read-from-stream | Reads an ATerm from a Stream | term.str |
| read-from-string | Reads an ATerm from a String | term.str |
| read-term-from-pipe | n/a | pipe-abstractions.str |
| read-text-file | Reads the contents of a textfile | char.str |
| read-text-from-stream | Reads all characters until EOF | char.str |
| read-text-line | Reads the next line of text in stream | char.str |
| readdir | The readdir() function returns a pointer to a dirent structure representing the next directory entry in the directory stream pointed to by dir | file.str |
| ReadFromFile | <ReadFromFile> file reads the term in file | term.str |
| real | This module contains strategies for operating on real numbers | real.str |
| real | n/a | real.str |
| real-to-string | n/a | real.str |
| real-to-string(ATerm prec) | n/a | real.str |
| record-failure | Internal: record a failed test | sunit.str |
| record-success | Internal: record a successful test | sunit.str |
| reduce(Strategy s) | n/a | fixpoint.str |
| register-usage(Strategy s) | Register useage info 's' by storing 's' in the table "usage-table" | parse-options.str |
| remove-all(Strategy s) | Removes all elements from a list that satisfy s | filter.str |
| remove-extension | Remove an extension from a file name | file.str |
| remove-file | Removes a file from a directory | dir.str |
| remove-no | n/a | common.str |
| remove-yes | n/a | common.str |
| rename | Renaming of bound variables is determined by the shape of variables and binding constructs | rename.str |
| rename(Strategy isvar, Strategy bndvars) | renaming bound variables assuming that variables are bound in all subterms of a binding construct variable declarations in binding constructs are assumed to have the same shape as variable uses | rename.str |
| rename(Strategy isvar, Strategy bndvars, Strategy boundin) | The strategy \verb|rename(isvar, mkvar, bnd)| renames all bound variables in a term to fresh variables; | rename.str |
| rename(Strategy isvar, Strategy bndvars, Strategy boundin, Strategy paste) | n/a | rename.str |
| rename-file | Alternative to the POSIX+XSI rename-file | file.str |
| rename-file | rename renames a file, moving it between directories if required | file.str |
| repeat(Strategy s) | Repeatedly apply s until it fails | iteration.str |
| repeat(Strategy s, Strategy c) | Repeatedly apply s until it fails and terminate with application of c | iteration.str |
| repeat(Strategy s, ATerm n) | Applies s repeatedly exactly n times | iteration.str |
| repeat-until(Strategy s, Strategy c) | Repeatedly apply s until c succeeds | iteration.str |
| repeat1(Strategy s, Strategy c) | Repeatedly apply s (at least once) and terminate with application of c | iteration.str |
| repeat1(Strategy s) | Repeatedly apply s (at least once) | iteration.str |
| report-failure | n/a | options.str |
| report-failure(Strategy exit) | n/a | options.str |
| report-failure-no-trace | Report the failure of this program, without showing a stack trace | options.str |
| report-failure-no-trace(Strategy exit) | n/a | options.str |
| report-run-time | Outputs the name of the program and the run time in seconds to stderr | time.str |
| report-run-time | n/a | fallback-posix.str |
| report-success | n/a | options.str |
| report-test | Internal: report the number of successes and failures | sunit.str |
| reset-counter | n/a | integer.str |
| rest-zip(Strategy s) | n/a | zip.str |
| restore(Strategy s, Strategy rest) | Apply restoring action 'rest' if s fails, and then fail | conditional.str |
| restore-always(Strategy s, Strategy rest) | Apply restoring action 'rest' after s terminates, and preserve success/failure behaviour of s | conditional.str |
| retain-all(Strategy s) | Returns all elements in a list that satisfy s, as a list | filter.str |
| reverse | Reverses a list | common.str |
| reverse(Strategy s) | Reverses a list and applies s to all the elements | common.str |
| reverse-filter(Strategy s) | Returns all elements in a list that satisfy s, as a list | filter.str |
| reverse-filter(Strategy s, Strategy tail) | n/a | filter.str |
| reverse-map(Strategy s) | In reverse order, apply a strategy to each element of a list | common.str |
| rewrite(Strategy ns) | n/a | scoped-finite-map.str |
| right-match | Succeeds if the first list of terms ends with the second list of terms | string.str |
| RightAssoc | n/a | parenthesize.str |
| risky(Strategy s, ATerm msg) | n/a | log.str |
| risky(Strategy s, ATerm severity, ATerm msg) | n/a | log.str |
| risky(Strategy msg, Strategy s) | Tries to apply s and prints msg to stderr if this fails | term.str |
| rm-annotations | n/a | annotation.str |
| rm-config | Remove the entry of the specified key from the config table | common.str |
| rm2(ATerm scpid, ATerm tbl2, ATerm key) | n/a | dynamic-rules.str |
| rm2(ATerm scpid, ATerm tbl2, ATerm key) | n/a | dynamic-rules.str |
| rmdir | Remove empty directory | file.str |
| RnBinding(Strategy bndvrs) | n/a | rename.str |
| RnBinding(Strategy bndvrs, Strategy paste) | n/a | rename.str |
| RnVar(Strategy isvar) | n/a | rename.str |
| rseq | n/a | dynamic-rules.str |
| rtrim(Strategy s) | Trim elements from the end of a list | common.str |
| rtrim-chars(Strategy s) | Trims trailing characters from a string | string.str |
| RuleScope(ATerm , ATerm ) | n/a | dynamic-rules.str |
| run-time | Total run-time so far | time.str |
| rzip(Strategy s) | n/a | zip.str |
| rzipFetch(Strategy s) | n/a | zip.str |
| R_OK(ATerm ) | n/a | file.str |
| S | ||
| Saturday(ATerm ) | n/a | time.str |
| save(Strategy file) | n/a | term.str |
| say(Strategy msg) | Prints the term produced by applying msg to stderr | term.str |
| scope(Strategy ns, Strategy s) | n/a | scoped-finite-map.str |
| scoped-finite-map | n/a | scoped-finite-map.str |
| Scopes(ATerm ) | n/a | scoped-finite-map.str |
| self-children-sys-time | n/a | time.str |
| self-children-user-time | n/a | time.str |
| separate-by | Separates the elements of the list by the specified separator | common.str |
| separate-by(Strategy sep) | Separates the elements of the list by the specified separator | common.str |
| separate-by(ATerm sep) | Separates the elements of the list by the specified separator | common.str |
| September(ATerm ) | n/a | time.str |
| set | n/a | set.str |
| set-anno | n/a | annotation.str |
| set-annos | Alias of set-annotations | annotation.str |
| set-annotations | Sets the annotations of the given term t to the annotations a | annotation.str |
| set-config | Set an entry (key and value) in the config table | common.str |
| set-counter | n/a | integer.str |
| set-eq | Check equality of two list sets | set.str |
| set-eq(Strategy eq) | Check equality of two list sets | set.str |
| set-index | Change element in list | index.str |
| set-keep | Sets the 'keep' level | keep.str |
| set-log-stream | n/a | log.str |
| set-random-seed | Sets a seed for the following sequence of next-random calls | integer.str |
| set-statistics | Sets the 'statistics' level | stats.str |
| set-verbosity | Sets the verbosity level | verbose.str |
| set2(ATerm scpid, ATerm tbl2, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| set2(ATerm scpid, ATerm tbl2, ATerm key, ATerm value) | n/a | dynamic-rules.str |
| setenv | The setenv() function adds the variable name to the environment with the value value, if name does not already exist | process.str |
| setup-filter-pipe | n/a | pipe-abstractions.str |
| severity-string | n/a | log.str |
| severity-string | n/a | log.str |
| severity-string | n/a | log.str |
| severity-string | n/a | log.str |
| severity-string | n/a | log.str |
| severity-string | n/a | log.str |
| severity-string | n/a | log.str |
| severity-string | n/a | log.str |
| severity-string | n/a | log.str |
| share | The ATerm library preserves maximal sharing of subterms through hash-consing | share.str |
| share(Strategy mkvar, Strategy always, Strategy mklet) | The strategy share defined in this module achieves such an explicit sharing for arbitrary terms | share.str |
| short-description(Strategy s) | No default long description | parse-options.str |
| shuffle-forced | n/a | string.str |
| SIGABRT | n/a | signal.str |
| SIGALRM | n/a | signal.str |
| SIGBUS | n/a | signal.str |
| SIGCHLD | n/a | signal.str |
| SIGCONT | n/a | signal.str |
| SIGFPE | n/a | signal.str |
| SIGHUP | n/a | signal.str |
| SIGILL | n/a | signal.str |
| SIGINT | n/a | signal.str |
| SIGKILL | n/a | signal.str |
| signal | Information in this module is taken from the GNU core-utils manual, process control section | signal.str |
| Signal(ATerm , ATerm , ATerm ) | n/a | signal.str |
| signal-from-number | n/a | signal.str |
| signal-to-descr | n/a | signal.str |
| signal-to-descr | n/a | signal.str |
| signaled | Succeeds if the process of this WaitStatus was signaled | process-abstractions.str |
| SIGPIPE | n/a | signal.str |
| SIGPOLL | n/a | signal.str |
| SIGPROF | n/a | signal.str |
| SIGQUIT | n/a | signal.str |
| SIGSEGV | n/a | signal.str |
| SIGSTOP | n/a | signal.str |
| SIGSYS | n/a | signal.str |
| SIGTERM | n/a | signal.str |
| SIGTRAP | n/a | signal.str |
| SIGTSTP | n/a | signal.str |
| SIGTTIN | n/a | signal.str |
| SIGTTOU | n/a | signal.str |
| SIGURG | n/a | signal.str |
| SIGUSR1 | n/a | signal.str |
| SIGUSR2 | n/a | signal.str |
| SIGVTALRM | n/a | signal.str |
| SIGXCPU | n/a | signal.str |
| SIGXFSZ | n/a | signal.str |
| simple | This module contains generic one-pass traversals over terms | simple.str |
| sin | n/a | real.str |
| single-quote | n/a | string.str |
| single-quote-chars | Adds single quotes to the start and end of a list of characters | string.str |
| skip(Strategy s) | n/a | filter.str |
| skip(Strategy s) | n/a | filter.str |
| Snd | n/a | common.str |
| Some(ATerm ) | n/a | option.str |
| somebu(Strategy s) | n/a | simple.str |
| somedownup(Strategy s) | n/a | simple.str |
| somespinebu(Strategy s) | n/a | simple.str |
| somespinetd(Strategy s) | n/a | simple.str |
| sometd(Strategy s) | n/a | simple.str |
| sort | This module contains strategies for sorting lists | sort.str |
| sort-list(Strategy s) | Sorts a list when given a suitable comparsion strategy s | sort.str |
| SortL(Strategy s) | Swaps the two first elements in a list if s succeeds on this pair | sort.str |
| spawn-filter-with-prog(Strategy prog, Strategy args) | n/a | pipe-abstractions.str |
| spinebu(Strategy s) | Apply s along the spine of a term, in bottom up order | simple.str |
| spinebu'(Strategy s) | n/a | simple.str |
| spinetd(Strategy s) | Apply s along the spine of a term, in top down order | simple.str |
| spinetd'(Strategy s) | n/a | simple.str |
| split(Strategy f, Strategy g) | n/a | common.str |
| split-after | n/a | string.str |
| split-at(Strategy s) | n/a | common.str |
| split-at(ATerm n) | Splits the list in two sublists, containing elements from 0 to n and from n onwards | common.str |
| split-at-dot | n/a | string.str |
| split-at-newlines | n/a | string.str |
| split-at-space | Splits a string at each occurrence of a whitespace | string.str |
| split-before | n/a | string.str |
| split-Cons | Splits a Cons into a tuple with head and tail | common.str |
| split-fetch(Strategy s) | Splits a list in two parts at the first point where s succeeds | common.str |
| split-fetch-keep(Strategy s) | Splits a list in two parts at the point where s succeeds, keeping the element at which s succeeded | common.str |
| split-init-last | Splits a list into a tuple of its init list and last element | common.str |
| split-last | n/a | common.str |
| split3(Strategy f, Strategy g, Strategy h) | n/a | common.str |
| splitmap(Strategy s, ATerm n) | Splits a list after n elements and applies strategy s to the first sublist | common.str |
| SplitPos(ATerm , ATerm ) | n/a | dynamic-rules.str |
| sqrt | n/a | real.str |
| stacktrace | n/a | stacktrace.str |
| stacktrace-get-all-frame-names | Return a list of all the current stack frame namess | stacktrace.str |
| stacktrace-get-current-frame-index | Return the index (depth) of the current stack, including the call to this strategy | stacktrace.str |
| stacktrace-get-current-frame-name | Return the name of the currently active stack frame | stacktrace.str |
| statistics-option | Option specifcation for level of statistics printing | options.str |
| stats | n/a | stats.str |
| stderr(ATerm ) | n/a | file.str |
| stderr-stream | n/a | file.str |
| STDERR_FILENO | n/a | file.str |
| stdin(ATerm ) | n/a | file.str |
| stdin-from-pipe | n/a | pipe-abstractions.str |
| stdin-stream | Returns the Stream for stdin, stdout and stderr | file.str |
| STDIN_FILENO | n/a | file.str |
| stdio-stream | n/a | file.str |
| stdio-stream | n/a | file.str |
| stdio-stream | n/a | file.str |
| stdout(ATerm ) | n/a | file.str |
| stdout-stream | n/a | file.str |
| stdout-to-pipe | n/a | pipe-abstractions.str |
| STDOUT_FILENO | n/a | file.str |
| step | n/a | common.str |
| stopped | Succeeds if the process of this WaitStatus was stopped | process-abstractions.str |
| stratego-lib-c99 | n/a | stratego-lib-c99.str |
| stratego-lib-generic | n/a | stratego-lib-generic.str |
| stratego-lib-posix | n/a | stratego-lib-posix.str |
| stratego-lib-posix-xsi | n/a | stratego-lib-posix-xsi.str |
| strcasecmp | Compares two lists of characters lexicographically, ignoring case | string.str |
| strcat | Concats a tuple of two Strings | string.str |
| strcmp | n/a | string.str |
| Stream(ATerm ) | n/a | file.str |
| strerror | Return string describing error code | error.str |
| string | This module contains strategies for operating on strings | string.str |
| string-as-chars(Strategy s) | Wraps a strategy on a list of chars in a strategy on a string | string.str |
| string-ends-with(ATerm end) | Succeeds if the first String ends with the second String | string.str |
| string-gt | Compares two strings or lists of characters lexicographically and succeeds if the first one is larger than the second, ignoring case | string.str |
| string-length | Returns the number of characters in a string | string.str |
| string-lt | Compares two strings or lists of characters lexicographically and succeeds if the first one is smaller than the second, ignoring case | string.str |
| string-replace(ATerm old, ATerm new) | n/a | string.str |
| string-sort | n/a | string.str |
| string-sort-desc | Sorts a list of strings lexicographically ignoring case, descending | string.str |
| string-starts-with(ATerm start) | Succeeds if the first String starts with the second String | string.str |
| string-to-int | n/a | integer.str |
| string-to-level | n/a | log.str |
| string-to-level | n/a | log.str |
| string-to-level | n/a | log.str |
| string-to-level | n/a | log.str |
| string-to-level | n/a | log.str |
| string-to-level | n/a | log.str |
| string-to-level | n/a | log.str |
| string-to-level | n/a | log.str |
| string-to-level | n/a | log.str |
| string-to-real | n/a | real.str |
| string-tokenize(ATerm sepchars) | Breaks a string into tokens | string.str |
| string-tokenize | n/a | string.str |
| string-tokenize-keep-all(ATerm sepChars) | Splits a string into a list of tokens, keeping the separating elements as 1-char-strings within the results list, *and* also keeping the empty "" tokens | string.str |
| string-tokenize-keep-empty(ATerm sepChars) | Splits a string into a list of tokens, including the empty ones | string.str |
| strip-annos | n/a | annotation.str |
| strlen | Returns the number of characters in a string | string.str |
| strncmp | Compares the n first characters of two character lists, n is given by the last argument | string.str |
| Structure(ATerm ) | n/a | dynamic-rules.str |
| subs-args | n/a | substitution.str |
| subset | Succeeds if the first set is a strict subset of the second | set.str |
| subset(Strategy eq) | Succeeds if the first set is a strict subset of the second | set.str |
| subset-gen(Strategy eq, Strategy rest) | n/a | set.str |
| subseteq | Succeeds if the first set is a (non-strict) subset of the second | set.str |
| subseteq(Strategy eq) | Succeeds if the first set is a (non-strict) subset of the second | set.str |
| substitute(Strategy isvar, Strategy ren) | n/a | substitution.str |
| substitute(Strategy isvar) | n/a | substitution.str |
| substitute(Strategy isvar, Strategy varshape, Strategy bndvars, Strategy boundin, Strategy paste, Strategy ren) | n/a | substitution.str |
| substitute(Strategy isvar, Strategy varshape, Strategy bndvars, Strategy boundin, Strategy paste) | n/a | substitution.str |
| substitution | n/a | substitution.str |
| SubsVar(Strategy isvar, Strategy mksbs) | n/a | substitution.str |
| subt | Subtracts two numbers (integer or real) | integer.str |
| subti | Subtracts two integers | integer.str |
| subtr | Subtracts two reals | integer.str |
| subtS | n/a | integer.str |
| sum | Returns the sum of all integers in a list of integers | integer.str |
| Sunday(ATerm ) | n/a | time.str |
| sunit | sunit: Unit Testing Framework | sunit.str |
| sunit-color-plain | n/a | sunit.str |
| sunit-color-red | n/a | sunit.str |
| sunit-create-input(Strategy s) | n/a | sunit.str |
| sunit-create-output(Strategy s) | n/a | sunit.str |
| sunit-failure-string | n/a | sunit.str |
| Swap | n/a | common.str |
| swapper(ATerm a2) | n/a | sort.str |
| sym-diff | Takes the symmetric difference of two sets | set.str |
| sym-diff(Strategy eq) | Takes the symmetric difference of two sets | set.str |
| symmetric-no | n/a | common.str |
| symmetric-yes | n/a | common.str |
| system-about | n/a | parse-options.str |
| system-about-switch | Always provide the --about and --version switch | parse-options.str |
| system-time | n/a | time.str |
| system-usage | n/a | parse-options.str |
| system-usage-switch | Always provide --help switch | parse-options.str |
| T | ||
| t(Strategy s) | n/a | environment.str |
| table-append | n/a | common.str |
| table-copy | n/a | common.str |
| table-create | Creates a table with a given name, which can be any term | common.str |
| table-destroy | Destroy a table with a given name, which can be any term | common.str |
| table-diff | n/a | common.str |
| table-get | Get the value associated with a key from a table | common.str |
| table-getlist | Get a list of key-value pairs | common.str |
| table-hashtable | Retrieves the primitive table-table as a Hashtable | common.str |
| table-keys | Produce a list of keys of a table | common.str |
| table-lookup | n/a | common.str |
| table-pop | n/a | common.str |
| table-pop-get | n/a | common.str |
| table-pop-rm | n/a | common.str |
| table-push | n/a | common.str |
| table-put | Associate a value with a key in a table | common.str |
| table-putlist | Put a list of key-value pairs in a table | common.str |
| table-putlist(Strategy s) | n/a | common.str |
| table-remove | Remove association of a key in a table | common.str |
| table-rename | Renames a table, i | common.str |
| table-replace | n/a | common.str |
| table-union | n/a | common.str |
| Tables(ATerm ) | n/a | nested.str |
| take(Strategy isn) | Take the first n elements of a list, given by isn | common.str |
| take(ATerm n) | Returns the first n elements of a list, fails if list has fewer than n elements | common.str |
| take-until(Strategy s) | Take elements from the start of a list until s succeeds | common.str |
| take-while(Strategy s) | Take elements from the start of a list while s succeeds | common.str |
| takemap(Strategy s, ATerm n) | Returns the n first elements after s has been applied to them | common.str |
| tcata(Strategy s1, Strategy s2) | n/a | common.str |
| tconcat(Strategy s) | n/a | common.str |
| tconcat'(Strategy s1, Strategy s2) | n/a | common.str |
| temp-dir | n/a | file.str |
| term | Term input and output | term.str |
| term-address-lt(ATerm t2) | Compare the address of two terms and succeeds if the address of the current term is smaller than the address of the argument | common.str |
| term-share-dead | n/a | share.str |
| term-share-dont-inline(Strategy mklet) | n/a | share.str |
| term-share-inline | n/a | share.str |
| term-size | n/a | common.str |
| term-zip(Strategy leaf, Strategy node) | n/a | zip.str |
| TermTupleZip(Strategy s) | n/a | zip.str |
| TermZip(Strategy s) | n/a | zip.str |
| test-extension(Strategy ext) | Tests if the file extension (everything after the | file.str |
| test-suite(Strategy name, Strategy tests) | n/a | sunit.str |
| testing(Strategy nr, Strategy s) | n/a | sunit.str |
| tfoldr(Strategy s1, Strategy s2) | Fold a tuple from right to left using s2 as the folding strategy | common.str |
| Thd | n/a | common.str |
| Third | n/a | common.str |
| thread-alltd(Strategy s) | n/a | environment.str |
| thread-bottomup(Strategy s) | n/a | environment.str |
| thread-map(Strategy s) | Applies s to each element in the list, keeping along a separate context term | common.str |
| thread-replacement(Strategy s) | n/a | environment.str |
| ThrowCS(ATerm , ATerm ) | n/a | dynamic-rules.str |
| Thursday(ATerm ) | n/a | time.str |
| ticks-to-seconds | n/a | time.str |
| time | The primitive \verb|dtime| returns the CPU time in seconds since the last call to \verb|dtime| | time.str |
| time | Strategy time returns the time since the Epoch (00:00:00 UTC, January 1, 1970), measured in seconds | time.str |
| time | n/a | time.str |
| time | n/a | time.str |
| times | n/a | time.str |
| times-to-seconds | n/a | time.str |
| tindex | n/a | common.str |
| tl(Strategy s') | n/a | dynamic-rules.str |
| tmap(Strategy s) | n/a | common.str |
| tmpnam | n/a | file.str |
| to-lower | Ensures that a character is lower-case | string.str |
| to-upper | Ensures that a character is upper-case | string.str |
| toggle-config | Adds an entry to the config table if it does not exist, or removes the entry if it does already exist in the config table | common.str |
| topdown(Strategy s) | n/a | simple.str |
| topdown-l(Strategy s) | n/a | list.str |
| topdownS(Strategy s, Strategy stop) | n/a | simple.str |
| topdownS-l(Strategy s, Strategy stop) | n/a | list.str |
| trace(Strategy msg, Strategy s) | n/a | term.str |
| trim(Strategy s) | Trim elements from both start and end of a list | common.str |
| trim-chars(Strategy s) | Trims leading and trailing characters from a string | string.str |
| trim-leading-whitespace | Trims all leading whitespace in a (single-line) string | string.str |
| trim-trailing-whitespace | Trims all trailing whitespace in a (single-line) string | string.str |
| trim-whitespace | Trims all trailing and leading whitespace in a (single-line) string | string.str |
| true | n/a | conditional.str |
| try(Strategy s) | n/a | conditional.str |
| TryBlock(ATerm , ATerm , ATerm , ATerm ) | n/a | dynamic-rules.str |
| Ttl | n/a | common.str |
| Tuesday(ATerm ) | n/a | time.str |
| tuple-unzip(Strategy s) | n/a | common.str |
| tuple-zip(Strategy s) | n/a | common.str |
| TupleToList | n/a | common.str |
| twicetd(Strategy s) | n/a | collect.str |
| tzip(Strategy s) | n/a | common.str |
| U | ||
| UfDecompose | n/a | unification.str |
| UfIdem | n/a | unification.str |
| UfShift | n/a | unification.str |
| UfSwap(Strategy isvar) | n/a | unification.str |
| UfVar(Strategy isvar) | n/a | unification.str |
| un-double-quote | Removes double quotes from the start and end of a string Fails if the string is not properly quoted | string.str |
| un-double-quote-chars | Removes double quotes from the start and end of a list of characters | string.str |
| un-single-quote | Removes single quotes from the start and end of a string Fails if the string is not properly quoted | string.str |
| un-single-quote-chars | Removes single quotes from the start and end of a list of characters | string.str |
| Undefined(ATerm ) | n/a | parse-options.str |
| UndefinedOption | n/a | parse-options.str |
| unescape | Unescapes double quotes, backslash, linefeed and tabs | string.str |
| UnEscape | n/a | string.str |
| unescape-chars(Strategy s) | Unescapes characters using a specified unescape strategy | string.str |
| unescape-chars | Unescapes double quotes, backslash, linefeed and tabs | string.str |
| unification | Syntactic unification, no variable bindings are taken into account | unification.str |
| unify(Strategy isvar) | The strategy unify unifies a list of pairs of terms and creates the most general unifier for them | unification.str |
| union | Union: Concatenation of two lists, only those elements in the first list are added that are not already in the second list | set.str |
| union(Strategy eq) | n/a | set.str |
| unions | Takes the union of a list of sets | set.str |
| unions(Strategy eq) | n/a | set.str |
| uniq | n/a | sort.str |
| Uniq | n/a | sort.str |
| UnknownSignal(ATerm ) | n/a | signal.str |
| unpack(Strategy wrapper, Strategy getname, Strategy ext) | Unpacking is the reverse of packing, i | common.str |
| unquote(Strategy s) | Removes the first and last character of a string | string.str |
| unquote(Strategy s1, Strategy s2) | Removes the first and last character of a string | string.str |
| unquote-chars(Strategy s) | Removes the first and last character of a list of characters | string.str |
| unquote-chars(Strategy s1, Strategy s2) | Removes the first and last character of a list of characters | string.str |
| unzip | n/a | zip.str |
| unzip(Strategy s) | Splits a list of pairs into two separate lists, applying s to the pair before splitting | zip.str |
| upper-case | Converts all characters of this string to upper case | string.str |
| upper-case-chars | Converts a list of characters to upper case | string.str |
| upto | n/a | common.str |
| user-time | n/a | time.str |
| V | ||
| verbose | Verbosity management | verbose.str |
| verbose-level | n/a | log.str |
| verbose-level | n/a | log.str |
| verbose-level | n/a | log.str |
| verbose-level | n/a | log.str |
| verbose-level | n/a | log.str |
| verbose-level | n/a | log.str |
| verbose-level | n/a | log.str |
| verbose-level | n/a | log.str |
| verbose-level | n/a | log.str |
| verbose-option | Option specifications for verbosity | options.str |
| verbose-to-int | n/a | options.str |
| verbosity | Give the current verbosity level | verbose.str |
| Vomit(ATerm ) | n/a | log.str |
| W | ||
| waitpid | n/a | process.str |
| WaitStatus(ATerm , ATerm , ATerm ) | Collects the information returned from a wait call | process.str |
| warn(ATerm msg) | Logs the specified message as a warning | log.str |
| warn-ifsignaled | Prints a warning if the process of this WaitStatus was signaled | process-abstractions.str |
| warn-msg(ATerm msg) | Logs the specified message as a warning | log.str |
| Warning(ATerm ) | n/a | log.str |
| Wednesday(ATerm ) | n/a | time.str |
| while(Strategy c, Strategy s) | While c succeeds apply s | iteration.str |
| while-not(Strategy c, Strategy s) | While c does not succeed apply s | iteration.str |
| whoami | n/a | options.str |
| with | This module provides a basic strategy for specifying run-time verified strategies | with.str |
| with(Strategy s, ATerm message) | n/a | with.str |
| Write | n/a | file-abstractions.str |
| write-in-baf-to-stream | n/a | term.str |
| write-in-taf-to-stream | n/a | term.str |
| write-in-text-to-stream | n/a | term.str |
| write-term-to-text-pipe | n/a | pipe-abstractions.str |
| write-to-binary-string | Writes an ATerm to a binary string represented as a list of chars | term.str |
| write-to-prog(Strategy prog, Strategy args) | n/a | pipe-abstractions.str |
| write-to-prog'(Strategy prog, Strategy args) | n/a | pipe-abstractions.str |
| write-to-shared-string | Writes an ATerm to a shared string represented as a list of chars | term.str |
| write-to-stream | Writes an ATerm to a Stream | term.str |
| write-to-string | Writes an ATerm to a String | term.str |
| WriteMod(Strategy getname, Strategy write, Strategy ext) | n/a | common.str |
| WriteToBinaryFile | <WriteToBinaryFile> (file, term) writes term to file in BAF format | term.str |
| WriteToFile(Strategy writer) | <WriteToFile(s)> (file, term) writes term to file with the writer s | term.str |
| WriteToTextFile | <WriteToTextFile> (file, term) writes term to file in textual ATerm format | term.str |
| W_OK(ATerm ) | n/a | file.str |
| X | ||
| X_OK(ATerm ) | n/a | file.str |
| Z | ||
| zip | n/a | zip.str |
| zip | Zipping two lists into a list of pairs is a useful operation in many situations | zip.str |
| zip | n/a | zip.str |
| zip(Strategy s) | Combines two lists into one by pairing up the elements from both lists, applying s to the pair | zip.str |
| zip(Strategy s, ATerm ys) | Combines two lists into one by pairing up the elements from both lists | zip.str |
| zip'(Strategy s) | n/a | zip.str |
| zip-skip(Strategy pred, Strategy s) | n/a | zip.str |
| zip-tail | n/a | zip.str |
| zipFetch(Strategy s) | n/a | zip.str |
| zipl(Strategy s) | n/a | zip.str |
| zipl-tail-match(Strategy s) | n/a | zip.str |
| zipPad(Strategy s, Strategy padding) | Combines two lists, which may have different lengths, into one by pairing up the elements from both lists, applying s to the pair | zip.str |
| zipr(Strategy s) | n/a | zip.str |
| zipr-tail-match(Strategy s) | n/a | zip.str |