Distributed programming in FDScript is organized around the notion of servers processing requests. Distributing a program across many machines consists of defining servers with different roles depending on capacities of machines, dependencies between services and data, and prosaic concerns of bandwidth and connectivity.

Every server on a machine has a particular address, called a port on which it listens for requests. Combining this port with the name of the machine defines a unique server id which other programs can use to access the server. The syntax port@host specifies a server, where the port can be:

• an integer address, typically larger than 1000 but less than 100000
• a service name, defined by an operating system database
• a "touch tone encoded" integer address, where an integer address is encoded alphabetically

Each server is effectively a remote Scheme interpreter which provides some subset of the Scheme namespace augmented by whatever special procedures it defines. These special procedures are called operations, but it can be useful to think of them as procedures which happen to be executed remotely. We give a brief description of how to start your own server below, but a more detailed description can be found in Implementing DType servers.

There are numerous ways to use a remote server from FDScript. The most seamless method uses an expression of the form (USE-SERVER "service@host" op) returns a remote procedure whose application in the current machine invokes the remote operation op (which is typically a symbol) on the server listening for service requests for the host host. For example,

[fdscript] (define rplus (use-server "demos@framerd.org" '+))
[fdscript] (rplus 3 4 5)
12

uses an Internet connection to add three numbers. A more interesting use would be:

[fdscript] (define nlphrase (use-server "demos@framerd.org" 'nlphrase))
[fdscript] (nlphrase "This sentence starts with a T")
(#((#("This" DETERMINER "this") #("sentence" NOUN)) (#("begins" VERB "begin")) 
   (#("with" PREPOSITION) #("a" DETERMINER) #("T" NOMINALIZATION "t"))))

The infrastructure for remote evaluation can be directly accessed through the FDScript functions remote-eval and dtcall. The remote-eval procedure takes a Scheme expression and evaluates it on the remote server, e.g.

[fdscript] (dtype-eval '(if (even? (length (session-id))) 'even-id 'odd-id)
                       "demos@framerd.org")
EVEN-ID

the dtcall procedure takes a server id, a remote operation, and any number of arguments and applies the operation to the arguments remotely, for example

[fdscript] (dtcall "demos@framerd.org" nlphrase "Many sentences start with M")
(#((#("Many" DETERMINER "many") #("sentences" PLURAL-NOUN "sentence")) 
   (#("start" VERB)) (#("with" PREPOSITION) #("M" NOMINALIZATION "m"))))

The dtcall procedure differs from dtype-eval in that it evaluates its arguments locally, so that:

[fdscript] (define my-sentence "Many sentences start with M")
[fdscript] (dtcall "demos@framerd.org" nlparse my-sentence)
(#((#("Many" DETERMINER "many") #("sentences" PLURAL-NOUN "sentence")) 
   (#("start" VERB)) (#("with" PREPOSITION) #("M" NOMINALIZATION "m"))))

does what you would expect.

Remote processing with dtcall can also be initiated from your operating system's command line using the dtcall command; for example:

sh% dtcall demos@framerd.org nlphrase "Other sentences start with other letters"
(#((#("Other" DETERMINER "other") 
    #("sentences" PLURAL-NOUN "sentence")) 
   (#("start" VERB)) 
   (#("with" PREPOSITION) #("other" DETERMINER) 
    #("letters" NOUN "letter"))))

Starting a Server

Starting a server can be as simple as creating a server configuration file and calling the fdserver program on this file. A server configuration file is just a regular Scheme text file, with the suffix (type) .fdz, which may include some special function calls to configure the server.

;; This is the file myfact.fdz
(set-port-id! "fact")
(define (fact n)
  (define (fact-iter i f)
    (if (= i 0) f (fact-iter (- i 1) (* f i))))
  (fact-iter n 1))
(define (help)
  "This server provides an iterative factorial computation 
through the operation FACT")

given this definition, a `local' server can be started with simply the line:

sh% fdserver myfact.fdz ‐‐local &

The ‐‐local argument tells fdserver to run the server "locally", where it can be accessed by the current machine using the hostname localhost but not accessed from anywhere else. The ampersand (&) at the end of the line tells the computer to run the server in the background, so you can type other things at the command line.

Once the server has been started, it can be used remotely from fdscript:

Eval: (define rfact (use-server "fact@localhost" 'fact))
Eval: (rfact 33)
8683317618811886495518194401280000000

It can also be used from the command line (with dtcall):

[haase@buster docs]$ dtcall fact@localhost fact 10
3628800

If the program is started without the ‐‐local argument, as in:

sh% fdserver myfact.fdz &

it can be accessed from other machines with a server id of the form fact@hostname where hostname is the name of the machine running fdserver. As discussed at length in Running DType Servers, this means that any machine on the Internet can connect to the server (if they know about it), but there are numerous ways to restrict access.

FramerD servers are described in detail in the FramerD Server Guide

FDScript includes a novel facility for non-deterministic programming organized around a construct called the choice. A choice describes a set of values which may be any object except another choice. When FDScript encounters a choice, it automatically explores different possible outcomes based on each element of the choice. This makes it very simple to describe certain kinds of processes and operations by characterizing the inputs and outputs of procedures as choices rather than single values.

Choices in FDScript are descended from the AMB operator discussed by John McCarthy and various versions of this idea implemented by David Chapman, Ramin Zabih, David McAllester, and Jeff Siskind. They first entered FramerD in its predecessor language, Framer, as a way of regularizing functions involving multi-valued and single-valued slots.

Choices are distinct from the multiple values provided by Common Lisp and as specified by the R5RS Scheme standard. These facilities allow a procedure to return structured multiple values, where different value positions have different semantics (e.g. the first value might be an x coordinate and the second value might be a y coordinate). Choices in FDScript, on the other hand, represent an unstructured set of values.

Curly braces represent literal choices, so evaluating a choice between 3, 4, and 5 just returns a choice between the three numbers.

[fdscript] {3 4 5}
{3 4 5}

However, adding 10 to the set of choices returns a different set of choices:

[fdscript] (+ {3 4 5} 10)
{13 14 15}

while multiplying the set of choices by itself produces even more options:

[fdscript] (* {3 4 5} {3 4 5})
{9 12 15 16 15 20 25}

Whenever FDScript applies a procedure to a set of choices, it picks each of the choices, applies the procedure, and combines the results; thus, if we define SQUARE as:

(define (square x) (* x x))

and apply it to the same set of choices as above, we get only three choices back, since square is called three times on each single input and that single input is then multipled by itself:

[fdscript] (square {3 4 5})
{9 16 25}

When a procedure returns a non-deterministic value, we can apply another procedure to it, as in:

[fdscript] (+ (square {3 4 5}) 10)
{19 26 35}

Most FDScript procedures work in exactly this way when given non deterministic sets for arguments, passing on any non-determinism in their arguments to their results. However, some procedures work differently by either returning deterministic results for non-deterministic arguments into a single result or taking deterministic arguments and returning a set of choices (a non-deterministic result).

When a procedure returns a non-deterministic result consisting of one choice, that is the same as a deterministic result. This means that a regular procedure can return a deterministic result from non-deterministic argument, as in:

[fdscript] (square {3 -3})
9

Deterministic results from non-deterministic inputs

Built-in procedures for generating deterministic results from non-deterministic inputs include:

• (pick-one set) randomly selects one of the choices in set
• (choice->list set) returns the choices as a list of elements
• (choice-size set) returns the number of choices in set
set
• (empty? expr)
  (fail? expr) returns true if evaluating expr returns no values
• (exists? expr) returns true if evaluating expr returns any values at all
• (contains? val expr) returns true the result of evaluating expr includes val

[fdscript] (PICK-ONE (CHOICE 2 3 4))
3
[fdscript] (PICK-ONE (CHOICE 2 3 4))
2
[fdscript] (CHOICE-SIZE (CHOICE 2 3 4))
3
[fdscript] (CHOICE-SIZE 8)
1
[fdscript] (CHOICE-SIZE {})
0
[fdscript] (FAIL? (CHOICE))
#T
[fdscript] (FAIL? 3)
#F
[fdscript] (EMPTY? (CHOICE 3 4))
#F
[fdscript] (DEFINE (EVEN? x) (if (zero? (remainder x 2)) x (CHOICE)))
[fdscript] (EXISTS? (CHOICE))
#F
[fdscript] (EXISTS? 3)
#T
[fdscript] (EXISTS? (even? (CHOICE 3 5 9)))
#F
[fdscript] (EXISTS? (even? (CHOICE 2 3 5 9)))
#T
[fdscript] (CONTAINS? 2 (CHOICE 2 3 4))
#t
[fdscript] (CONTAINS? 5 (CHOICE 2 3 4))
#f
[fdscript] (CONTAINS? 8 (+ (CHOICE 2 3 4) (CHOICE 4 5 6)))
#t

Non-deterministic results from deterministic inputs

Other built-in procedures generate non-deterministic results from deterministic arguments. The most basic such procedure is CHOICE, which returns its arguments non-deterministically, e.g.

[fdscript] (choice 3 4 5)
{3 4 5}
[fdscript] (+ (CHOICE 3 4 5) 10)
{13 14 15}

while another important one is ELTS which returns the elements of a sequence non-deterministically, e.g.:

[fdscript] (elts '(a b c))
{A B C}
[fdscript] (elts "def")
{#\d #\f #\e}

Failure and Pruning

A procedure can also return no choices at all. This "return value" is called a failure and is indicated by pair of empty curly braces "{}", e.g.

[fdscript] (CHOICE)
{}

when a procedure is called on a failure, the procedure itself returns a failure, so:

[fdscript] (+ (CHOICE 10 8) (CHOICE))
{}

This special result, indicating no returned choices, is called a failure because of the way that choices are used in searching by non-deterministic programming. If you think of a given procedure as doing some `search' given the constraints of its arguments, returning the empty choice can be considered as "failing" in the part of the search.

The early termination on failure is called "pruning." We say that the call to + was pruned because the second call to CHOICE failed. Note that if a subexpression fails in this way, none of the remaining arguments are evaluated, E.G.

[fdscript] (+ (CHOICE) (begin (lineout "last argument") 3))
{}

doesn't produce the output line `last argument' because the whole expression is pruned before the final form is evaluated.

Using Choices to Represent Sets

Non-deterministic return values can be used to represent sets, as in the following definition of set intersection, which specifies the base case and naturally generalizes:

[fdscript] (define (intersect x y) (if (equal? x y) x (fail)))
[fdscript] (intersect (CHOICE 3 4 5 6) (CHOICE 5 6 7 8))
{5 6}

We can see the value combination process in action by adding trace statements to the INTERSECT procedure, as in:

[fdscript] (define (intersect x y) 
            (lineout "INTERSECT " x " = " y " is " (equal? x y))
            (if (equal? x y) x {}))
[fdscript] (intersect (CHOICE 3 4 5) (CHOICE 5 6 7))
    INTERSECT 3 = 5 is #f 
    INTERSECT 3 = 6 is #f
    INTERSECT 3 = 7 is #f
    INTERSECT 4 = 5 is #f
    INTERSECT 4 = 6 is #f
    INTERSECT 4 = 7 is #f
    INTERSECT 5 = 5 is #t 
    INTERSECT 5 = 6 is #f
    INTERSECT 5 = 7 is #f
5

Of course, this is an inefficient way to compute intersections. FDScript provides a number of special forms for dealing with non-deterministic values, which we describe in the next section.

Combining Choices

There are a variety of FDScript special forms for dealing with non-deterministic values. They are called "special" forms because they do not follow the normal rules for non-deterministic procedure combination.

(INTERSECTION expr₁ expr₂)

evaluates expr₁ and expr₂ and returns only the values returned by both expressions. E.G.

[fdscript] (INTERSECTION {3 4 5} {2 4 6})
4

On very large choices, operations like intersection can be very time consuming. FDScript provides a special flavor of choice, the sorted choice which can be optimized for these sorts of operations. The function sorted-choice returns such a choice.

(UNION expr₁ expr₂)

evaluates expr₁ and expr₂ and returns the results from both. E.G.

[fdscript] (UNION {3 4 5} {2 4 6})
{2 3 4 5 6}

(DIFFERENCE expr₁ expr₂)

evaluates expr₁ and expr₂ and returns the results of expr₁ which are not returned by expr₂. E.G.

[fdscript] (DIFFERENCE {3 4 5} {2 4 6})
{3 5}

(TRY expr_i...)

Evaluates each expr_i in order, returning the first one which doesn't fail (e.g. which produces any values at all), E.G.

[fdscript] (TRY (INTERSECTION (CHOICE 3 4 5) (CHOICE 6 7 8)) ; This one fails
               (INTERSECTION (CHOICE 3 4 5) (CHOICE 1 2 3))  ; This one doesn't
               (INTERSECTION (CHOICE 3 4 5) (CHOICE 4 5 6))) ; This one doesn't get a chance
3

Pruning and Special Forms

You may have figured out that non-deterministic evaluation and pruning can't apply to the definitions above or else an expression like:

        (UNION (CHOICE) (CHOICE 3 4))

would automatically be pruned. Some other special forms also break the default rules for combination and pruning. For instance, the formatted output functions such as LINEOUT don't do automatic enumeration and pruning, so you get the following behavior:

[fdscript] (LINEOUT "This is empty: " (CHOICE) " but this isn't: " (CHOICE 2 3))
    This is empty: {} but this isn't: {2 3}

Choices and User Procedures

User procedures (like the procedure INTERSECT which we defined above) automatically invoke the interpreter's search and combination mechanisms. For instance, the following fragment generates possible sentences:

[fdscript] (DEFINE (sentence subject verb object) (list subject verb object))
[fdscript] (sentence (CHOICE "Moe" "Larry" "Curly") 
                  (CHOICE "hit" "kissed")
                  (CHOICE "Huey" "Dewey" "Louie"))
{("Moe" "hit" "Huey") ("Larry" "hit" "Huey") ("Curly" "hit" "Huey") 
            ("Moe" "kissed" "Huey") ("Larry" "kissed" "Huey") 
            ("Curly" "kissed" "Huey") ("Moe" "hit" "Dewey") 
            ("Larry" "hit" "Dewey") ("Curly" "hit" "Dewey") 
            ("Moe" "kissed" "Dewey") ("Larry" "kissed" "Dewey") 
            ("Curly" "kissed" "Dewey") ("Moe" "hit" "Louie") 
            ("Larry" "hit" "Louie") ("Curly" "hit" "Louie") 
            ("Moe" "kissed" "Louie") ("Larry" "kissed" "Louie") 
            ("Curly" "kissed" "Louie")}

The only caveat to the non-deterministic application of user procedures was mentioned above. If a user procedure takes a dotted or optional argument, the argument is bound to a list of the remaining choices rather than a choice among the lists that they would generate. So, this definition calls LINEOUT once on the choice {3 4}:

[fdscript] (define (list-choices . x) (lineout "Results are: " (car x)))
[fdscript] (list-choices (CHOICE 3 4))
    Results are: {3 4}

while this definition calls list-choices separately on the returned values:

[fdscript] (define (list-choices x) (lineout "Results are: " x))
[fdscript] (list-choices (CHOICE 3 4))
    Results are: 3
    Results are: 4

calls list-choices separately on the returned values.

The key point is that if a procedure is expecting a choice as an argument and needs the choice to remain a choice (rather than having its elements enumerated), the argument should be extracted from a "dotted" argument. For instance, suppose we wanted to define a function which returned twice the size of a choice, we might try to write it this way:

[fdscript] (DEFINE (BAD-DOUBLE-SIZE x) (* 2 (choice-size x)))
[fdscript] (BAD-DOUBLE-SIZE 3) ; <== this works fine
2
[fdscript] (BAD-DOUBLE-SIZE {3 4 5 6}) ; <== this doesn't
2

but that won't work because the x argument is bound to each of the numbers in the choice individually, rather than as an entire choice at once. A correct definition would be:

[fdscript] (DEFINE (DOUBLE-SIZE . ARGS) (* 2 (SET-SIZE (CAR ARGS))))
[fdscript] (DOUBLE-SIZE 3) ; <== this still works fine
2
[fdscript] (DOUBLE-SIZE {3 4 5 6}) ; <== and so does this...
8

Choices and variables

Choices can be stored and saved in a variety of ways. For instance, the special form SET! sets a variable to contain a set of possible values, so one can say:

[fdscript] (SET! small-primes (CHOICE 2 3 5 7 11 13 17 19))
[fdscript] (define (divides? x y) (if (zero? (remainder x y)) y {}))
[fdscript] (divides? 15 small-primes)
{3 5}

The SET+! adds a set of values non-deterministically to a variable. For example,

[fdscript] (SET! small-odd-numbers (CHOICE 1 3 5 7))
[fdscript] small-odd-numbers
{5 1 7 3}
[fdscript] (SET+! small-odd-numbers (CHOICE 9 17))
[fdscript] small-odd-numbers
{5 9 1 7 17 3}

The binding special forms LET and LET* can be used to store non-deterministic values in the same way as set!. E.G.

[fdscript] (define (divides? x y) (if (zero? (remainder x y)) y {}))
[fdscript] (let ((small-primes (CHOICE 2 3 5 7 11 13 17 19)))
            (divides? 15 small-primes))
{3 5}

(For old-time Scheme aficianados, this interpretation of LET breaks the equivalence of LET and LAMBDA, since writing the above as an application of a lambda would automatically iterate through the choices..)

Iterating over choices

Sometimes it is important to be able to process each element of a choice separately. FDScript provides three special forms supporting this kind of processing, DO-CHOICES, FOR-CHOICES, and FILTER-CHOICES:

(DO-CHOICES (var val-expr) expr₁ expr₂...)

Evaluates all of the expr_i with var bound to each of the values returned by val-expr. E.G.

[fdscript] (DO-CHOICES (x (CHOICE 3 4)) (lineout "I saw a " x))
    I saw a 4
    I saw a 3

DO-CHOICES can be used to unpack a set of values to pass to forms which don't automatically unpack their arguments (such as LINEOUT), as in the following definition which puts each of the values returned by FGET on a different line:

(define (print-slot-values frame slot)
  (let ((values (fget frame slot)))
    (lineout "The " slot " of " frame " is:")
    (do-choices (value values)
      (lineout "            " value))))

(FOR-CHOICES (var val-expr) expr₁ expr₂...)

Like DO-CHOICES, but combines the results of evaluating the last expr_i for each value, E.G.

[fdscript] (FOR-CHOICES (x (CHOICE 3 4 5 6)) (if (zero? (remainder x 2)) (+ x 3)))
{7 9}

(FILTER-CHOICES (var value-expr) test-expr_i...)

Evaluates value-expr and and binds var to each element and returning those elements for which every test-expr_i returns true given the binding. E.G.

[fdscript] (DEFINE (EVEN? x) (zero? (remainder x 2)))
[fdscript] (FILTER-CHOICES (num (CHOICE 1 2 3 4 5 6)) 
            (EVEN? x))
{2 4 6}
[fdscript] (FILTER-CHOICES (num (CHOICE 1 2 3 4 5 6)) 
            (EVEN? num)
            (< num 6))
{2 4}

FDScript provides fast implementations of sets and association tables using an internal hashing implementation. These functions are similar to those provided by other programming environments, so our descriptions here will be brief.

(make-hashtable)

returns an empty hash table.

(hashtable-get hashtable key)

gets the value(s) associated with key in hashtable.

(hashtable-add! hashtable key new)

adds new to the values associated with key in hashtable.

(hashtable-set! hashtable key new)

makes new be the only values associated with key in hashtable.

(hashtable-zap! hashtable key)

removes any associations with key in hashtable.

For example, the following code stores the squares of the integers from 0 to 199 in a hashtable:

    [fdscript] (define square-table (make-hashtable))
    [fdscript] squares-table
    [#hashtable 0/19]
    [fdscript] (dotimes (i 200) (hashtable-add! square-table i (* i i)))
    [fdscript] squares-table
    [#hashtable 200/271]
    [fdscript] (hashtable-get square-table 20 #f)
    400
    [fdscript] (hashtable-zap! square-table 20)
    [fdscript] (hashtable-get square-table 20 #f)
    {}
    [fdscript] (hashtable-add! square-table 30 300) ; Not true!
    [fdscript] (hashtable-get square-table 30 #f)
    {900 300} ; < Note multiple values

FDScript also provides a "hashset" facility for maintaining large sets of objects with fast tests for membership

(make-hashset)

returns an empty hashset.

(hashset-get hashset elt)

returns true if elt is in hashset.

(hashset-add! hashset elt)

adds elt to hashset.

(hashset-zap! hashset elt)

removes elt from hashset.

(hashset-elts hashset)

returns the elements of hashset as a non-deterministic set.

[fdscript] (define primes-table (make-hashset))
[fdscript] primes-table
[#hashset 0/19]
[fdscript] (hashset-add! primes-table (amb 1 2 3 5 7 11 13 17 19 23 29))
[fdscript] (hashset-get primes-table 15)
#F
[fdscript] (hashset-get primes-table 17)
#T
[fdscript] (hashset-get primes-table 2)
#T
[fdscript] (hashset-zap! primes-table 2)
[fdscript] (hashset-get primes-table 2)
#F
[fdscript] (hashset-elts primes-table)
{1 2 3 5 7 11 13 17 19 23 29}

In addition to hashing primitives, FDScript provides a generic ordering function for many lisp objects, which allows numbers, strings, symbols, pairs, vectors, etc to be placed in a "total order". This ordering is first based on types, with numbers being smaller than all other types and proceeding in order: numbers, characters, symbols, OIDs, strings, pairs, vectors, records, and slotmaps. Objects of the same time are ordered numerically, lexicographically (using Unicode character values), or recursively.

The generic ordering can be accessed through the primitives ANY<? and ANY>?, as in:

[fdscript] (any<? 33 44)
#t
[fdscript] (any<? 33 "forty-four")
#t
[fdscript] (any<? "thirty-three" 44)
#f
[fdscript] (any>? "thirty-three" 44)
#t
[fdscript] (any<? "thirty-three" "three hundred")
#t

The procedure SORTED takes a choice and returns a vector whose elements are sorted by the generic comparision function:

[fdscript] (sorted (choice "abc" "abd"))
#("abc" "abd")
[fdscript] (sorted (choice 110/17 1 2.3))
#(1 2.300000 110/17)

when SORTED is given a second argument, it is a procedure which is used as the key for sorting, for example

[fdscript] (sorted (choice '(3 . "three") '(28 . "twenty-eight")
                       '(3000000000 . "really big"))
	       car)
#((3 . "three") (28 . "twenty-eight") (3000000000 . "really big"))

Sequences are either lists, vectors, strings or packets. Generic functions on sequences include:

(elt sequence index)

returns the indexth element of sequence. For strings, this will be a character, for packets, it will be an integer in the range 0-255, and for vectors and lists it could be any object. This procedure fails (returns the empty choice) if sequence has fewer than index elements.

(reverse sequence)

returns a sequence of the same type with its elements in reverse order.

(length sequence)

returns the number of elements in sequence

(find key sequence)

returns an element of sequence which is EQUAL? to key or #F otherwise.

(position key sequence [start])

returns the position of the first element of sequence after start which is EQUAL? to key or #F otherwise. If start (an integer) is not provided, the absolute first occurence is returned.

(count key sequence)

returns the number of elements of sequence which are EQUAL? to key.

(subseq sequence start [end])

returns the subsequence of sequence starting at start and ending at end (or the end of sequence if end is not specified).

(remove key sequence)

returns a copy of sequence with all elements EQUAL? to key removed.

(search sub-sequence sequence [start])

returns an offset into sequence where sub-sequence starts, or #f otherwise. sequence and sub-sequence need not be the same type. If start is specified, the search starts at the offset start in sequence (but still returns an offset relative to the beginning of sequence).

(mismatch sequence1 sequence2 [start1] [start2])

returns the offset at which sequence1 and sequence2 begin to differ. If start1 and start2 are specified, they indicate starting places in sequence1 and sequence2 respectively.

(doseq (var sequence [index]) body...)

evaluates body repeatedly with each element (in order) bound to var. If the variable index is provided, it is bound to the position in the sequence where the element is found.

(first sequence)

returns the first element of sequence

(second sequence)

returns the second element of sequence

(third sequence)

returns the third element of sequence

(fourth sequence)

returns the fourth element of sequence

(fifth sequence)

returns the fifth element of sequence

FDScript implements Scheme ports as an input and output abstraction. The function open-input-file opens an external file for input; the function open-output-file opens an external file for output. The results of these functions can be used as second arguments to functions like write, display, and newline or as the first argument to printout-to.

The ports returned by these functions can also be made the default port for input or output. The form (WITH-INPUT port ...body...) evaluates body with a default input port of port. Similarly, the form (WITH-OUTPUT port ...body...) evaluates body with a default output port of port.

Variants of this function can take filenames as arguments and implicitly open an input or output file. The form (WITH-INPUT-FROM-FILE filename ...body...) evaluates body with a default input port reading data from filename. Similarly, the form (WITH-OUTPUT-TO-FILE filename ...body...) evaluates body with a default output port writing data to filename.

In addition to file ports, string ports allow programs to read from and write to strings. A string input port reads from a literal string as though it were a file; a string output port accumulates its output in a string which can be extracted along the way. The function (open-string-input-stream string) opens a string input port for reading, e.g.

(define p1 (open-string-input-port "(first) (second)"))
(read p1)
(first)
(read p1)
(second)
(read p1)
#EOF

while the form (open-string-output-stream) creates a stream for output whose "output thus far" can be extracted with STRING-STREAM-CONTENTS, e.g.

(define p2 (open-string-output-stream))
(write '(first) p2)
(write '(second) p2)
(string-stream-contents p2)
"(FIRST)(SECOND)"

String streams can also be used implicitly with the form (WITH-OUTPUT-TO-STRING ...body...) which evaluates body with output going (by default) to a string whose value is returned. Thus, we can say:

(with-output-to-string (write '(first)) (write '(second)))
"(FIRST)(SECOND)"

or with the form (WITH-INPUT-FROM-STRING string ...body...) which evaluates forms given default input from the string string, e.g.

(with-input-from-string "33+5i 44.5"
  (list (read) (read)))
(33+5i 44.5)

Binary I/O

A binary input or output file can be opened by using the fopen function with a "b" mode to get an input or output port. The functions read-byte and write-byte will read integer-valued bytes from such streams.

The function write-data can be used to write a packet to a file or output stream. (write-data packet stream-or-filename) writes the bytes in a packet directly to the output stream.

DTypes can be written to binary output ports with the function write-dtype and read with the function read-dtype.

An object's DTYPE representation can be written to a file with write-dtype-to-file; a DTYPE representation for an object can be added to the end of a file with the function add-dtype-to-file. These can be used together with read-dtype-from-file to accumulate a set of objects in a file.

DTypes can also be written to packets with the function write-dtype-to-packet and read from packets with the function read-dtype-from-packet. For example,

[fdscript] (write-dtype-to-packet "foo")
[#PACKET 8 0x0600000003666f6f]
[fdscript] (write-dtype-to-packet "föb")
[#PACKET 9 0x400206006600f60062]
[fdscript] (write-dtype-to-packet 88)
[#PACKET 5 0x0300000058]

Direct binary I/O is possible with four functions:

read-byte

Reads a single byte from the stream as an integer between 0 and 255

FDScript also provides a number of functions for accessing operating system functions. These are useful for tracking resources, converting non-FramerD data into FramerD data, and other operations.

Environment access

(getenv var)

looks up the value associated with the string var in the following places:

• the global FDScript environment (potentially modified by configuration files or profiles)
• (under WIN32) the Windows Registry, under the key "Software\\FramerD\\environment\\var" beneath both the user and local machine roots
• through the ANSI standard function getenv on the variable var

For example,

    [fdscript] (fdgetenv "USER")
    "haase"
    [fdscript] (getenv "SUPER_POOL")
    "/usr/local/share/framerd/super-pool"

(getenv var)
uses the C library function getenv to get the value of the environment variable var, e.g.

    [fdscript] (cgetenv "TERM")
    "VT100"

(timestring)
returns a string representing the current time, e.g.

    [fdscript] (timestring)
    "15:45"

(session-id)
returns a string representing the current FDScript session, e.g.

    [fdscript] (session-id)
    "framerd: haase@eliza.media.mit.edu OS:Digital Unix Release:Jan 24 1997 Fri Jan 24 23:50:03 1997"

(system printout-args...)
Combines printout-args to make a command line which it passes to the default command intepreter. For example,

[fdscript] (define filename "badfile")
[fdscript] (system "rm " filename)
0
[fdscript] (system "rm " filename) ; Already gone
rm: cannot remove `foobar': No such file or directory
256

(CD dir)
(CWD dir)
changes the current working directory to be dir.

Exploring the Filesystem

FDScript uses strings to represent files and directories in the file system. The file system can be explored by the functions GETFILES and GETDIRS. GETFILES takes a directory name and returns all of the files it contains; GETDIRS also takes a directory name but returns all of the subdirectories it contains. The following procedure gets all of the files recursively underneath a particular directory, taking advantage of getfiles, getdirs, and FDScript's automatic non-determinism:

(define (allfiles dir)
  (choice (getfiles dir)
          (allfiles (getdirs dir))))

These predicates can be applied to give information about a file given its name:

• (file-exists? filename) returns true if filename exists
• (file-writable? filename) returns true if filename can be modified
• (directory? filename) returns true if filename is a directory
• (symbolic-link? filename) returns true if filename is a symbolic link
• (regular-file? filename) returns true if filename is a regular file (not a directory or a symbolic link)

The following functions can be applied to pathnames to generate other pathnames or components of pathnames:

• (fullname path) returns a complete pathname (based at the file system root) given a relative pathname.
• (basename path) returns a the final part of a pathname, with the directory component removed.
• (dirname path) returns the initial part of a pathname, just the directory.
• (readlink path) returns the target of a link or the file itself otherwise.

Other information about particular files can be determined with these functions:

• (file-size filename) returns the size (in bytes) of a regular file
• (file-access-time filename) returns the last time a file was accessed, as a timestamp object
• (file-creation-time filename) returns the time at which a file was created, as a timestamp object
• (file-modification-time filename) returns the last time at which a file was modified, as a timestamp object
• (file-size filename) returns the number of bytes comprising a file
• (file-owner filename) returns a string describing the owner of filename

The predicate (FILE-OLDER? file1 file2) returns true if file1 is older than file2.

User-specific Information

• (get-user-data)
  (get-user-data username)
  (get-user-data numeric-userid) returns information about a specified user, defaulting to the current user.

  [fdscript] (get-user-data)
  #[UID 31406
    GID 501
    UNAME "haase"
    TEXT-DATA "Kenneth Haase"
    HOMEDIR "/local/haase"
    SHELL "/bin/bash"]
  [fdscript] (get-user-data "root")
  #[UID 0 GID 0 UNAME "root" TEXT-DATA "root" HOMEDIR "/root" SHELL "/bin/bash"]
  [fdscript] (get-user-data 0)
  #[UID 0 GID 0 UNAME "root" TEXT-DATA "root" HOMEDIR "/root" SHELL "/bin/bash"]
  

• (get-homedir) returns the absolute pathname of the current user's home directory.

  [fdscript] (get-homedir)
  "/local/haase"
  

Accessing the Web

FDScript also has builtin functions for getting documents from the World Wide Web. The function URLSTRING returns the content of a remote URL as a string, trying to use any information the server sends about character set and encoding. This will signal an error if the retrieved object does not have a MIME text type.

The function URLGET is more general and returns a slotmap describing a generalized mime type document parsed by FramerD's internal MIME parser.

Functions Dealing with Time

The basic time structure in FramerD is the timestamp which comes in two flavors: simple timestamps which represent moments with a precision of seconds and complex timestamps which representation moments with varying degrees of precision (days, seconds, milliseconds, microseconds, etc) and also carry timezone information.

• (timestamp)
  (timestamp string)
  (timestamp string timezone)
  (timestamp timestamp timezone)
  Returns a timestamp object. Without an argument or with #f as an argument, the timestamp describes the current moment; with an argument, the string is parsed as an ISO-8601 formatted time, e.g. 1990-01-20T15:00:00-5:00 describes the 20th of January, 1990 at 3pm in the afternoon (Easter Standard Time) while 1990-01-20T20:00:00GMT describes the same moment in Greenwich Mean Time. When the timezone argument is provided it either changes the timezone of the first argument (keeping the moment the same) or is used in interpreting it. For example, (timestamp "199O-01-20T15:00:00EST" "GMT") would return a timestamp which prints out as 1990-01-20T20:00:00UTC.
• (xtimestamp)
  (xtimestamp precision)
  (xtimestamp timestamp precision)
  Returns a timestamp object with a particular precision. With no arguments, it returns a timestamp with the greatest possible precision; with one argument, it returns a timestamp with a particular precision (providing that timestamp is Precision can be a symbol year, month, day, hour, minute, second, millisecond, microsecond, or nanosecond. For example, (xtimestamp #f 'millisecond) returns something like .
• (get-month)
  (get-month timestamp)returns a symbol denoting the current month or the month of a particular timestamp (in the local timezone), e.g. (get-month) ==> MARCH.
• (get-year) Gets the current year (AD), e.g. (get-year) ==> 1997
• (get-hour) Gets the current hour (hours since midnight), e.g. (get-hour) ==> 14
• (get-season) Gets the current season, being ambiguous on the edges, e.g. (get-season) ==> {winter spring}
• (get-day) returns a symbol describing the current day of the week, e.g. (get-day) ==> THURSDAY
• (get-daytime) Returns a symbol describing the current time of day, being ambiguous on the edges, e.g. (get-daytime) ==> {afternoon evening}

Accessing the WIN32 Registry

Under WIN32, FDScript also provides some access to the Windows Registry. The registry can be used to store fixnums, strings, lists of strings, and binary data packets. The functions to use are:

(registry-get path entry)

looks up the value associated with the string entry under the registry key path. This does a search which first looks in the "Current User" tree and then looks in the "Local Machine" tree, returning the first branch to have a matching entry. It returns the empty set if the entry is not defined. E.G.

    [fdscript] (registry-get "Software\\MUSOFT\\framerd" "super-pool")
    xxx

(registry-set! path entry value)

changes the value associated with the string entry under the registry key path. This does a search which first looks in the "Current User" tree and then looks in the "Local Machine" tree, changing the first branch to have a matching entry. It is created in the user tree if the entry is not defined in either entry. E.G.

[fdscript] (registry-set! "Software\\MUSOFT\\etc" "birthday" 22197)
#t
[fdscript] (registry-get "Software\\MUSOFT\\etc" "birthday")
22197

These functions can be combined with the functions write-dtype-to-packet and read-dtype-from-packet to store arbitrary LISP objects in the registry, e.g.

[fdscript] (registry-set! "Software\\MUSOFT\\etc" "example"
              (write-dtype-to-packet '("example" 1)))
#t
[fdscript] (read-dtype-from-packet (registry-get "Software\\MUSOFT\\etc" "example"))
("example" 1)

Counting Resources

The procedure (resources) returns a slotmap containing various implementation-dependent resource information, e.g.

[fdscript] (resources)
#[MEMORY: 688 SWAPS: 0 USER-USECS: 57584 SYSTEM-USECS: 103456
  CONSES: 746 MALLOCD: 264 CONS-MEMORY: 12232 REFERENCED-OIDS: 0
  LOADED-OIDS: 0]

The function GET can be used to extract fields from a slotmap, E.G.

[fdscript] (get (resources) 'cons-memory)
167218

The (clock) function returns the number of microseconds of processing time expended since the first time clock was called:

[fdscript] (clock)
0
[fdscript] (clock)
1652000

The (memusage) function returns the number of KBytes of memory being used by the data of the current process. This is based on the operating system's accounting.

The (consusage) function returns the number of bytes of memory being used by the current process. This uses FramerD's own accounting methods rather than the operating systems and also leaves out conses which have been allocated but are not currently being used.

Accessing and modifying configuration information

FramerD installations and applications are customized by configuration files loaded when the installations or applications start up. A configuration file is a set of variable bindings which are established when the configuration file is loaded. No expressions are evaluated (which makes them somewhat safer), but the configuration file can define or redefine default values as well as adding values to variables which are already defined (potentially making them into choices).

Every FramerD application loads the "system configuration" file; interactive applications generally also load a "user profile" containing user specific information. In addition, the executables fdscript and fdserver both take arguments of the form ‐‐config=file to specify additional configuration files. These files can be manipulated from the system command line with the scripts fdconfig, fdprofile, and fdcfg as described in the user's guide In addition, configuration files can be modified from the evaluator by several primitives.

(CONFIG-SET! file var val) sets var in file to have the value val.

(CONFIG-ADD! file var val) adds the value val to the binding of var specified in file. If file already defines var, val is just added to the values there. If file doesn't define var, val is added as an augmentation, so that it will be added to any existing value when the config file is loaded.

(CONFIG-RESET! file var) removes any values associated with var in file.

Internationalization

FramerD and FDScript both use Unicode internally to represent characters, strings, and symbols. This means that programs and data can include characters from hundreds of national languages at the same time. Thus a FramerD frame can have one slot containing data as greek characters, another containing different data in Japanese Kanji, and yet another slot in the Korean Hangul character set.

All of the string and character functions work with Unicode strings, as in:

[fdscript] (subseq "Êtes-vous parlé français?" 0 4)
"Êtes"
[fdscript] (position #\ç "Êtes-vous parlé français?")
20
[fdscript] (string-upcase "Êtes-vous parlé français?")
"ÊTES-VOUS PARLÉ FRANÇAIS?"

Unmarked versions of characters can be extracted with the functions CHAR-BASE CHAR-LOWER-BASE:

[fdscript] (char-base #\ç)
#\c
[fdscript] (char-lower-base #\Ê)
#\e

Similar functions existing for strings

[fdscript] (string-base  "Êtes-vous parlé Français?")
"Etes-vous parle Francais?"
[fdscript] (string-lower-base  "Êtes-vous parlé Français?")
"etes-vous parle francais?"

permitting canonicalization of strings from various languages. However, the result is not guaranteed to be an ASCII string, as in:

[fdscript] (string-base "I hope to döss at the Schloß")
"I hope to doss at the Schloß"

FDScript also supports a diversity of external character encodings, allowing it to read and emit data in many different character sets. A character set is a mapping from some external character encoding into the Unicode representation used by FramerD. The contents of a file with a particular encoding can be converted into a string with the function FILESTRING whose second argument specifies the encoding. For example,

(filestring "xx.txt" "latin-1")

(filestring "john1.txt" "latin-7")

A packet (a byte vector) can be converted into a string by the function packet->string and converted back by the function string->packet, both of which require a character set specifier. For example, using the FILEDATA function to get the above file as a packet:

(packet->string (filedata "sassure1.txt"))

(string->packet "")

(equal? (string->packet "") "")
#t

The encoding of a program source file can be specified in several ways:

• the second argument to load can specify a character set, e.g. (load "zh-parser.scm" "BIG5")
• the file can call the function set-file-encoding! to change the encoding being used for the current file being loaded, e.g (set-file-encoding! "koi8")
• the head of the file can include a special line of the form -*- text-encoding: latin-2 -*-

If the encoding of a file is not specified, a default encoding is used. This default encoding can be set in numerous ways:

• after an application has started, the function set-default-encoding! can be used, as in (set-default-encoding! "latin-1")
• when an fdscript listener is started, a command line option such as ‐‐charset=koi8 can be specified;
• before the application launches, the environment or config variable CHARSET can be set

This default encoding is also used for interactions with the console, unless it is overridden by the function set-console-encoding!.

Regardless of the character encoding in force, unicode characters can always be entered as unicode escapes (modelled on Java) of the form \uxxxx or \Uxxxxxxxx (differing in case). Where xxxx or xxxxxxxx are the hexadecimal codes for the corresponding unicode characters. The interpretation of these escape sequences happens at a very low level, so they keep their syntactic character. Thus, the following will be parsed as a string:

[fdscript] \u0022foo\u0022
"foo"

The character sets built into FramerD include all of the ISO-8859 character sets as well as the KOI-8 character set for the Russian language. In addition, FramerD is able to read the mapping files provided by the Unicode consortium. These files can be found at ftp://ftp.unicode.org/pub/mappings/ and installed with .

;; This is the file fdlog.fdz
(sdefine (log x)
  (add-dtype-to-file x "log.dtype"))

[fdscript] (define filename "test.fdx")
[fdscript] (system "chmod a+x " filename)
1

[fdscript] (define xx (open-process "fdscript" "-"))
;; Nothing (void) was returned
;; Values changed (1): XX
[fdscript] (printout-to (subjob-input xx) '(+ 2 3 (* 4 5)) "\n")
;; Nothing (void) was returned
[fdscript] (readline (subjob-output xx))
"25"

[fdscript] (define sock (open-socket "framerd.org" "http"))
;; Nothing (void) was returned
;; Values changed (1): SOCK
[fdscript] (printout-to (subjob-input sock) "GET /\n")
;; Nothing (void) was returned
[fdscript] (flush-output (subjob-input sock))
#t
[fdscript] (readline (subjob-output sock))
""
[fdscript] (readline (subjob-output sock))
""
[fdscript] (readline (subjob-output sock))
""

[fdscript] (signals-error? (+ 2 3))
#f
[fdscript] (signals-error? (+ 2 'a))
[#ERROR ("Type Error" "+: not an integer" A)]

[fdscript] (define errobj (signals-error? (+ 2 'a)))
#f
[fdscript] errobj
[#ERROR ("Type Error" "+: not an integer" A)]
[fdscript] (error? errobj)
#T
[fdscript] (error-exception errobj)
"Type Error"
[fdscript] (error-details errobj)
"+: not an integer"
[fdscript](error-irritant errobj)
A

[fdscript] (signals-error+? (+ 2 3))
#f
;;+1: 5

[fdscript] (define (test-eval expr)
             (multiple-value-bind (error? result) (signals-error+? (eval expr))
               (if error? (lineout "Evaluating " expr " signalled " error?)
                   (lineout "Evaluating " expr " returned " result))))
[fdscript] (test-eval '(+ 2 3))
Evaluating (+ 2 3) returned 5
[fdscript] (test-eval '(+ 2 a))
Evaluating (+ 2 A) signalled [#ERROR ("Variable is unbound" "EVAL" A)]
[fdscript] (test-eval '(+ 2 'a))
Evaluating (+ 2 'A) signalled [#ERROR ("Type Error" "+: not an integer" A)]

(module-export! 'whois)

(module-export! '{whois whereis})

[fdscript] (tx-match '(isalnum+) "haase")
#t

[fdscript] (tx-match '(isalnum+) "haase@media")
#f

[fdscript] (tx-match '(isalnum+) "häse")
#t

[fdscript] (tx-match '#((isalnum+) "@" (isalnum+))  "haase@media")
#t

[fdscript] (tx-match '#((isalnum+) {"@" "%"} (isalnum+))  "haase%prep.ai.mit.edu")
#t

[fdscript] (tx-match '#((isalnum+) {"@" "%" (ispunct)} (isalnum+))  "haase-media")
#t

(define user-name '(isalnum+))
(define host-name
  {(isalnum+)
   #((isalnum+) "." (isalnum+) ".edu")
   #((isalnum+) "." (isalnum+) "." (isalnum+) ".edu")
   #((isalnum+) "." (isalnum+) "." (isalnum+) "." (isalnum+) ".edu")})
[fdscript] (tx-match (tx-closure '#(user-name "@" host-name))
                     "haase@media.mit.edu")
#t

[fdscript] (tx-extract '#((isalnum+) "@" (isalnum+))  "haase@media.mit.edu")
#("haase" "@" "media.mit.edu")

[fdscript] (tx-extract (txc #(user-name "@" host-name)) "haase@media.mit.edu")
#("haase" "@" "media.mit.edu")

[fdscript] (tx-extract (vector user-name "@" host-name))
#("haase" "@" #("media" "." "mit" ".edu"))

[fdscript] (tx-search '(isdigit+) "My name is 007, JAMES 007")
11

[fdscript] (tx-matcher '(isdigit+) "123ABC")
3

[fdscript] (tx-gather '(isdigit+) "There were 12 grapes and 66 apples")
;; There are 2 results
{"12" "66"}

[fdscript] (read-from-string
             (tx-gather '(isdigit+) "There were 12 grapes and 66 apples"))
;; There are 2 results
{12 66}

(define vowels '(+ {"a" "e" "i" "o" "u"}))
[fdscript] (tx-segment "How long has it been?" vowels)
("H" "w l" "ng h" "s " "t b" "n?")

[fdscript] (apply string-append (tx-segment "How long has it been?" vowels))
"Hw lng hs t bn?"

[fdscript] (tx-fragment "How long has it been?" vowels)
("" "H" "o" "w l" "o" "ng h" "a" "s " "i" "t b" "ee" "n?")

[fdscript] (apply string-append
              (tx-fragment "How long has it been?" vowels))
"How long has it been?"

[fdscript] (tx-match '(char-not "+-") "333.5")
#t
[fdscript] (tx-match '(char-not "+-") "333.5+5i")
#f

[fdscript] (tx-match '(char-range #\a #\z) "a")
#t
[fdscript] (tx-match '(char-range #\a #\z) "m")
#t

[fdscript] (tx-match '(* {"hum" "dum" "doo" "de"}) "humdumdoodedum")
#t

(tx-extract '(* {"hum" "dum" "doo" "de"}) "humdumdoodedum")
(* "hum" "dum" "doo" "de" "dum")

[fdscript] (tx-extract '(* #((isalnum+) {(eol) (isspace+) #("," (isspace+))}))
                       "foo bar baz")
(* #("foo" " ") #("bar" " ") #("baz" ""))
[fdscript] (tx-extract '(* #((isalnum+) {(eol) (isspace+) #("," (isspace+))}))
                       "foo, bar, baz, quux")
(* #("foo" #("," " ")) #("bar" #("," " "))
   #("baz" #("," " ")) #("quux" ""))

[fdscript] (tx-match '(* #((isalnum+) {(eol) (isspace+) #("," (isspace+))}))
                     "")
#t

[fdscript] (tx-match '(* #((isalnum+) {(eol) (isspace+) #("," (isspace+))}))
                     ",")
#f

[fdscript] (tx-match '(+ #((isalnum+) {(eol) (isspace+) #("," (isspace+))}))
                     "")
#f

[fdscript] (tx-match '(+ #((isalnum+) {(eol) (isspace+) #("," (isspace+))}))
                     "cook")
#t

[fdscript] (tx-match '(not (isalpha+)) "good")
#f

(tx-match "Good" "good")
#t

[fdscript] (tx-match '(match-case "Good") "good")
#f

[fdscript] (tx-match
            '(match-case #("Good" ", " (ignore-case "BAD") ", " "Ugly"))
            "Good, bad, Ugly")
#t

[fdscript] (MD5 "I feel so unique")
[#PACKET 16 0x6a145c9f21b7cc4fe8a488ad59b34267]

[fdscript] (MD5 (write-dtype-to-packet '(SENTENCE "I am hungry")))
[#PACKET 16 0xbf2e69fd6c8b5023c9e73510c40260f3]

[fdscript] (refpoints "Elvis and Princess Di met at the House of Blues
in Tusla, Oklahoma.  They listened to `Boogie-Woogie Bugle Boy' on the juke
box.")
{;; There are 7 results
 "Tusla" "Princess Di" "Elvis" "Blues"
 "House" "Boogie-Woogie Bugle Boy" "Oklahoma"}

[fdscript] (parse-timestring "July 4, 1976 11:10 PM")
#<"1976-07-04T18:10:00GMT">

(stem-word "trees")
"tree"
(stem-word "meeting")
"meet"
(stem-word "meets")
"meet"
(stem-word "flies")
"fli"
(stem-word "flying")
"fly"

(define rules {
  #("ing" "") #("ed" "") #("s" "") #("ies" "y")
  #("nning" "n") #("nned" "n")})
(define roots {"cook" "fly" "skin"})
[fdscript] (morphrule "cooking" rules roots)
"cook"
[fdscript] (morphrule "flying" rules roots)
"fly"
[fdscript] (morphrule "flies" rules roots)
"fly"

[fdscript] (parse-html (filestring "test.html"))
((BODY () 
    ("\n" 
     (P () ("This is a test of " (STRONG () ("FramerD")) " HTML parsing\n")) 
     (P ((ALIGN "RIGHT")) ("It has several paragraphs\n")) "\n")))

This is a test of FramerD HTML parsing
It has several paragraphs

[fdscript] (parse-xml (filestring "test.html"))
[16:04:07 P entity closed with (BODY ())]
((BODY () 
    ("\n" 
     (P () 
        ("This is a test of " (STRONG () ("FramerD")) " HTML parsing\n" 
         (P ((ALIGN "RIGHT")) ("It has several paragraphs\n")) "\n")))))

[fdscript] (unparse-html (parse-html (filestring "test.html")))

This is a test of FramerD HTML parsing
It has several paragraphs

;; Nothing (void) was returned

[fdscript] (read-mime (filestring "test-message"))
#[FROM "haase@media.mit.edu"
  TO "walter@media.mit.edu"
  CONTENT "Looks like it's going to happen

‐‐ Ken
"]

[fdscript] (get-mailids "I heard that fdr@whitehouse.gov thinks hitler@reich.org is a fascist.")
{"fdr@whitehouse.gov" "hitler@reich.org"}

#!/usr/local/bin/fdscript

#!/usr/local/bin/fdscript
;; This is the file square.fdx
(define (square x) (* x x))
;; PARSE-ARG will convert a string to a number
(define (main x) (square (parse-arg x)))

sh% square.fdx 10
100

sh% fdinstall-script find-sense.fdx find-sense
sh% find-sense dog animal
@/brico/f902("dog" "domestic_dog" "Canis_familiaris")
sh% find-sense dog person
@/brico/185c6("cad" "bounder" "blackguard" "dog" "hound" "heel")
@/brico/18651("dog")
@/brico/18b22("frump" "dog")

(macro (expr) body...)

(define push
 '(macro (expr)
   `(set! ,(caddr expr) (cons ,(cadr expr) ,(caddr expr)))))

[fdscript] (define atoms '())
[fdscript] (push 'x atoms)
[fdscript] (push 'y atoms)
[fdscript] atoms
(Y X)
[fdscript] (let ((nums '()))
             (dotimes (i 5) (push i nums))
             nums)
(5 4 3 2 1)

(define attributes #(" " (not> {">" "/"})))
(define element-pattern
  (tx-closure #("<" {"" "/"} (isalnum+) {"" attributes} {"" "/"} ">")))
(define (empty-string? x) (= (length x) 0))
(define (xml-parser-loop rs content-fn stack)
  ;; Read the content and process it
  (let ((content (read-spacing rs))) (content-fn stack content))
  ;; Get fresh markup
  (let* ((markup (read-record rs)))
    (if (eof-object? markup)
	(cond ((null? stack) 'ok)
	      (else (lineout "File ended early at " stack)
		    stack))
	;; If there is some, extract it structure and branch
	(let* ((extraction (tx-extract element-pattern markup))
	       (start-element (empty-string? (vector-ref extraction 1)))
	       (empty-element (not (empty-string? (vector-ref extraction 4))))
	       (tag (vector-ref extraction 2))
	       (attribs (vector-ref extraction 4)))
	  (cond (empty-element ;; empty elements have null content
		 (content-fn (cons (cons tag attribs) stack) "")
		 (xml-parser-loop rs content-fn stack))
		(start-element ;; start elements push onto the stack
		 (xml-parser-loop rs content-fn 
				  (cons (cons tag attribs) stack)))
		((equal? tag (car (car stack)))
		 ;; Matching non-start non-empty elements pop the stack
		 (xml-parser-loop rs content-fn (cdr stack)))
		(else
		 ;; anything else reports an error and returns the stream
		 (lineout "Element mismatch, started with "
		   (car (car stack)) " ended with "
		   tag)
		 rs))))))
(define (xml-parser filename content-fn)
  (let ((stream (open-record-stream filename element-pattern)))
    (xml-parser-loop stream content-fn '())))
(define (test-fn stack content)
  (lineout "Stack is " stack)
  (printout "  at content: ") (print content))

This is a test.  This is a bold statement about our
image ().

[17:08:30 MIT FramerD library 2.2 (C) 1994-2000, built Mar 19 2001]
[fdscript] (load "mini-xml.fdx")
;; Nothing (void) was returned
;; Values changed (6): ATTRIBUTES EMPTY-STRING? ELEMENT-PATTERN XML-PARSER-LOOP XML-PARSER TEST-FN
[fdscript] (xml-parser "mini.xml" test-fn)
Stack is ()
  at content: ""
Stack is (("P" . ""))
  at content: "This is a test.  This is a "
Stack is (("bold" . "") ("P" . ""))
  at content: "bold"
Stack is (("P" . ""))
  at content: " statement about our\nimage ("
Stack is (("img" . "/") ("P" . ""))
  at content: ""
Stack is (("P" . ""))
  at content: ")."
Stack is ()
  at content: "\n\n\n"
OK