Subversion-Projekte lars-tiefland.ci

Revision

Details | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
776 lars 1 
<!doctype html>
2 
<title>CodeMirror: Dylan mode</title>
3 
<meta charset="utf-8" />
4 
<link rel=stylesheet href="../../doc/docs.css">
5 
<link rel="stylesheet" href="../../lib/codemirror.css">
6 
<script src="../../lib/codemirror.js"></script>
7 
<script src="../../addon/edit/matchbrackets.js"></script>
8 
<script src="../../addon/comment/continuecomment.js"></script>
9 
<script src="../../addon/comment/comment.js"></script>
10 
<script src="dylan.js"></script>
11 
<style type="text/css">
12 
    .CodeMirror {
13 
        border-top: 1px solid black;
14 
        border-bottom: 1px solid black;
15 
    }
16 
</style>
17 
<div id=nav>
18 
    <a href="http://codemirror.net">
19 
        <h1>CodeMirror</h1>
20 
        <img id=logo src="../../doc/logo.png">
21 
    </a>
22 
    <ul>
23 
        <li>
24 
            <a href="../../index.html">Home</a>
25 
            <li>
26 
                <a href="../../doc/manual.html">Manual</a>
27 
                <li>
28 
                    <a href="https://github.com/codemirror/codemirror">Code</a>
29 
    </ul>
30 
    <ul>
31 
        <li>
32 
            <a href="../index.html">Language modes</a>
33 
            <li>
34 
                <a class=active href="#">Dylan</a>
35 
    </ul>
36 
</div>
37 
<article>
38 
    <h2>Dylan mode</h2>
39 
    <div>
40 
        <textarea id="code" name="code"> Module: locators-internals Synopsis: Abstract modeling of locations Author: Andy Armstrong Copyright: Original Code is Copyright (c) 1995-2004 Functional Objects, Inc. All rights reserved. License: See License.txt in this distribution for details.
41 
            Warranty: Distributed WITHOUT WARRANTY OF ANY KIND define open generic locator-server (locator ::
42 
            <locator>) => (server :: false-or(
43 
                <server-locator>)); define open generic locator-host (locator ::
44 
                    <locator>) => (host :: false-or(
45 
                        <string>)); define open generic locator-volume (locator ::
46 
                            <locator>) => (volume :: false-or(
47 
                                <string>)); define open generic locator-directory (locator ::
48 
                                    <locator>) => (directory :: false-or(
49 
                                        <directory-locator>)); define open generic locator-relative? (locator ::
50 
                                            <locator>) => (relative? ::
51 
                                                <boolean>); define open generic locator-path (locator ::
52 
                                                    <locator>) => (path ::
53 
                                                        <sequence>); define open generic locator-base (locator ::
54 
                                                            <locator>) => (base :: false-or(
55 
                                                                <string>)); define open generic locator-extension (locator ::
56 
                                                                    <locator>) => (extension :: false-or(
57 
                                                                        <string>)); /// Locator classes define open abstract class
58 
                                                                            <directory-locator> (
59 
                                                                                <physical-locator>) end class
60 
                                                                                    <directory-locator>; define open abstract class
61 
                                                                                        <file-locator> (
62 
                                                                                            <physical-locator>) end class
63 
                                                                                                <file-locator>; define method as (class ==
64 
                                                                                                    <directory-locator>, string ::
65 
                                                                                                        <string>) => (locator ::
66 
                                                                                                            <directory-locator>) as(
67 
                                                                                                                <native-directory-locator>, string) end method as; define method make (class ==
68 
                                                                                                                    <directory-locator>, #key server :: false-or(
69 
                                                                                                                        <server-locator>) = #f, path ::
70 
                                                                                                                            <sequence> = #[], relative? ::
71 
                                                                                                                                <boolean> = #f, name :: false-or(
72 
                                                                                                                                    <string>) = #f) => (locator ::
73 
                                                                                                                                        <directory-locator>) make(
74 
                                                                                                                                            <native-directory-locator>, server: server, path: path, relative?: relative?, name: name) end method make; define method as (class ==
75 
                                                                                                                                                <file-locator>, string ::
76 
                                                                                                                                                    <string>) => (locator ::
77 
                                                                                                                                                        <file-locator>) as(
78 
                                                                                                                                                            <native-file-locator>, string) end method as; define method make (class ==
79 
                                                                                                                                                                <file-locator>, #key directory :: false-or(
80 
                                                                                                                                                                    <directory-locator>) = #f, base :: false-or(
81 
                                                                                                                                                                        <string>) = #f, extension :: false-or(
82 
                                                                                                                                                                            <string>) = #f, name :: false-or(
83 
                                                                                                                                                                                <string>) = #f) => (locator ::
84 
                                                                                                                                                                                    <file-locator>) make(
85 
                                                                                                                                                                                        <native-file-locator>, directory: directory, base: base, extension: extension, name: name)
86 
                                                                                                                                                                                            end method make; /// Locator coercion //---*** andrewa: This caching
87 
                                                                                                                                                                                            scheme doesn't work yet, so disable it. define constant $cache-locators?
88 
                                                                                                                                                                                            = #f; define constant $cache-locator-strings? = #f; define constant
89 
                                                                                                                                                                                            $locator-to-string-cache = make(
90 
                                                                                                                                                                                            <object-table>, weak: #"key"); define constant $string-to-locator-cache = make(
91 
                                                                                                                                                                                                <string-table>, weak: #"value"); define open generic locator-as-string (class
92 
                                                                                                                                                                                                    :: subclass(
93 
                                                                                                                                                                                                    <string>), locator ::
94 
                                                                                                                                                                                                        <locator>) => (string ::
95 
                                                                                                                                                                                                            <string>); define open generic string-as-locator (class
96 
                                                                                                                                                                                                                :: subclass(
97 
                                                                                                                                                                                                                <locator>), string ::
98 
                                                                                                                                                                                                                    <string>) => (locator ::
99 
                                                                                                                                                                                                                        <locator>); define sealed sideways method as
