Storing sessions in a database is a good solution. Backups are easier; persistence and pruning orphaned sessions are simpler. Security is available through the database server’s security. We will use MySQL, since it is the best supported in newLISP.

Setting up the database

First, we need a table in which to store session data. Using a MySQL TIMESTAMP column will provide us with an automatically updating time stamp on the last modification of the session, which we will use below to find old sessions to remove.

CREATE TABLE sessions (
	sid VARCHAR(255) PRIMARY KEY,
	DATA TEXT NOT NULL,
	ts TIMESTAMP
)

Designing the storage module

Several functions need to be defined to handle storing data. First, we must ensure that the MySQL module is loaded and initialized. We will do this in a separate module that we will call DBSessions.

(context 'DBSessions)
 
(unless (sym "MYSQL" 'MySQL nil) ; do not reinitialize if already loaded
  (module "mysql5.lsp") ; with newlisp 10.1, this will change to "mysql.lsp"
  (MySQL:init)
  (MySQL:connect "127.0.0.1" "user" "secret" "somedb"))
 
(context 'MAIN)

Next, we define a function to create or resume a session from the database. Sessions are stored in memory as contexts, making our job easier. Our function will query MySQL to see if the session id exists, and either create a new session and insert it or retrieve an existing session and load it. The function Web:session-id gives us the current session id from the session cookie or creates a new one and sends the client a cookie to store it. Web:session-context returns a symbol pointed to the context storing the current session.

(define (open-session)
  (when (MySQL:query (format "SELECT data FROM sessions WHERE sid = '%s'" (MySQL:escape (Web:session-id))))
    (let ((data (MySQL:fetch-row)))
      (if data
        ;; Evaluate the serialized context into the current session context
        (eval-string (first data) (Web:session-context))
        ;; Create a new session and save it
        (MySQL:query (format "INSERT INTO sessions (sid, data) VALUES ('%s', '%s')"
          (MySQL:escape (Web:session-id))
          (MySQL:escape (source (Web:session-context)))))))))

Next, we need a function to write any changes to the session to storage. Since the session is stored as a context, this is quite simple.

(define (close-session)
  (MySQL:query (format "UPDATE sessions SET data = '%s' WHERE sid = '%s'"
    (MySQL:escape (source (Web:session-context)))
    (MySQL:escape (Web:session-id)))))

We also need a function to delete entire sessions when necessary. This is also simple.

(define (delete-session)
  (MySQL:query (format "DELETE FROM sessions WHERE sid = '%s'"
    (MySQL:escape (Web:session-id)))))

Finally, a function to cull old sessions from the database. For this, we use the variable Web:SESSION_MAX_AGE to determine which sessions have expired.

(define (clean-sessions)
  (MySQL:query (format "DELETE FROM sessions WHERE NOW() >= DATE_ADD(ts, INTERVAL %d SECOND)"
    Web:SESSION_MAX_AGE)))

Registering the handler in Web

Last, the handler functions need to be registered in the Web module.

(Web:define-session-handlers
  open-session close-session delete-session clean-sessions)

Putting it all together

(unless (sym "MYSQL" 'MySQL nil) ; do not reinitialize if already loaded
  (module "mysql5.lsp") ; with newlisp 10.1, this will change to "mysql.lsp"
  (MySQL:init)
  (MySQL:connect "127.0.0.1" "user" "secret" "somedb"))
 
(context 'DBSessions)
 
(define (open-session)
  (when (MySQL:query (format "SELECT data FROM sessions WHERE sid = '%s'" (MySQL:escape (Web:session-id))))
    (let ((data (MySQL:fetch-row)))
      (if data
        ;; Evaluate the serialized context into the current session context
        (eval-string (first data) (Web:session-context))
        ;; Create a new session and save it
        (MySQL:query (format "INSERT INTO sessions (sid, data) VALUES ('%s', '%s')"
          (MySQL:escape (Web:session-id))
          (MySQL:escape (source (Web:session-context)))))))))
 
(define (close-session)
  (MySQL:query (format "UPDATE sessions SET data = '%s' WHERE sid = '%s'"
    (MySQL:escape (source (Web:session-context)))
    (MySQL:escape (Web:session-id)))))
 
(define (delete-session)
  (MySQL:query (format "DELETE FROM sessions WHERE sid = '%s'"
    (MySQL:escape (Web:session-id)))))
 
(define (clean-sessions)
  (MySQL:query (format "DELETE FROM sessions WHERE NOW() >= DATE_ADD(ts, INTERVAL %d SECOND)"
    Web:SESSION_MAX_AGE)))
 
(Web:define-session-handlers
  open-session close-session delete-session clean-sessions)
 
(context 'MAIN)

Submit article

The official CGI module has some real issues. First, it combines POST and GET variables into a single structure. This has two serious consequences: 1) the application has no way to determine the method by which a parameter is passed (that information is completely lost), and 2) name clashes between GET and POST result in the loss of one or the other parameter (in the case of the CGI module, GET information would be overwritten.)

Another issue in the CGI module is with the put-page function, which breaks if “%>” is used inside of a code island, even legitimately, such as in a string.

Web fixes both of these problems and provides a number of other features, including:

• ASP/PHP-style templates
• Getting/setting cookies, GET, and POST parameters
• Entity encoding and decoding
• HTTP header control
• Sessions
• Custom session storage
• URL building and parsing
• URL encoding and decoding
• Query string building and parsing

Additionally, Web does not suffer from the GET/POST issues that the CGI module does, nor does it mishandle tags inside of code.

HTTP Headers

Headers are set using Web:header, which accepts two parameters – the header name and the header value. By default, one header is already set: Content-type: text/html. Headers are output using Web:send-headers, which is called before any other output. The convenience function Web:redir redirects the browser to the passed URL.

GET and POST

GET and POST variables are accessed using Web:get and Web:post, which may be called in two ways. When called with a single parameter, these functions act like lookup and return the GET/POST parameter with the named key. When called with no parameters, they return an association list of the corresponding query.

Cookies

Cookies must be set before headers are sent. They are set using the Web:cookie function, which accepts up to six parameters.

;; Set a basic cookie
(cookie "foo" "bar")
;; Access a cookie value
(cookie "foo")
;; Delete a cookie by setting expires to now
(cookie "foo" nil (date-value))
;; Set a cookie that expires in an hour
(cookie "foo" "bar" (+ (date-value) (* 60 60)))

See the documentation for a full list of accepted parameters.

Sessions

By default, sessions use file-based storage (located at /tmp). They are controlled with a few simple functions. The default exit function is wrapped to ensure that Web:close-session is called at the end of a script (at least, a script that calls exit at its end.)

(Web:open-session)
(Web:session "foo" "bar") ; store "foo" as "bar"
(Web:send-headers) ; start output
(println "<p><strong>foo is:</strong> " (Web:session "foo") "</p>")
(exit 0)

It is a simple matter to design and use custom storage handlers. The function Web:define-session-handlers allows customization of which functions are called to begin/load, close/write, delete a session, and clear old sessions. See the documentation for a list of helpful functions and variables for custom storage handlers.

Templates

Templates work almost identically to the official CGI module, with a few differences. First, Web:eval-template is called with a string, rather than a file, to permit other storage methods and programmatic building of templates. Second, <%= .. %> may be substituted for the default opening tag as a shortcut for <% (print … ) %>. Last, the opening and closing tags may be customized by setting values of Web:OPEN_TAG and Web:CLOSE_TAG. The shortcut tag will always be Web:OPEN_TAG appended with and equal sign.

Encoding and decoding

There are several functions to make encoding, decoding, and escaping strings easier for dealing with URLs, javascript, and HTML entities.

Web:escape takes a string and encodes the basic HTML character entities (apostrophe, quote, ampersand, and left and right angle brackets.) Web:unescape provides the reverse. The function Web:escape-js does no encoding of entities, but instead ensures that a string may be safely output in javascript string without causing syntax errors.

Web:encode-entities encodes all HTML entities, including a number of entities that are not fully supported by all browser. The full list of entities is derived from Wikipedia. Its reverse, Web:decode-entities, translates entities back into their character equivalents.

The functions Web:url-encode and Web:url-decode deal with hex-encoding/decoding strings for use in URLs.

Query strings are easily created using Web:build-query, modeled after the PHP function http_build_query. Its counterpart, Web:parse-query, takes a query string and turns it into an association list.

For URLs, it is simpler to use Web:build-url, which takes a URL and any number of association lists which it uses to build a complete URL. Each alist may overwrite parameters from the previous, including any parameters on the passed URL.

(let ((url "http://www.artfulcode.net/?s=newlisp"))
  (println (Web:build-url url '(("s" "newlisp web module") ("foo" "bar")))))
;; => http://www.artfulcode.net/?s=newlisp+web+module&foo=bar

It also has a counterpart, Web:parse-url, which breaks a URL up into an association list of its component parts.

Download

You can find it in the repository or download it directly here.

Submit article

There are not a huge number of features at the moment, but here is the list:

• install modules from multiple repositories
• install/uninstall module dependencies
• automatic upgrade of modules
• newlisp version checking
• file clash checking

Basic setup

Download the archive nl-install from http://static.artfulcode.net/nl-install/. Extract and edit the nl-install file to set up your target installation directory (/usr/share/newlips/site-lisp by default) and any (future) extra repositories you would like to add. Make the file executable and place in your path, then update:

chmod +x nl-install
sudo cp nl-install /usr/local/bin
sudo nl-install update

Usage

To see the list of all available modules or just the ones installed:

nl-install list available
nl-install list installed

To install one or more modules:

sudo nl-install install acode:csv
sudo nl-install install acode:matching acode:util

If there are other modules that must be installed first, you will be prompted for their installation.

To uninstall a module:

sudo nl-install uninstall acode:csv

Re-install a module to get the latest version.

Repositories

Setting up your own repository is easy. Just write a package listing and put it online somewhere. A sample is included in the tarball:

(repository
  (title "My repository")
  (identifier "foo") ; once chosen, this should *not* change
  (contact "My Name ")
  (version 1000) ; repository version number (1.0)
 
  (module
    (title "module1")
    (description "A short description of module1")
    (url "http://location/of/module1.lsp")
    (qwerty "http://location/of/module1.qwerty")
    (version 1010) ; 1.1
    (newlisp-min-version 10000) ; 10
    (newlisp-max-version 10001) ; 10.0.1
    (depends nil)) ; no dependencies
 
  (module
    (title "module2")
    (description "A short description of module2")
    (url "http://location/of/module2.lsp")
    (qwerty "http://location/of/module2.qwerty")
    (version 2011) ; 2.1.1
    (newlisp-min-version 10000) ; 10
    (newlisp-max-version 10001) ; 10.0.1
    (depends "foo:module1")))

Let me know about it and I will put it in the repository list.

Submit article

The module came out of my original locks module, which contained only the Lock and RLock classes. The new library contains the following classes:

• Semaphore: simplifies use of semaphores
• Shared: simplifies use of shared memory
• Synchronized: shared memory made safe for use between processes
• Lock: a binary semaphore, or mutex
• RLock: a recursive Lock
• Event: a simple mechanism to signal multiple processes
• Pipe: simplifies use of pipes
• Channel: a two-way communications channel made with pipes
• Queue: a synchronized first in, first out class

MP additionally includes various utilities to deal with common tasks:

• get-pid: gets the current processes’ pid
• with-lock-held: a macro that evaluates its body while holding a lock
• wait: waits for a condition with variable length polling to reduce processor load
• map and iter: versions of map and dolist evaluated asynchronously using the Cilk API

Perhaps the most useful function in the module is with-lock-held, which simplifies the most common locking case: assuring that a block of code is executed atomically.

(setf lock (RLock))
(with-lock-held lock
  (access-restricted-resource))

In this case, no more than one process can evaluate (access-restricted-resource) at a time.

You can download the MP module from my newLisp module repository.

Submit article

A couple of notable changes are a complete replacement of the mysql module, functional has been renamed to matching, and the addition of the Element module, which provides utilities to write XML (or any structured markup) quickly and efficiently.

As modules are updated, I am making a note of it in their descriptions.

The repository

Submit article

The Mysql module differs from the distribution standard module in several important ways. Most obviously, it uses FOOP wrappers for MySQL types. It also requires clients to free results instances; in the standard module, only the base MYSQL instance itself must be freed (using MySQL:close-db).

The significance of this is that it is much simpler to create multiple connections (without having to duplicate the entire context at compile time). Result sets are completely independent of each other, and several may be maintained in any state at once. This also means that a spawned process may be given its own Mysql instance to use without having to worry about other processes’ instances interfering. Using the standard module, the entire context would need to be cloned at compile time and given a static symbol reference (e.g., (new 'MySQL 'db)) in order to run multiple instances or connections to a server.

Moreover, because this module uses unpack and MySQL C API accessor functions, there is no need for the client to calculate member offsets in MySQL compound types. So long as newLisp was compiled for the same target as the libmysqlclient library (both are 32 bit or both are 64 bit), everything should work out of the box. Additionally, MySQL errors are now checked in the connect and query functions and re-thrown as interpreter errors. Instead of checking for nil returns and a using MySQL:error to get the error message, standard error  handling with the catch function may be used.

Several convenience functions and macros have been defined in the mysql context for common operations, including connecting to the database and iterating over results without having to worry about catching errors and managing memory. SQL statements may be passed as strings or a list containing a format string and its parameters, which will type-checked and automatically be escaped as needed.

(mysql:on-connect '("localhost" "user" "secret" "my_database")
  (lambda (db err)
    (if err
      (println "Error! " err)
      (mysql:row-iter db "SELECT * FROM some_table" true
        (lambda (row)
          (println row))))))

This module has been tested with MySQL version 5 and 5.1 and newLisp version 10.0.1. It requires newLisp 10.0 or later. You can download it from the Artful Code newLisp module repository.

Submit article

Importing foreign functions

Loading a function from a shared library is done with the ‘import’ function. Once imported, the function now exists as a normal function in the namespace in which is was imported. From the newLisp documentation:

;; import in Linux
(import "libc.so.6" "printf")
;; import in Mac OS X
(import "libc.dylib" "printf")
;; import in CYGWIN
(import "cygwin1.dll" "printf")

printf is now a function that may be called as any other. Because functions evaluate to themselves and import returns the function value, it is simple to bind the function to a different name:

(setf print-f (import "libc.dylib" "printf"))

Calling foreign functions

Foreign functions are called in the same was any other function.  They can be applied, curried, or mapped.

(printf "%g %s %d %c\n" 1.23 "hello" 999 65)
1.23 hello 999 A

The values that the foreign function receives are pointers to the values that were passed to the function in newLisp. In most cases, this is not problematic, but it is something that must be kept in mind.

Return values

Often, a library function will not return a value directly. Often, functions return a pointer to a value or struct in memory. newLisp cannot guess at the size of the return value or its composition, so it is up to the programmer to know what kind of value is being returned.

For functions that return a pointer to a single value, the functions get-int, get-char, and get-float may be used to find the value to which the pointer points. It is important to check the return value of such a function, as passing an invalid value or null pointer to these functions may crash the interpreter.

(setf ptr (get-pointer-from-some-c-func))
(if-not (zero? ptr)
  (setf value (get-int ptr)))

Strings may be accessed using get-string, although functions that return string pointers often leave it to the consuming function to free the memory. To do so, the function ‘free’ (which frees memory) must first be imported from libc:

(import "libc.dylib" "free")
(setf ptr (get-string-pointer))
(if-not (zero? ptr)
  (setf str (get-string ptr)) ; copy the c string to a newLisp string
  (free ptr)) ; free the string allocated by the foreign function

Deconstructing structs

Functions in 3rd party libraries often return custom types that newLisp cannot introspect. In these cases, the programmer must tell newLisp how to unpack the values.

To that end, newLisp provides the pack and unpack functions. These can be used to pack newLisp values into a structure and vice versa. pack and unpack use a specially formated string that corresponds to the members of the struct. Take the following struct as an example:

struct foo {
  int int_value;
  double float_value;
}

It could be unpacked using the format, “lu lf” (see the documentation for pack and unpack for a full explanation of the format used). Unpacking with this format will return a list of the struct’s values.

(unpack "lu lf" foo-instance) ; returns (42 84.5)

A function that accepts such a struct can be passed the return value of the pack function:

(foofunction (pack "lu lf" 42 84.5))

This makes it simple to unpack complex types into newLisp values.

Putting it all together

It is helpful to create a base FOOP class to work with compound types. Specific types can be prototyped from this class, changing only the pack format to match.

(setf Pointer:pack-format nil)
 
(define (Pointer:Pointer addr)
  (list (context) addr))
 
(define (Pointer:pointer inst)
  (inst 1))
 
(define (Pointer:member inst n , unpacked)
  (setf unpacked (unpack Pointer:pack-format (:pointer inst)))
  (unpacked n))

The Pointer class gives us a few useful methods. :pointer returns the pointer address and :member returns the nth member of the struct. So, the foo class would look like this:

(new 'Pointer 'Foo)
(setf Foo:pack-format "lu lf")

It might also be helpful to add a couple of accessor functions:

(define (Foo:int-val inst , ptr)
  (setf ptr (:member inst 0))
  (if-not (zero? ptr)
    (get-int ptr)))
 
(define (Foo:float-val inst , ptr)
  (setf ptr (:member inst 1))
  (if-not (zero? ptr)
    (get-float ptr)))

Functions from a foreign library that work on ‘foo’ types can now be added directly to the Foo class as methods, and passed the return value of (:pointer my-foo). This makes working with foreign types reasonably trivial.

Submit article

Basic syntax

Like many newLISP sequence functions, find-all is defined for both strings and lists. The basic syntax is:

Strings: (find-all pattern target [expression [option]])
Lists:   (find-all pattern target [expression [comparison-function]])

String searches and regular expressions

The most basic string search finds occurrences of one string inside of another.

(set 'str "Now is the time for all good men to come to the aid of their country.")
(find-all "the" str)
; ("the" "the" "the")

There are three occurrences (including one within the word, ‘their’). To find only occurrences of ‘the’ as a complete word, a regular expression is used:

(find-all {\bthe\b} str $0 0)
; ("the" "the")

The first parameter is a regular expression, defined in curly braces to eliminate the need to double-escape entities (like b). The final parameter, 0, is the PCRE option (a full list of options is available in the newLISP documents for regex.

The third parameter is key to one of the more powerful features of find-all – substitution. The expression parameter is applied to each element found. Inside of this expression, the global variable $0 represents the entire matched element. In a regular expression search, captured matches are available via subsequently enumerated variables: $1, $2, etc.

For example, to convert all occurrences of ‘the’ to upper case in the resulting list:

(find-all {\bthe\b} str (upper-case $0) 0)
;("THE" "THE")

Here is a short program to count the number of occurrences of some common words in the text of War and Peace:

(set 'text (read-file "war_and_peace.txt"))
(set 'words (find-all {\b\S+\b} text $0 1)) ; split into words
 
(println (format "%12s: %6d" "Total words" (length words)))
(letn ((common-words '("and" "or" "the"))
       (counts (map 'list common-words (count common-words words))))
  (dolist (word counts)
    (println (format "%12s: %6d" (word 0) (word 1)))))

With the results:

 Total words: 564345
         and:  21023
          or:   1542
         the:  31702

This isn’t necessarily efficient; finding all words and then counting occurrences of three specific words in a list of more than half a million elements results in a lot of wasted time. The regular expression used also includes opening and closing punctuation in the word (i.e. a quote that begins “The…” would result in a missed occurrence of ‘the’, because the list would contain “The instead. It also does not account for case when counting occurrences.

Here is a more efficient version:

(set 'common-words '("and" "or" "the"))
(set 're (format {\b(%s)\b} (join common-words "|")))
(set 'occurrences (find-all re text (lower-case $0) 1))
(println (map 'list common-words (count common-words occurrences)))
; (("and" 22267) ("or" 1582) ("the" 34619))

Note that find-all is recursive and newLISP has a limited stack size, which can be set during execution with the -s switch:

newlisp -s 500000 common_counts.lsp

The previous example would hit the default stack limit of 2,048. This can be solved by using map instead of find-all‘s substitution expression:

(set 'common-words '("and" "or" "the"))
(set 're (format {\b(%s)\b} (join common-words "|")))
(set 'occurrences (map 'lower-case (find-all re text $0 1)))
(println (map 'list common-words (count common-words occurrences)))
; (("and" 22267) ("or" 1582) ("the" 34619))

The substitution expression is also useful to cause side effects, squeezing even more efficiency out of the algorithm. Here, find-all increments a count of each word and stores it in a dictionary.

(define counts:counts)
 
(set 'common-words '("and" "or" "the"))
(set 're (format {\b(%s)\b} (join common-words "|")))
(find-all re text (counts (lower-case $0) (+ 1 (or (counts (lower-case $0)) 0))) 1)
 
(dolist (w common-words)
  (println (format "%4s: %6d" w (counts w))))
 
 ; and:  22267
 ;  or:   1582
 ; the:  34619

This algorithm is quite fast, although still somewhat weighty in RAM, since it stores the entire text before doing its work.

List searches

find-all list searches are (arguably) nearly as powerful as regular expressions. By default, find-all compares elements of target with pattern using match, and the default expression is the entire matched element ($0):

(set 'target '((a 1) (b 2) (c 3) (d 4 5)))
 
(find-all '(? ?) target)
; ((a 1) (b 2) (c 3))
 
(find-all '(d *) target)
; ((d 4 5))

Using the substitution expression, lists may be unified or matched further:

(find-all '(? ?) target (unify '(Letter Number) $0))
; (((Letter a) (Number 1)) ((Letter b) (Number 2)) ((Letter c) (Number 3)))

Simple list searches using other comparators than match are straight-forward:

(find-all 4 '(1 2 3 4 5) $0 >)
; (1 2 3)
 
(find-all 4 '(1 2 3 4 5) (+ 1 $0) >)
; (2 3 4)

find-all is convenient for searching XML. newLISP parses XML into a tree. For example:

(xml-type-tags nil nil nil nil)
(set 'xml (xml-parse (get-url "http://www.weather.gov/xml/current_obs/index.xml")
    (+ 1 2 4 16)))

For more info on parsing XML in newLISP, see this article and the newLISP documentation.

The XML at the url above lists weather stations. Here is an example station entry, under the root element, “wx_station_index”:

<station>
	<station_id>TAPA</station_id>
	<state>AG</state>
	<station_name>Vc Bird Intl Airport Antigua</station_name>
	<latitude>17.117</latitude>
	<longitude>-61.783</longitude>
	<html_url>http://weather.noaa.gov/weather/current/TAPA.html</html_url>
	<rss_url>http://weather.gov/xml/current_obs/TAPA.rss</rss_url>
	<xml_url>http://weather.gov/xml/current_obs/TAPA.xml</xml_url>
</station>

assoc is useful for finding a path in a parsed XML list:

(set 'stations-xml (assoc (xml "wx_station_index")))

However, assoc only returns the first element of the list that matches. In the XML article linked above, pop-assoc was used to collect elements iteratively:

(set 'stations '())
(while (assoc (xml "wx_station_index" "station"))

That is a handy way of collecting all elements, especially in an irregular document. With find-all, elements may be found just as easily and without modifying the original list:

(find-all '("station" *) (assoc (xml "wx_station_index")))

From there, it is just as simple to aggregate the values from each element:

(set 'station-pattern
    '("station"
        ("station_id" ?)
        ("state" ?)
        ("station_name" ?)
        ("latitude" ?)
        ("longitude" ?)
        ("html_url" ?)
        ("rss_url" ?)
        ("xml_url" ?)))
 
(find-all '("station" *) (assoc (xml "wx_station_index"))
    (match station-pattern $0))

This returns a list of the node values for each station. The data can be applied to a different associative structure easily using unify:

(find-all '("station" *) (assoc (xml "wx_station_index"))
    (unify '(Id State Name Lat Lon Html Rss Xml)
        (match station-pattern $0)))

Each element in this list this creates looks like:

((Id "TAPA")
 (State "AG")
 (Name "Vc Bird Intl Airport Antigua")
 (Lat "17.117")
 (Lon "-61.783")
 (Html "http://weather.noaa.gov/weather/current/TAPA.html")
 (Rss "http://weather.gov/xml/current_obs/TAPA.rss")
 (Xml "http://weather.gov/xml/current_obs/TAPA.xml"))

A completely impractical example

There are further implications of find-all‘s ability to cause side effects in the substitution expression. To download the XML for each individual station, something like this could be done (don’t really do this – it will attempt to spawn more than 2,000 processes):

(set 'processes
    (find-all '("station" *) (assoc (xml "wx_station_index"))
      (spawn (sym (lookup "station_name" $0) 'WEATHER)
             (get-url (lookup "xml_url" $0)))))
 
(sync 30000) ; wait 30 seconds for all downloads to finish

Assuming that the application is able to download the XML file for more than 2,000 stations in 30 seconds (and that there is no hard limit to forked processes, as there is in OSX), the context WEATHER will contain the XML for all stations.

The infeasability of this example aside, it demonstrates, as an example, how easily a user-supplied XML file could be used to script a newLISP application.

Further documentation

• find-all
• unify
• match
• regex
• xml-parse

Submit article