/ elang / io

URI Expressions

The URI Literal Expression

The URLs familiar from web browsing -- such as http://www.erights.org -- are actually a special case of a syntax known as a URI. (Not that it matters, but URL stands for Uniform Resource Locator, while URI stands for Uniform Resource Identifier.) E's grammar recognizes legal URIs (and therefore, legal URLs) enclosed in angle brackets as URI literal expressions. A URI literal expression starts with a protocol-identifier, such as "http" or "file", is followed immediately by a colon, which is immediately followed by the uri-body characters, such as "//www.erights.org" or "/jabberwocky.txt":

<protocol-identifier:uri-body>

The protocol-identifier is a simple identifier that names a URI-protocol handler. It is up to the named handler to interpret the uri-body and return the value of the URI expression. The value of a URI expression will usually depend on which protocol handler is named. The URI body must begin with one of these characters:

a-z, A-Z, 0-9, any of ;/?@&+$-_.!~*'().%#\|

After the first character, the URI body consists of characters from this set, plus "=" and ":".

*** details: E doesn't quite recognize all legal URIs. The exceptions are the exclusion of "=" and ":" from the first uri-body character -- since it would cause confusion with ":=" (assignment) and "::" (reserved for future use). ***

*** details: \ and | are not actually legal URI characters, but appear in Netscape and/or Internet Explorer (clarify this) to mean / and : respectively. Accordingly, E normalizes \ to / and | to : before passing these to the protocol handler. ***

The URI Unary Expression (left associative)

To look up a file or a web page using a calculated name, rather than a name you know when you write the program, use the URI unary expression:

<protocol-name: expression>

So, for example, both

def name := "c:/jabbertest/jabberwocky.txt"
<file: name>

and

<file:c:/jabbertest/jabberwocky.txt>

mean the same thing. You can also use the URI unary expression to look up names that contain non-URI characters. For example, Windows machines have a top level directory names "Program Files". Since this name contains a space, you can't use the URI literal expression. But

<file: "/Program Files">

is just as good.

The "file:" URI

See Text File I/O.

***detail: to accomodate the way modern browsers operate on windows, a one-letter protocol handler is assumed to be a drive letter and turned into a file: uri whose body consists of the original uri. For example,

<a:/jabberwocky.txt>

is turned into

<file:a:/jabberwocky.txt>

which will fetch the file from your A drive (typically, a floppy). ***

Standard URLs (http:, ftp:, gopher:, news:, and mailto:)

These all evaluate to java.net.URL objects. See URLs.

The "import:" URI

After "import:" comes a Java fully qualified class name. If there is a class by this name (or if one can be loaded), that class is the value of this expression. This enables the equivalent of Java's import statement. Whereas in Java we might write

import java.util.Vector;
...
    Vector vec = ...     //used as a declaration
    ... new Vector() ... //calling constructor or static method

we'd instead say in E

def makeVector := <import:java.util.makeVector>
def Vector := makeVector.asType()
...
    def vec :Vector := ...     # declarations are optional in E
    ... makeVector() ... # calling constructor or static method

See Interfacing with Java.

The "cap:" URI

If the Vat containing the designated object is currently on-line and can be found, and if the designated object is still exported by that Vat, this evaluates to a remote (*** or network) pointer to that object. See Introducing Remote Objects.

***show expansion to kernel language