100 
                                                                                                                                                                                                                            (class :: subclass(
101 
                                                                                                                                                                                                                            <string>), locator ::
102 
                                                                                                                                                                                                                                <locator>) => (string ::
103 
                                                                                                                                                                                                                                    <string>) let string = element($locator-to-string-cache,
104 
                                                                                                                                                                                                                                        locator, default: #f);
105 
                                                                                                                                                                                                                                        if (string) as(class,
106 
                                                                                                                                                                                                                                        string) else let string
107 
                                                                                                                                                                                                                                        = locator-as-string(class,
108 
                                                                                                                                                                                                                                        locator); if ($cache-locator-strings?)
109 
                                                                                                                                                                                                                                        element($locator-to-string-cache,
110 
                                                                                                                                                                                                                                        locator) := string;
111 
                                                                                                                                                                                                                                        else string end end
112 
                                                                                                                                                                                                                                        end method as; define
113 
                                                                                                                                                                                                                                        sealed sideways method
114 
                                                                                                                                                                                                                                        as (class :: subclass(
115 
                                                                                                                                                                                                                                        <locator>), string ::
116 
                                                                                                                                                                                                                                            <string>) => (locator ::
117 
                                                                                                                                                                                                                                                <locator>) let locator
118 
                                                                                                                                                                                                                                                    = element($string-to-locator-cache,
119 
                                                                                                                                                                                                                                                    string,
120 
                                                                                                                                                                                                                                                    default:
121 
                                                                                                                                                                                                                                                    #f); if
122 
                                                                                                                                                                                                                                                    (instance?(locator,
123 
                                                                                                                                                                                                                                                    class))
124 
                                                                                                                                                                                                                                                    locator
125 
                                                                                                                                                                                                                                                    else let
126 
                                                                                                                                                                                                                                                    locator
127 
                                                                                                                                                                                                                                                    = string-as-locator(class,
128 
                                                                                                                                                                                                                                                    string);
129 
                                                                                                                                                                                                                                                    if ($cache-locators?)
130 
                                                                                                                                                                                                                                                    element($string-to-locator-cache,
131 
                                                                                                                                                                                                                                                    string)
132 
                                                                                                                                                                                                                                                    := locator;
133 
                                                                                                                                                                                                                                                    else locator
134 
                                                                                                                                                                                                                                                    end end
135 
                                                                                                                                                                                                                                                    end method
136 
                                                                                                                                                                                                                                                    as; ///
137 
                                                                                                                                                                                                                                                    Locator
138 
                                                                                                                                                                                                                                                    conditions
139 
                                                                                                                                                                                                                                                    define
140 
                                                                                                                                                                                                                                                    class
141 
                                                                                                                                                                                                                                                    <locator-error>
142 
                                                                                                                                                                                                                                                    (
143 
                                                                                                                                                                                                                                                        <format-string-condition>,
144 
                                                                                                                                                                                                                                                            <error>)
145 
                                                                                                                                                                                                                                                                end
146 
                                                                                                                                                                                                                                                                class
147 
                                                                                                                                                                                                                                                                <locator-error>;
148 
                                                                                                                                                                                                                                                                    define
149 
                                                                                                                                                                                                                                                                    function
150 
                                                                                                                                                                                                                                                                    locator-error
151 
                                                                                                                                                                                                                                                                    (format-string
152 
                                                                                                                                                                                                                                                                    ::
153 
                                                                                                                                                                                                                                                                    <string>,
154 
                                                                                                                                                                                                                                                                        #rest
155 
                                                                                                                                                                                                                                                                        format-arguments)
156 
                                                                                                                                                                                                                                                                        error(make(
157 
                                                                                                                                                                                                                                                                        <locator-error>,
158 
                                                                                                                                                                                                                                                                            format-string:
159 
                                                                                                                                                                                                                                                                            format-string,
160 
                                                                                                                                                                                                                                                                            format-arguments:
161 
                                                                                                                                                                                                                                                                            format-arguments))
162 
                                                                                                                                                                                                                                                                            end
163 
                                                                                                                                                                                                                                                                            function
164 
                                                                                                                                                                                                                                                                            locator-error;
165 
                                                                                                                                                                                                                                                                            ///
166 
                                                                                                                                                                                                                                                                            Useful
167 
                                                                                                                                                                                                                                                                            locator
168 
                                                                                                                                                                                                                                                                            protocols
169 
                                                                                                                                                                                                                                                                            define
170 
                                                                                                                                                                                                                                                                            open
171 
                                                                                                                                                                                                                                                                            generic
172 
                                                                                                                                                                                                                                                                            locator-test
173 
                                                                                                                                                                                                                                                                            (locator
174 
                                                                                                                                                                                                                                                                            ::
175 
                                                                                                                                                                                                                                                                            <directory-locator>)
176 
                                                                                                                                                                                                                                                                                =>
177 
                                                                                                                                                                                                                                                                                (test
178 
                                                                                                                                                                                                                                                                                ::
179 
                                                                                                                                                                                                                                                                                <function>);
180 
                                                                                                                                                                                                                                                                                    define
181 
                                                                                                                                                                                                                                                                                    method
182 
                                                                                                                                                                                                                                                                                    locator-test
183 
                                                                                                                                                                                                                                                                                    (locator
184 
                                                                                                                                                                                                                                                                                    ::
185 
                                                                                                                                                                                                                                                                                    <directory-locator>)
186 
                                                                                                                                                                                                                                                                                        =>
187 
                                                                                                                                                                                                                                                                                        (test
188 
                                                                                                                                                                                                                                                                                        ::
189 
                                                                                                                                                                                                                                                                                        <function>)
190 
                                                                                                                                                                                                                                                                                            \=
191 
                                                                                                                                                                                                                                                                                            end
192 
                                                                                                                                                                                                                                                                                            method
193 
                                                                                                                                                                                                                                                                                            locator-test;
194 
                                                                                                                                                                                                                                                                                            define
195 
                                                                                                                                                                                                                                                                                            open
196 
                                                                                                                                                                                                                                                                                            generic
197 
                                                                                                                                                                                                                                                                                            locator-might-have-links?
198 
                                                                                                                                                                                                                                                                                            (locator
199 
                                                                                                                                                                                                                                                                                            ::
200 
                                                                                                                                                                                                                                                                                            <directory-locator>)
201 
                                                                                                                                                                                                                                                                                                =>
202 
                                                                                                                                                                                                                                                                                                (links?
203 
                                                                                                                                                                                                                                                                                                ::
204 
                                                                                                                                                                                                                                                                                                <boolean>);
205 
                                                                                                                                                                                                                                                                                                    define
206 
                                                                                                                                                                                                                                                                                                    method
207 
                                                                                                                                                                                                                                                                                                    locator-might-have-links?
208 
                                                                                                                                                                                                                                                                                                    (locator
209 
                                                                                                                                                                                                                                                                                                    ::
210 
                                                                                                                                                                                                                                                                                                    <directory-locator>)
211 
                                                                                                                                                                                                                                                                                                        =>
212 
                                                                                                                                                                                                                                                                                                        (links?
213 
                                                                                                                                                                                                                                                                                                        ::
214 
                                                                                                                                                                                                                                                                                                        singleton(#f))
215 
                                                                                                                                                                                                                                                                                                        #f
216 
                                                                                                                                                                                                                                                                                                        end
217 
                                                                                                                                                                                                                                                                                                        method
218 
                                                                                                                                                                                                                                                                                                        locator-might-have-links?;
219 
                                                                                                                                                                                                                                                                                                        define
220 
                                                                                                                                                                                                                                                                                                        method
221 
                                                                                                                                                                                                                                                                                                        locator-relative?
222 
                                                                                                                                                                                                                                                                                                        (locator
223 
                                                                                                                                                                                                                                                                                                        ::
224 
                                                                                                                                                                                                                                                                                                        <file-locator>)
225 
                                                                                                                                                                                                                                                                                                            =>
226 
                                                                                                                                                                                                                                                                                                            (relative?
227 
                                                                                                                                                                                                                                                                                                            ::
228 
                                                                                                                                                                                                                                                                                                            <boolean>)
229 
                                                                                                                                                                                                                                                                                                                let
230 
                                                                                                                                                                                                                                                                                                                directory
231 
                                                                                                                                                                                                                                                                                                                =
232 
                                                                                                                                                                                                                                                                                                                locator.locator-directory;
233 
                                                                                                                                                                                                                                                                                                                ~directory
234 
                                                                                                                                                                                                                                                                                                                |
235 
                                                                                                                                                                                                                                                                                                                directory.locator-relative?
236 
                                                                                                                                                                                                                                                                                                                end
237 
                                                                                                                                                                                                                                                                                                                method
238 
                                                                                                                                                                                                                                                                                                                locator-relative?;
239 
                                                                                                                                                                                                                                                                                                                define
240 
                                                                                                                                                                                                                                                                                                                method
241 
                                                                                                                                                                                                                                                                                                                current-directory-locator?
242 
                                                                                                                                                                                                                                                                                                                (locator
243 
                                                                                                                                                                                                                                                                                                                ::
244 
                                                                                                                                                                                                                                                                                                                <directory-locator>)
245 
                                                                                                                                                                                                                                                                                                                    =>
246 
                                                                                                                                                                                                                                                                                                                    (current-directory?
247 
                                                                                                                                                                                                                                                                                                                    ::
248 
                                                                                                                                                                                                                                                                                                                    <boolean>)
249 
                                                                                                                                                                                                                                                                                                                        locator.locator-relative?
250 
                                                                                                                                                                                                                                                                                                                        &
251 
                                                                                                                                                                                                                                                                                                                        locator.locator-path
252 
                                                                                                                                                                                                                                                                                                                        =
253 
                                                                                                                                                                                                                                                                                                                        #[#"self"]
254 
                                                                                                                                                                                                                                                                                                                        end
255 
                                                                                                                                                                                                                                                                                                                        method
256 
                                                                                                                                                                                                                                                                                                                        current-directory-locator?;
257 
                                                                                                                                                                                                                                                                                                                        define
258 
                                                                                                                                                                                                                                                                                                                        method
259 
                                                                                                                                                                                                                                                                                                                        locator-directory
260 
                                                                                                                                                                                                                                                                                                                        (locator
261 
                                                                                                                                                                                                                                                                                                                        ::
262 
                                                                                                                                                                                                                                                                                                                        <directory-locator>)
263 
                                                                                                                                                                                                                                                                                                                            =>
264 
                                                                                                                                                                                                                                                                                                                            (parent
265 
                                                                                                                                                                                                                                                                                                                            ::
266 
                                                                                                                                                                                                                                                                                                                            false-or(
267 
                                                                                                                                                                                                                                                                                                                            <directory-locator>))
268 
                                                                                                                                                                                                                                                                                                                                let
269 
                                                                                                                                                                                                                                                                                                                                path
270 
                                                                                                                                                                                                                                                                                                                                =
271 
                                                                                                                                                                                                                                                                                                                                locator.locator-path;
272 
                                                                                                                                                                                                                                                                                                                                unless
273 
                                                                                                                                                                                                                                                                                                                                (empty?(path))
274 
                                                                                                                                                                                                                                                                                                                                make(object-class(locator),
275 
                                                                                                                                                                                                                                                                                                                                server:
276 
                                                                                                                                                                                                                                                                                                                                locator.locator-server,
277 
                                                                                                                                                                                                                                                                                                                                path:
278 
                                                                                                                                                                                                                                                                                                                                copy-sequence(path,
279 
                                                                                                                                                                                                                                                                                                                                end:
280 
                                                                                                                                                                                                                                                                                                                                path.size
281 
                                                                                                                                                                                                                                                                                                                                -
282 
                                                                                                                                                                                                                                                                                                                                1),
283 
                                                                                                                                                                                                                                                                                                                                relative?:
284 
                                                                                                                                                                                                                                                                                                                                locator.locator-relative?)
285 
                                                                                                                                                                                                                                                                                                                                end
286 
                                                                                                                                                                                                                                                                                                                                end
287 
                                                                                                                                                                                                                                                                                                                                method
288 
                                                                                                                                                                                                                                                                                                                                locator-directory;
289 
                                                                                                                                                                                                                                                                                                                                ///
290 
                                                                                                                                                                                                                                                                                                                                Simplify
291 
                                                                                                                                                                                                                                                                                                                                locator
292 
                                                                                                                                                                                                                                                                                                                                define
293 
                                                                                                                                                                                                                                                                                                                                open
294 
                                                                                                                                                                                                                                                                                                                                generic
295 
                                                                                                                                                                                                                                                                                                                                simplify-locator
296 
                                                                                                                                                                                                                                                                                                                                (locator
297 
                                                                                                                                                                                                                                                                                                                                ::
298 
                                                                                                                                                                                                                                                                                                                                <physical-locator>)
299 
                                                                                                                                                                                                                                                                                                                                    =>
300 
                                                                                                                                                                                                                                                                                                                                    (simplified-locator
301 
                                                                                                                                                                                                                                                                                                                                    ::
302 
                                                                                                                                                                                                                                                                                                                                    <physical-locator>);
303 
                                                                                                                                                                                                                                                                                                                                        define
304 
                                                                                                                                                                                                                                                                                                                                        method
305 
                                                                                                                                                                                                                                                                                                                                        simplify-locator
306 
                                                                                                                                                                                                                                                                                                                                        (locator
307 
                                                                                                                                                                                                                                                                                                                                        ::
308 
                                                                                                                                                                                                                                                                                                                                        <directory-locator>)
309 
                                                                                                                                                                                                                                                                                                                                            =>
310 
                                                                                                                                                                                                                                                                                                                                            (simplified-locator
311 
                                                                                                                                                                                                                                                                                                                                            ::
312 
                                                                                                                                                                                                                                                                                                                                            <directory-locator>)
313 
                                                                                                                                                                                                                                                                                                                                                let
314 
                                                                                                                                                                                                                                                                                                                                                path
315 
                                                                                                                                                                                                                                                                                                                                                =
316 
                                                                                                                                                                                                                                                                                                                                                locator.locator-path;
317 
                                                                                                                                                                                                                                                                                                                                                let
318 
                                                                                                                                                                                                                                                                                                                                                relative?
319 
                                                                                                                                                                                                                                                                                                                                                =
320 
                                                                                                                                                                                                                                                                                                                                                locator.locator-relative?;
321 
                                                                                                                                                                                                                                                                                                                                                let
322 
                                                                                                                                                                                                                                                                                                                                                resolve-parent?
323 
                                                                                                                                                                                                                                                                                                                                                =
324 
                                                                                                                                                                                                                                                                                                                                                ~locator.locator-might-have-links?;
325 
                                                                                                                                                                                                                                                                                                                                                let
326 
                                                                                                                                                                                                                                                                                                                                                simplified-path
327 
                                                                                                                                                                                                                                                                                                                                                =
328 
                                                                                                                                                                                                                                                                                                                                                simplify-path(path,
329 
                                                                                                                                                                                                                                                                                                                                                resolve-parent?:
330 
                                                                                                                                                                                                                                                                                                                                                resolve-parent?,
331 
                                                                                                                                                                                                                                                                                                                                                relative?:
332 
                                                                                                                                                                                                                                                                                                                                                relative?);
333 
                                                                                                                                                                                                                                                                                                                                                if
334 
                                                                                                                                                                                                                                                                                                                                                (path
335 
                                                                                                                                                                                                                                                                                                                                                ~=
336 
                                                                                                                                                                                                                                                                                                                                                simplified-path)
337 
                                                                                                                                                                                                                                                                                                                                                make(object-class(locator),
338 
                                                                                                                                                                                                                                                                                                                                                server:
339 
                                                                                                                                                                                                                                                                                                                                                locator.locator-server,
340 
                                                                                                                                                                                                                                                                                                                                                path:
341 
                                                                                                                                                                                                                                                                                                                                                simplified-path,
342 
                                                                                                                                                                                                                                                                                                                                                relative?:
343 
                                                                                                                                                                                                                                                                                                                                                locator.locator-relative?)
344 
                                                                                                                                                                                                                                                                                                                                                else
345 
                                                                                                                                                                                                                                                                                                                                                locator
346 
                                                                                                                                                                                                                                                                                                                                                end
347 
                                                                                                                                                                                                                                                                                                                                                end
348 
                                                                                                                                                                                                                                                                                                                                                method
349 
                                                                                                                                                                                                                                                                                                                                                simplify-locator;
350 
                                                                                                                                                                                                                                                                                                                                                define
351 
                                                                                                                                                                                                                                                                                                                                                method
352 
                                                                                                                                                                                                                                                                                                                                                simplify-locator
353 
                                                                                                                                                                                                                                                                                                                                                (locator
354 
                                                                                                                                                                                                                                                                                                                                                ::
355 
                                                                                                                                                                                                                                                                                                                                                <file-locator>)
356 
                                                                                                                                                                                                                                                                                                                                                    =>
357 
                                                                                                                                                                                                                                                                                                                                                    (simplified-locator
358 
                                                                                                                                                                                                                                                                                                                                                    ::
359 
                                                                                                                                                                                                                                                                                                                                                    <file-locator>)
360 
                                                                                                                                                                                                                                                                                                                                                        let
361 
                                                                                                                                                                                                                                                                                                                                                        directory
362 
                                                                                                                                                                                                                                                                                                                                                        =
363 
                                                                                                                                                                                                                                                                                                                                                        locator.locator-directory;
364 
                                                                                                                                                                                                                                                                                                                                                        let
365 
                                                                                                                                                                                                                                                                                                                                                        simplified-directory
366 
                                                                                                                                                                                                                                                                                                                                                        =
367 
                                                                                                                                                                                                                                                                                                                                                        directory
368 
                                                                                                                                                                                                                                                                                                                                                        &
369 
                                                                                                                                                                                                                                                                                                                                                        simplify-locator(directory);
370 
                                                                                                                                                                                                                                                                                                                                                        if
371 
                                                                                                                                                                                                                                                                                                                                                        (directory
372 
                                                                                                                                                                                                                                                                                                                                                        ~=
373 
                                                                                                                                                                                                                                                                                                                                                        simplified-directory)
374 
                                                                                                                                                                                                                                                                                                                                                        make(object-class(locator),
375 
                                                                                                                                                                                                                                                                                                                                                        directory:
376 
                                                                                                                                                                                                                                                                                                                                                        simplified-directory,
377 
                                                                                                                                                                                                                                                                                                                                                        base:
378 
                                                                                                                                                                                                                                                                                                                                                        locator.locator-base,
379 
                                                                                                                                                                                                                                                                                                                                                        extension:
380 
                                                                                                                                                                                                                                                                                                                                                        locator.locator-extension)
381 
                                                                                                                                                                                                                                                                                                                                                        else
382 
                                                                                                                                                                                                                                                                                                                                                        locator
383 
                                                                                                                                                                                                                                                                                                                                                        end
384 
                                                                                                                                                                                                                                                                                                                                                        end
385 
                                                                                                                                                                                                                                                                                                                                                        method
386 
                                                                                                                                                                                                                                                                                                                                                        simplify-locator;
387 
                                                                                                                                                                                                                                                                                                                                                        ///
388 
                                                                                                                                                                                                                                                                                                                                                        Subdirectory
389 
                                                                                                                                                                                                                                                                                                                                                        locator
390 
                                                                                                                                                                                                                                                                                                                                                        define
391 
                                                                                                                                                                                                                                                                                                                                                        open
392 
                                                                                                                                                                                                                                                                                                                                                        generic
393 
                                                                                                                                                                                                                                                                                                                                                        subdirectory-locator
394 
                                                                                                                                                                                                                                                                                                                                                        (locator
395 
                                                                                                                                                                                                                                                                                                                                                        ::
396 
                                                                                                                                                                                                                                                                                                                                                        <directory-locator>,
397 
                                                                                                                                                                                                                                                                                                                                                            #rest
398 
                                                                                                                                                                                                                                                                                                                                                            sub-path)
399 
                                                                                                                                                                                                                                                                                                                                                            =>
400 
                                                                                                                                                                                                                                                                                                                                                            (subdirectory
401 
                                                                                                                                                                                                                                                                                                                                                            ::
402 
                                                                                                                                                                                                                                                                                                                                                            <directory-locator>);
403 
                                                                                                                                                                                                                                                                                                                                                                define
404 
                                                                                                                                                                                                                                                                                                                                                                method
405 
                                                                                                                                                                                                                                                                                                                                                                subdirectory-locator
406 
                                                                                                                                                                                                                                                                                                                                                                (locator
407 
                                                                                                                                                                                                                                                                                                                                                                ::
408 
                                                                                                                                                                                                                                                                                                                                                                <directory-locator>,
409 
                                                                                                                                                                                                                                                                                                                                                                    #rest
410 
                                                                                                                                                                                                                                                                                                                                                                    sub-path)
411 
                                                                                                                                                                                                                                                                                                                                                                    =>
412 
                                                                                                                                                                                                                                                                                                                                                                    (subdirectory
413 
                                                                                                                                                                                                                                                                                                                                                                    ::
414 
                                                                                                                                                                                                                                                                                                                                                                    <directory-locator>)
415 
                                                                                                                                                                                                                                                                                                                                                                        let
416 
                                                                                                                                                                                                                                                                                                                                                                        old-path
417 
                                                                                                                                                                                                                                                                                                                                                                        =
418 
                                                                                                                                                                                                                                                                                                                                                                        locator.locator-path;
419 
                                                                                                                                                                                                                                                                                                                                                                        let
420 
                                                                                                                                                                                                                                                                                                                                                                        new-path
421 
                                                                                                                                                                                                                                                                                                                                                                        =
422 
                                                                                                                                                                                                                                                                                                                                                                        concatenate-as(
423 
                                                                                                                                                                                                                                                                                                                                                                        <simple-object-vector>,
424 
                                                                                                                                                                                                                                                                                                                                                                            old-path,
425 
                                                                                                                                                                                                                                                                                                                                                                            sub-path);
426 
                                                                                                                                                                                                                                                                                                                                                                            make(object-class(locator),
427 
                                                                                                                                                                                                                                                                                                                                                                            server:
428 
                                                                                                                                                                                                                                                                                                                                                                            locator.locator-server,
429 
                                                                                                                                                                                                                                                                                                                                                                            path:
430 
                                                                                                                                                                                                                                                                                                                                                                            new-path,
431 
                                                                                                                                                                                                                                                                                                                                                                            relative?:
432 
                                                                                                                                                                                                                                                                                                                                                                            locator.locator-relative?)
433 
                                                                                                                                                                                                                                                                                                                                                                            end
434 
                                                                                                                                                                                                                                                                                                                                                                            method
435 
                                                                                                                                                                                                                                                                                                                                                                            subdirectory-locator;
436 
                                                                                                                                                                                                                                                                                                                                                                            ///
437 
                                                                                                                                                                                                                                                                                                                                                                            Relative
438 
                                                                                                                                                                                                                                                                                                                                                                            locator
439 
                                                                                                                                                                                                                                                                                                                                                                            define
440 
                                                                                                                                                                                                                                                                                                                                                                            open
441 
                                                                                                                                                                                                                                                                                                                                                                            generic
442 
                                                                                                                                                                                                                                                                                                                                                                            relative-locator
443 
                                                                                                                                                                                                                                                                                                                                                                            (locator
444 
                                                                                                                                                                                                                                                                                                                                                                            ::
445 
                                                                                                                                                                                                                                                                                                                                                                            <physical-locator>,
446 
                                                                                                                                                                                                                                                                                                                                                                                from-locator
447 
                                                                                                                                                                                                                                                                                                                                                                                ::
448 
                                                                                                                                                                                                                                                                                                                                                                                <physical-locator>)
449 
                                                                                                                                                                                                                                                                                                                                                                                    =>
450 
                                                                                                                                                                                                                                                                                                                                                                                    (relative-locator
451 
                                                                                                                                                                                                                                                                                                                                                                                    ::
452 
                                                                                                                                                                                                                                                                                                                                                                                    <physical-locator>);
453 
                                                                                                                                                                                                                                                                                                                                                                                        define
454 
                                                                                                                                                                                                                                                                                                                                                                                        method
455 
                                                                                                                                                                                                                                                                                                                                                                                        relative-locator
456 
                                                                                                                                                                                                                                                                                                                                                                                        (locator
457 
                                                                                                                                                                                                                                                                                                                                                                                        ::
458 
                                                                                                                                                                                                                                                                                                                                                                                        <directory-locator>,
459 
                                                                                                                                                                                                                                                                                                                                                                                            from-locator
460 
                                                                                                                                                                                                                                                                                                                                                                                            ::
461 
                                                                                                                                                                                                                                                                                                                                                                                            <directory-locator>)
462 
                                                                                                                                                                                                                                                                                                                                                                                                =>
463 
                                                                                                                                                                                                                                                                                                                                                                                                (relative-locator
464 
                                                                                                                                                                                                                                                                                                                                                                                                ::
465 
                                                                                                                                                                                                                                                                                                                                                                                                <directory-locator>)
466 
                                                                                                                                                                                                                                                                                                                                                                                                    let
467 
                                                                                                                                                                                                                                                                                                                                                                                                    path
468 
                                                                                                                                                                                                                                                                                                                                                                                                    =
469 
                                                                                                                                                                                                                                                                                                                                                                                                    locator.locator-path;
470 
                                                                                                                                                                                                                                                                                                                                                                                                    let
471 
                                                                                                                                                                                                                                                                                                                                                                                                    from-path
472 
                                                                                                                                                                                                                                                                                                                                                                                                    =
473 
                                                                                                                                                                                                                                                                                                                                                                                                    from-locator.locator-path;
474 
                                                                                                                                                                                                                                                                                                                                                                                                    case
475 
                                                                                                                                                                                                                                                                                                                                                                                                    ~locator.locator-relative?
476 
                                                                                                                                                                                                                                                                                                                                                                                                    &
477 
                                                                                                                                                                                                                                                                                                                                                                                                    from-locator.locator-relative?
478 
                                                                                                                                                                                                                                                                                                                                                                                                    =>
479 
                                                                                                                                                                                                                                                                                                                                                                                                    locator-error
480 
                                                                                                                                                                                                                                                                                                                                                                                                    ("Cannot
481 
                                                                                                                                                                                                                                                                                                                                                                                                    find
482 
                                                                                                                                                                                                                                                                                                                                                                                                    relative
483 
                                                                                                                                                                                                                                                                                                                                                                                                    path
484 
                                                                                                                                                                                                                                                                                                                                                                                                    of
485 
                                                                                                                                                                                                                                                                                                                                                                                                    absolute
486 
                                                                                                                                                                                                                                                                                                                                                                                                    locator
487 
                                                                                                                                                                                                                                                                                                                                                                                                    %=
488 
                                                                                                                                                                                                                                                                                                                                                                                                    from
489 
                                                                                                                                                                                                                                                                                                                                                                                                    relative
490 
                                                                                                                                                                                                                                                                                                                                                                                                    locator
491 
                                                                                                                                                                                                                                                                                                                                                                                                    %=",
492 
                                                                                                                                                                                                                                                                                                                                                                                                    locator,
493 
                                                                                                                                                                                                                                                                                                                                                                                                    from-locator);
494 
                                                                                                                                                                                                                                                                                                                                                                                                    locator.locator-server
495 
                                                                                                                                                                                                                                                                                                                                                                                                    ~=
496 
                                                                                                                                                                                                                                                                                                                                                                                                    from-locator.locator-server
497 
                                                                                                                                                                                                                                                                                                                                                                                                    =>
498 
                                                                                                                                                                                                                                                                                                                                                                                                    locator;
499 
                                                                                                                                                                                                                                                                                                                                                                                                    path
500 
                                                                                                                                                                                                                                                                                                                                                                                                    =
501 
                                                                                                                                                                                                                                                                                                                                                                                                    from-path
502 
                                                                                                                                                                                                                                                                                                                                                                                                    =>
503 
                                                                                                                                                                                                                                                                                                                                                                                                    make(object-class(locator),
504 
                                                                                                                                                                                                                                                                                                                                                                                                    path:
505 
                                                                                                                                                                                                                                                                                                                                                                                                    vector(#"self"),
506 
                                                                                                                                                                                                                                                                                                                                                                                                    relative?:
507 
                                                                                                                                                                                                                                                                                                                                                                                                    #t);
508 
                                                                                                                                                                                                                                                                                                                                                                                                    otherwise
509 
                                                                                                                                                                                                                                                                                                                                                                                                    =>
510 
                                                                                                                                                                                                                                                                                                                                                                                                    make(object-class(locator),
511 
                                                                                                                                                                                                                                                                                                                                                                                                    path:
512 
                                                                                                                                                                                                                                                                                                                                                                                                    relative-path(path,
513 
                                                                                                                                                                                                                                                                                                                                                                                                    from-path,
514 
                                                                                                                                                                                                                                                                                                                                                                                                    test:
515 
                                                                                                                                                                                                                                                                                                                                                                                                    locator.locator-test),
516 
                                                                                                                                                                                                                                                                                                                                                                                                    relative?:
517 
                                                                                                                                                                                                                                                                                                                                                                                                    #t);
518 
                                                                                                                                                                                                                                                                                                                                                                                                    end
519 
                                                                                                                                                                                                                                                                                                                                                                                                    end
520 
                                                                                                                                                                                                                                                                                                                                                                                                    method
521 
                                                                                                                                                                                                                                                                                                                                                                                                    relative-locator;
522 
                                                                                                                                                                                                                                                                                                                                                                                                    define
523 
                                                                                                                                                                                                                                                                                                                                                                                                    method
524 
                                                                                                                                                                                                                                                                                                                                                                                                    relative-locator
525 
                                                                                                                                                                                                                                                                                                                                                                                                    (locator
526 
                                                                                                                                                                                                                                                                                                                                                                                                    ::
527 
                                                                                                                                                                                                                                                                                                                                                                                                    <file-locator>,
528 
                                                                                                                                                                                                                                                                                                                                                                                                        from-directory
529 
                                                                                                                                                                                                                                                                                                                                                                                                        ::
530 
                                                                                                                                                                                                                                                                                                                                                                                                        <directory-locator>)
531 
                                                                                                                                                                                                                                                                                                                                                                                                            =>
532 
                                                                                                                                                                                                                                                                                                                                                                                                            (relative-locator
533 
                                                                                                                                                                                                                                                                                                                                                                                                            ::
534 
                                                                                                                                                                                                                                                                                                                                                                                                            <file-locator>)
535 
                                                                                                                                                                                                                                                                                                                                                                                                                let
536 
                                                                                                                                                                                                                                                                                                                                                                                                                directory
537 
                                                                                                                                                                                                                                                                                                                                                                                                                =
538 
                                                                                                                                                                                                                                                                                                                                                                                                                locator.locator-directory;
539 
                                                                                                                                                                                                                                                                                                                                                                                                                let
540 
                                                                                                                                                                                                                                                                                                                                                                                                                relative-directory
541 
                                                                                                                                                                                                                                                                                                                                                                                                                =
542 
                                                                                                                                                                                                                                                                                                                                                                                                                directory
543 
                                                                                                                                                                                                                                                                                                                                                                                                                &
544 
                                                                                                                                                                                                                                                                                                                                                                                                                relative-locator(directory,
545 
                                                                                                                                                                                                                                                                                                                                                                                                                from-directory);
546 
                                                                                                                                                                                                                                                                                                                                                                                                                if
547 
                                                                                                                                                                                                                                                                                                                                                                                                                (relative-directory
548 
                                                                                                                                                                                                                                                                                                                                                                                                                ~=
549 
                                                                                                                                                                                                                                                                                                                                                                                                                directory)
550 
                                                                                                                                                                                                                                                                                                                                                                                                                simplify-locator
551 
                                                                                                                                                                                                                                                                                                                                                                                                                (make(object-class(locator),
552 
                                                                                                                                                                                                                                                                                                                                                                                                                directory:
553 
                                                                                                                                                                                                                                                                                                                                                                                                                relative-directory,
554 
                                                                                                                                                                                                                                                                                                                                                                                                                base:
555 
                                                                                                                                                                                                                                                                                                                                                                                                                locator.locator-base,
556 
                                                                                                                                                                                                                                                                                                                                                                                                                extension:
557 
                                                                                                                                                                                                                                                                                                                                                                                                                locator.locator-extension))
558 
                                                                                                                                                                                                                                                                                                                                                                                                                else
559 
                                                                                                                                                                                                                                                                                                                                                                                                                locator
560 
                                                                                                                                                                                                                                                                                                                                                                                                                end
561 
                                                                                                                                                                                                                                                                                                                                                                                                                end
562 
                                                                                                                                                                                                                                                                                                                                                                                                                method
563 
                                                                                                                                                                                                                                                                                                                                                                                                                relative-locator;
564 
                                                                                                                                                                                                                                                                                                                                                                                                                define
565 
                                                                                                                                                                                                                                                                                                                                                                                                                method
566 
                                                                                                                                                                                                                                                                                                                                                                                                                relative-locator
567 
                                                                                                                                                                                                                                                                                                                                                                                                                (locator
568 
                                                                                                                                                                                                                                                                                                                                                                                                                ::
569 
                                                                                                                                                                                                                                                                                                                                                                                                                <physical-locator>,
570 
                                                                                                                                                                                                                                                                                                                                                                                                                    from-locator
571 
                                                                                                                                                                                                                                                                                                                                                                                                                    ::
572 
                                                                                                                                                                                                                                                                                                                                                                                                                    <file-locator>)
573 
                                                                                                                                                                                                                                                                                                                                                                                                                        =>
574 
                                                                                                                                                                                                                                                                                                                                                                                                                        (relative-locator
575 
                                                                                                                                                                                                                                                                                                                                                                                                                        ::
576 
                                                                                                                                                                                                                                                                                                                                                                                                                        <physical-locator>)
577 
                                                                                                                                                                                                                                                                                                                                                                                                                            let
578 
                                                                                                                                                                                                                                                                                                                                                                                                                            from-directory
579 
                                                                                                                                                                                                                                                                                                                                                                                                                            =
580 
                                                                                                                                                                                                                                                                                                                                                                                                                            from-locator.locator-directory;
581 
                                                                                                                                                                                                                                                                                                                                                                                                                            case
582 
                                                                                                                                                                                                                                                                                                                                                                                                                            from-directory
583 
                                                                                                                                                                                                                                                                                                                                                                                                                            =>
584 
                                                                                                                                                                                                                                                                                                                                                                                                                            relative-locator(locator,
585 
                                                                                                                                                                                                                                                                                                                                                                                                                            from-directory);
586 
                                                                                                                                                                                                                                                                                                                                                                                                                            ~locator.locator-relative?
587 
                                                                                                                                                                                                                                                                                                                                                                                                                            =>
588 
                                                                                                                                                                                                                                                                                                                                                                                                                            locator-error
589 
                                                                                                                                                                                                                                                                                                                                                                                                                            ("Cannot
590 
                                                                                                                                                                                                                                                                                                                                                                                                                            find
591 
                                                                                                                                                                                                                                                                                                                                                                                                                            relative
592 
                                                                                                                                                                                                                                                                                                                                                                                                                            path
593 
                                                                                                                                                                                                                                                                                                                                                                                                                            of
594 
                                                                                                                                                                                                                                                                                                                                                                                                                            absolute
595 
                                                                                                                                                                                                                                                                                                                                                                                                                            locator
596 
                                                                                                                                                                                                                                                                                                                                                                                                                            %=
597 
                                                                                                                                                                                                                                                                                                                                                                                                                            from
598 
                                                                                                                                                                                                                                                                                                                                                                                                                            relative
599 
                                                                                                                                                                                                                                                                                                                                                                                                                            locator
600 
                                                                                                                                                                                                                                                                                                                                                                                                                            %=",
601 
                                                                                                                                                                                                                                                                                                                                                                                                                            locator,
602 
                                                                                                                                                                                                                                                                                                                                                                                                                            from-locator);
603 
                                                                                                                                                                                                                                                                                                                                                                                                                            otherwise
604 
                                                                                                                                                                                                                                                                                                                                                                                                                            =>
605 
                                                                                                                                                                                                                                                                                                                                                                                                                            locator;
606 
                                                                                                                                                                                                                                                                                                                                                                                                                            end
607 
                                                                                                                                                                                                                                                                                                                                                                                                                            end
608 
                                                                                                                                                                                                                                                                                                                                                                                                                            method
609 
                                                                                                                                                                                                                                                                                                                                                                                                                            relative-locator;
610 
                                                                                                                                                                                                                                                                                                                                                                                                                            ///
611 
                                                                                                                                                                                                                                                                                                                                                                                                                            Merge
612 
                                                                                                                                                                                                                                                                                                                                                                                                                            locators
613 
                                                                                                                                                                                                                                                                                                                                                                                                                            define
614 
                                                                                                                                                                                                                                                                                                                                                                                                                            open
615 
                                                                                                                                                                                                                                                                                                                                                                                                                            generic
616 
                                                                                                                                                                                                                                                                                                                                                                                                                            merge-locators
617 
                                                                                                                                                                                                                                                                                                                                                                                                                            (locator
618 
                                                                                                                                                                                                                                                                                                                                                                                                                            ::
619 
                                                                                                                                                                                                                                                                                                                                                                                                                            <physical-locator>,
620 
                                                                                                                                                                                                                                                                                                                                                                                                                                from-locator
621 
                                                                                                                                                                                                                                                                                                                                                                                                                                ::
622 
                                                                                                                                                                                                                                                                                                                                                                                                                                <physical-locator>)
623 
                                                                                                                                                                                                                                                                                                                                                                                                                                    =>
624 
                                                                                                                                                                                                                                                                                                                                                                                                                                    (merged-locator
625 
                                                                                                                                                                                                                                                                                                                                                                                                                                    ::
626 
                                                                                                                                                                                                                                                                                                                                                                                                                                    <physical-locator>);
627 
                                                                                                                                                                                                                                                                                                                                                                                                                                        ///
628 
                                                                                                                                                                                                                                                                                                                                                                                                                                        Merge
629 
                                                                                                                                                                                                                                                                                                                                                                                                                                        locators
630 
                                                                                                                                                                                                                                                                                                                                                                                                                                        define
631 
                                                                                                                                                                                                                                                                                                                                                                                                                                        method
632 
                                                                                                                                                                                                                                                                                                                                                                                                                                        merge-locators
633 
                                                                                                                                                                                                                                                                                                                                                                                                                                        (locator
634 
                                                                                                                                                                                                                                                                                                                                                                                                                                        ::
635 
                                                                                                                                                                                                                                                                                                                                                                                                                                        <directory-locator>,
636 
                                                                                                                                                                                                                                                                                                                                                                                                                                            from-locator
637 
                                                                                                                                                                                                                                                                                                                                                                                                                                            ::
638 
                                                                                                                                                                                                                                                                                                                                                                                                                                            <directory-locator>)
639 
                                                                                                                                                                                                                                                                                                                                                                                                                                                =>
640 
                                                                                                                                                                                                                                                                                                                                                                                                                                                (merged-locator
641 
                                                                                                                                                                                                                                                                                                                                                                                                                                                ::
642 
                                                                                                                                                                                                                                                                                                                                                                                                                                                <directory-locator>)
643 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    if
644 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    (locator.locator-relative?)
645 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    let
646 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    path
647 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    =
648 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    concatenate(from-locator.locator-path,
649 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    locator.locator-path);
650 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    simplify-locator
651 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    (make(object-class(locator),
652 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    server:
653 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    from-locator.locator-server,
654 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    path:
655 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    path,
656 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    relative?:
657 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    from-locator.locator-relative?))
658 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    else
659 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    locator
660 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    end
661 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    end
662 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    method
663 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    merge-locators;
664 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    define
665 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    method
666 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    merge-locators
667 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    (locator
668 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ::
669 
                                                                                                                                                                                                                                                                                                                                                                                                                                                    <file-locator>,
670 
                                                                                                                                                                                                                                                                                                                                                                                                                                                        from-locator
671 
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ::
672 
                                                                                                                                                                                                                                                                                                                                                                                                                                                        <directory-locator>)
673 
                                                                                                                                                                                                                                                                                                                                                                                                                                                            =>
674 
                                                                                                                                                                                                                                                                                                                                                                                                                                                            (merged-locator
675 
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ::
676 
                                                                                                                                                                                                                                                                                                                                                                                                                                                            <file-locator>)
677 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                let
678 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                directory
679 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                =
680 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                locator.locator-directory;
681 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                let
682 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                merged-directory
683 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                =
684 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                if
685 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (directory)
686 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                merge-locators(directory,
687 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                from-locator)
688 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                else
689 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                simplify-locator(from-locator)
690 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                end;
691 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                if
692 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (merged-directory
693 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ~=
694 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                directory)
695 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                make(object-class(locator),
696 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                directory:
697 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                merged-directory,
698 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                base:
699 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                locator.locator-base,
700 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                extension:
701 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                locator.locator-extension)
702 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                else
703 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                locator
704 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                end
705 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                end
706 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                method
707 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                merge-locators;
708 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                define
709 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                method
710 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                merge-locators
711 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (locator
712 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ::
713 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                <physical-locator>,
714 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    from-locator
715 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ::
716 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <file-locator>)
717 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        =>
718 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (merged-locator
719 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ::
720 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <physical-locator>)
721 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let
722 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            from-directory
723 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            =
724 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            from-locator.locator-directory;
725 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if
726 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (from-directory)
727 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            merge-locators(locator,
728 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            from-directory)
729 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            else
730 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            locator
731 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            end
732 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            end
733 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method
734 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            merge-locators;
735 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ///
736 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Locator
737 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protocols
738 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            define
739 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sideways
740 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method
741 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            supports-open-locator?
742 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (locator
743 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ::
744 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <file-locator>)
745 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                =>
746 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (openable?
747 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ::
748 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <boolean>)
749 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ~locator.locator-relative?
750 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    end
751 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method
752 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    supports-open-locator?;
753 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    define
754 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sideways
755 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method
756 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    open-locator
757 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (locator
758 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ::
759 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <file-locator>,
760 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #rest
761 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keywords,
762 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #key,
763 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #all-keys)
764 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        =>
765 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (stream
766 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ::
767 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <stream>)
768 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            apply(open-file-stream,
769 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            locator,
770 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            keywords)
771 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            end
772 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method
773 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            open-locator;
774 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            </textarea>
775 
    </div>
776 
    <script>
777 
        var editor = CodeMirror.fromTextArea(document.getElementById("code"),
778 
        {
779 
            mode: "text/x-dylan",
780 
            lineNumbers: true,
781 
            matchBrackets: true,
782 
            continueComments: "Enter",
783 
            extraKeys:
784 
            {
785 
                "Ctrl-Q": "toggleComment"
786 
            },
787 
            tabMode: "indent",
788 
            indentUnit: 2
789 
        });
790 
    </script>
791 
    <p>
792 
        <strong>MIME types defined:</strong> <code>text/x-dylan</code>.</p>
793 
</article>