Allegro CL version 10.1
Moderately revised from 10.0.
10.0 version

URI and IRI support in Allegro CL

This document contains the following sections:

1.0 Introduction
   1.1 RFC2396 no longer governs
2.0 The URI and IRI API definition
3.0 Parsing, escape decoding/encoding and the path
4.0 Interning URIs
5.0 Allegro CL implementation notes
6.0 Deviations from the RFC grammars and strict parsing
7.0 Examples

1.0 Introduction

URI stands for Universal Resource Identifier. For a description of URIs, see RFC3986 (which replaces the obsolete RFC2396), which can be found in several places such as the IETF web site ( The related URN syntax is described in RFC8141 (

IRI stands for Internationalized Resource Identifier, which is (according to Wikipedia) "an internet protocol standard which extends the ASCII characters subset of the Uniform Resource Identifier (URI) protocol". It is defined in RFC 3987. While URIs are limited to a subset of the ASCII character set, IRIs may contain characters from the Universal Character Set (Unicode/ISO 10646), including Chinese or Japanese kanji, Korean, Cyrillic characters, and so forth.

URIs are a superset in functionality and syntax to URLs (Universal Resource Locators) and URNs (Universal Resource Names).

In URL slang, the scheme is usually called the `protocol', but it is called scheme in RFC1738. A URL `host' corresponds to the URI `authority.' The URL slang `bookmark' or `anchor' is `fragment' in URI lingo.

The URI facility might not be in an Allegro CL image by default. Evaluate (require :uri) to ensure the facility is loaded (that form returns nil if the URI module is already loaded).

Broadly, the URI facility creates a Lisp object that represents a URI, and provides setters and accessors to fields in the URI object. The URI object can also be interned, much like symbols in CL are. This document describes the facility and the related operators.

Aside from the obvious slots which are called out in the RFC, URIs also have a property list. With interning, this is another similarity between URIs and CL symbols.

1.1 RFC2396 no longer governs

Allegro CL used to process URIs according to RFE2396. Now RFC3986 is used. The change was made in an unpdate released in September, 2018. The change causes changes one important area:

(net.uri:merge-uris (net.uri:parse-uri "?bar")
                    (net.uri:parse-uri ""))
RETURNS #<uri>


Other than that, there are new fields and accessors (such as the URN accessor urn-q-component, as called for in RFC8141).

2.0 The URI and IRI API definition

The uri module, which can be loaded with (require :uri), contains both the URI and the IRI functionality. Symbols naming objects (functions, variables, etc.) in the uri module are exported from the net.uri package.

URIs are represented by CLOS objects. Their slots are:


The host and port slots together correspond to the authority (see RFC3986). There is an accessor-like function, uri-authority, that can be used to extract the authority from a URI. See the RFC3986 specifications pointed to at the beginning of the Section 1.0 Introduction for details of all the slots except plist. The plist slot contains a standard Common Lisp property list.

IRIs are also represented by CLOS objects and have the same slots as URI objects.

All symbols are external in the net.uri package, unless otherwise noted. Brief descriptions are given in this document, with complete descriptions in the individual pages.

The variable *strict-parse* controls how strictly the parser observes syntax rules (many websites violate these rules and so will not parse when they are strictly observed). *strict-parse* has initial value t.

3.0 Parsing, escape decoding/encoding and the path

The method uri-path returns the path portion of the URI, in string form. The method uri-parsed-path returns the path portion of the URI, in list form. This list form is discussed below, after a discussion of decoding/encoding.

RFC2396 lays out a method for inserting into URIs reserved characters. You do this by escaping the character. An escaped character is defined like this:

escaped = "%" hex hex 

hex = digit | "A" | "B" | "C" | "D" | "E" | "F" | "a" | "b" | "c" | "d" | "e" | "f" 

In addition, the RFC defines excluded characters:

"<" | ">" | "#" | "%" | <"> | "{" | "}" | "|" | "\" | "^" | "[" | "]" | "`" 

The set of reserved characters are:

";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | "," 

with the following exceptions:

From the RFC, there are two important rules about escaping and unescaping (encoding and decoding):

The implication of this is that to decode the URI, it must be in a parsed state. That is, you can't convert %2f (the escaped form of "/") until the path has been parsed into its component parts. Another important desire is for the application viewing the component parts to see the decoded values of the components. For example, consider: 

This might be the implementation of a calculator, and how someone would execute 3/2. Clearly, the application that implements this would want to see path components of "calculator" and "3/2". "3%2f2" would not be useful to the calculator application.

For the reasons given above, a parsed version of the path is available and has the following form:

([:absolute | :relative] component1 [component2...]) 

where components are:

element | (element param1 [param2 ...]) 

and element is a path element, and the param's are path element parameters. For example, the result of

(uri-parsed-path (parse-uri "foo;10/bar:x;y;z/baz.htm")) 


(:relative ("foo" "10") ("bar:x" "y" "z") "baz.htm") 

There is a certain amount of canonicalization that occurs when parsing:

The variable *strict-parse* controls how strictly the parser observes syntax rules (many websites violate these rules and so will not parse when they are strictly observed).

4.0 Interning URIs

This section describes how to intern URIs. Interning is not mandatory. URIs can be used perfectly well without interning them.

Interned URIs in Allegro are like symbols. That is, a string representing a URI, when parsed and interned, will always yield an eq object. For example:

(eq (intern-uri "") 
    (intern-uri "")) 

is always true. (Two strings with identical contents may or may not be eq in Common Lisp, note.)

The functions associated with interning are:

5.0 Allegro CL implementation notes

  1. The following are true:
    (uri= (parse-uri "")
        (parse-uri ""))
    (eq (intern-uri "")
       (intern-uri ""))
  2. The following is true:
    (eq (intern-uri "")
        (intern-uri ""))
    (I.e. specifying the default port is the same as specifying no port at all. This is specific in RFC2396.)
  3. The scheme and authority are case-insensitive. In Allegro CL, the scheme is a keyword that appears in the normal case for the Lisp in which you are executing.
  4. #u"..." is shorthand for (parse-uri "...") but if an existing #u dispatch macro definition exists, it will not be overridden.
  5. The interaction between setting the scheme, host, port, path, query, and fragment slots of URI objects, in conjunction with interning URIs will have very bad and unpredictable results.
  6. The printable representation of URIs is cached, for efficiency. This caching is undone when the above slots are changed. That is, when you create a URI the printed representation is cached. When you change one of the above mentioned slots, the printed representation is cleared and calculated when the URI is next printed. For example:
user(10): (setq u #u"") 
user(11): (setf (net.uri:uri-host u) "") 
user(12): u 

This allows URIs behavior to follow the principle of least surprise.

6.0 Deviations from the RFC grammars and strict parsing

There are deviations from the grammar in the RFCs. The special net.uri:*strict-parse* controls whether the parser is RFC compliant. When net.uri:*strict-parse* is nil, the parse will differ in these ways:

Both of these changes are necessary for parsing URIs available in the wild.

7.0 Examples

uri(10): (use-package :net.uri)
uri(11): (parse-uri "foo")
#<uri foo>
uri(12): #u"foo"
#<uri foo>
uri(13): (setq base (intern-uri ""))
uri(14): (merge-uris (parse-uri "foo.htm") base)
uri(15): (merge-uris (parse-uri "?foo") base)
uri(16): (setq base (intern-uri ""))
uri(17): (merge-uris (parse-uri "foo.htm") base)
uri(18): (merge-uris #u"?foo" base)
uri(19): (describe #u"")
#<uri> is an instance of #<standard-class net.uri:uri>:
 The following slots have :instance allocation:
(describe #u"")
#<uri> is an instance of #<standard-class uri>:
 The following slots have :instance allocation:
  net.uri::scheme      :http
  net.uri::userinfo    nil
  net.uri::port        nil
  net.uri::path        nil
  net.uri::query       nil
  net.uri::fragment    nil
  net.uri::plist       nil       ""
  net.uri::.ipv6       nil    nil
  net.uri::escaped     nil
  string               ""
  net.uri::parsed-path nil
  net.uri::hashcode    nil

uri(20): #u"foobar#baz%23xxx"
#<uri foobar#baz#xxx>

Copyright (c) 1998-2017, Franz Inc. Oakland, CA., USA. All rights reserved.
This page has had moderate revisions compared to the 10.0 page.
Created 2017.2.15.

Allegro CL version 10.1
Moderately revised from 10.0.
10.0 version