Mercurial
comparison .cms/lib/codemirror/mode/dylan/index.html @ 0:78edf6b517a0 draft
24.10
author | Coffee CMS <info@coffee-cms.ru> |
---|---|
date | Fri, 11 Oct 2024 22:40:23 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:78edf6b517a0 |
---|---|
1 <!doctype html> | |
2 | |
3 <title>CodeMirror: Dylan mode</title> | |
4 <meta charset="utf-8"/> | |
5 <link rel=stylesheet href="../../doc/docs.css"> | |
6 | |
7 <link rel="stylesheet" href="../../lib/codemirror.css"> | |
8 <script src="../../lib/codemirror.js"></script> | |
9 <script src="../../addon/edit/matchbrackets.js"></script> | |
10 <script src="../../addon/comment/continuecomment.js"></script> | |
11 <script src="../../addon/comment/comment.js"></script> | |
12 <script src="dylan.js"></script> | |
13 <style>.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style> | |
14 <div id=nav> | |
15 <a href="https://codemirror.net/5"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png" alt=""></a> | |
16 | |
17 <ul> | |
18 <li><a href="../../index.html">Home</a> | |
19 <li><a href="../../doc/manual.html">Manual</a> | |
20 <li><a href="https://github.com/codemirror/codemirror5">Code</a> | |
21 </ul> | |
22 <ul> | |
23 <li><a href="../index.html">Language modes</a> | |
24 <li><a class=active href="#">Dylan</a> | |
25 </ul> | |
26 </div> | |
27 | |
28 <article> | |
29 <h2>Dylan mode</h2> | |
30 | |
31 | |
32 <div><textarea id="code" name="code"> | |
33 Module: locators-internals | |
34 Synopsis: Abstract modeling of locations | |
35 Author: Andy Armstrong | |
36 Copyright: Original Code is Copyright (c) 1995-2004 Functional Objects, Inc. | |
37 All rights reserved. | |
38 License: See License.txt in this distribution for details. | |
39 Warranty: Distributed WITHOUT WARRANTY OF ANY KIND | |
40 | |
41 define open generic locator-server | |
42 (locator :: <locator>) => (server :: false-or(<server-locator>)); | |
43 define open generic locator-host | |
44 (locator :: <locator>) => (host :: false-or(<string>)); | |
45 define open generic locator-volume | |
46 (locator :: <locator>) => (volume :: false-or(<string>)); | |
47 define open generic locator-directory | |
48 (locator :: <locator>) => (directory :: false-or(<directory-locator>)); | |
49 define open generic locator-relative? | |
50 (locator :: <locator>) => (relative? :: <boolean>); | |
51 define open generic locator-path | |
52 (locator :: <locator>) => (path :: <sequence>); | |
53 define open generic locator-base | |
54 (locator :: <locator>) => (base :: false-or(<string>)); | |
55 define open generic locator-extension | |
56 (locator :: <locator>) => (extension :: false-or(<string>)); | |
57 | |
58 /// Locator classes | |
59 | |
60 define open abstract class <directory-locator> (<physical-locator>) | |
61 end class <directory-locator>; | |
62 | |
63 define open abstract class <file-locator> (<physical-locator>) | |
64 end class <file-locator>; | |
65 | |
66 define method as | |
67 (class == <directory-locator>, string :: <string>) | |
68 => (locator :: <directory-locator>) | |
69 as(<native-directory-locator>, string) | |
70 end method as; | |
71 | |
72 define method make | |
73 (class == <directory-locator>, | |
74 #key server :: false-or(<server-locator>) = #f, | |
75 path :: <sequence> = #[], | |
76 relative? :: <boolean> = #f, | |
77 name :: false-or(<string>) = #f) | |
78 => (locator :: <directory-locator>) | |
79 make(<native-directory-locator>, | |
80 server: server, | |
81 path: path, | |
82 relative?: relative?, | |
83 name: name) | |
84 end method make; | |
85 | |
86 define method as | |
87 (class == <file-locator>, string :: <string>) | |
88 => (locator :: <file-locator>) | |
89 as(<native-file-locator>, string) | |
90 end method as; | |
91 | |
92 define method make | |
93 (class == <file-locator>, | |
94 #key directory :: false-or(<directory-locator>) = #f, | |
95 base :: false-or(<string>) = #f, | |
96 extension :: false-or(<string>) = #f, | |
97 name :: false-or(<string>) = #f) | |
98 => (locator :: <file-locator>) | |
99 make(<native-file-locator>, | |
100 directory: directory, | |
101 base: base, | |
102 extension: extension, | |
103 name: name) | |
104 end method make; | |
105 | |
106 /// Locator coercion | |
107 | |
108 //---*** andrewa: This caching scheme doesn't work yet, so disable it. | |
109 define constant $cache-locators? = #f; | |
110 define constant $cache-locator-strings? = #f; | |
111 | |
112 define constant $locator-to-string-cache = make(<object-table>, weak: #"key"); | |
113 define constant $string-to-locator-cache = make(<string-table>, weak: #"value"); | |
114 | |
115 define open generic locator-as-string | |
116 (class :: subclass(<string>), locator :: <locator>) | |
117 => (string :: <string>); | |
118 | |
119 define open generic string-as-locator | |
120 (class :: subclass(<locator>), string :: <string>) | |
121 => (locator :: <locator>); | |
122 | |
123 define sealed sideways method as | |
124 (class :: subclass(<string>), locator :: <locator>) | |
125 => (string :: <string>) | |
126 let string = element($locator-to-string-cache, locator, default: #f); | |
127 if (string) | |
128 as(class, string) | |
129 else | |
130 let string = locator-as-string(class, locator); | |
131 if ($cache-locator-strings?) | |
132 element($locator-to-string-cache, locator) := string; | |
133 else | |
134 string | |
135 end | |
136 end | |
137 end method as; | |
138 | |
139 define sealed sideways method as | |
140 (class :: subclass(<locator>), string :: <string>) | |
141 => (locator :: <locator>) | |
142 let locator = element($string-to-locator-cache, string, default: #f); | |
143 if (instance?(locator, class)) | |
144 locator | |
145 else | |
146 let locator = string-as-locator(class, string); | |
147 if ($cache-locators?) | |
148 element($string-to-locator-cache, string) := locator; | |
149 else | |
150 locator | |
151 end | |
152 end | |
153 end method as; | |
154 | |
155 /// Locator conditions | |
156 | |
157 define class <locator-error> (<format-string-condition>, <error>) | |
158 end class <locator-error>; | |
159 | |
160 define function locator-error | |
161 (format-string :: <string>, #rest format-arguments) | |
162 error(make(<locator-error>, | |
163 format-string: format-string, | |
164 format-arguments: format-arguments)) | |
165 end function locator-error; | |
166 | |
167 /// Useful locator protocols | |
168 | |
169 define open generic locator-test | |
170 (locator :: <directory-locator>) => (test :: <function>); | |
171 | |
172 define method locator-test | |
173 (locator :: <directory-locator>) => (test :: <function>) | |
174 \= | |
175 end method locator-test; | |
176 | |
177 define open generic locator-might-have-links? | |
178 (locator :: <directory-locator>) => (links? :: <boolean>); | |
179 | |
180 define method locator-might-have-links? | |
181 (locator :: <directory-locator>) => (links? :: singleton(#f)) | |
182 #f | |
183 end method locator-might-have-links?; | |
184 | |
185 define method locator-relative? | |
186 (locator :: <file-locator>) => (relative? :: <boolean>) | |
187 let directory = locator.locator-directory; | |
188 ~directory | directory.locator-relative? | |
189 end method locator-relative?; | |
190 | |
191 define method current-directory-locator? | |
192 (locator :: <directory-locator>) => (current-directory? :: <boolean>) | |
193 locator.locator-relative? | |
194 & locator.locator-path = #[#"self"] | |
195 end method current-directory-locator?; | |
196 | |
197 define method locator-directory | |
198 (locator :: <directory-locator>) => (parent :: false-or(<directory-locator>)) | |
199 let path = locator.locator-path; | |
200 unless (empty?(path)) | |
201 make(object-class(locator), | |
202 server: locator.locator-server, | |
203 path: copy-sequence(path, end: path.size - 1), | |
204 relative?: locator.locator-relative?) | |
205 end | |
206 end method locator-directory; | |
207 | |
208 /// Simplify locator | |
209 | |
210 define open generic simplify-locator | |
211 (locator :: <physical-locator>) | |
212 => (simplified-locator :: <physical-locator>); | |
213 | |
214 define method simplify-locator | |
215 (locator :: <directory-locator>) | |
216 => (simplified-locator :: <directory-locator>) | |
217 let path = locator.locator-path; | |
218 let relative? = locator.locator-relative?; | |
219 let resolve-parent? = ~locator.locator-might-have-links?; | |
220 let simplified-path | |
221 = simplify-path(path, | |
222 resolve-parent?: resolve-parent?, | |
223 relative?: relative?); | |
224 if (path ~= simplified-path) | |
225 make(object-class(locator), | |
226 server: locator.locator-server, | |
227 path: simplified-path, | |
228 relative?: locator.locator-relative?) | |
229 else | |
230 locator | |
231 end | |
232 end method simplify-locator; | |
233 | |
234 define method simplify-locator | |
235 (locator :: <file-locator>) => (simplified-locator :: <file-locator>) | |
236 let directory = locator.locator-directory; | |
237 let simplified-directory = directory & simplify-locator(directory); | |
238 if (directory ~= simplified-directory) | |
239 make(object-class(locator), | |
240 directory: simplified-directory, | |
241 base: locator.locator-base, | |
242 extension: locator.locator-extension) | |
243 else | |
244 locator | |
245 end | |
246 end method simplify-locator; | |
247 | |
248 /// Subdirectory locator | |
249 | |
250 define open generic subdirectory-locator | |
251 (locator :: <directory-locator>, #rest sub-path) | |
252 => (subdirectory :: <directory-locator>); | |
253 | |
254 define method subdirectory-locator | |
255 (locator :: <directory-locator>, #rest sub-path) | |
256 => (subdirectory :: <directory-locator>) | |
257 let old-path = locator.locator-path; | |
258 let new-path = concatenate-as(<simple-object-vector>, old-path, sub-path); | |
259 make(object-class(locator), | |
260 server: locator.locator-server, | |
261 path: new-path, | |
262 relative?: locator.locator-relative?) | |
263 end method subdirectory-locator; | |
264 | |
265 /// Relative locator | |
266 | |
267 define open generic relative-locator | |
268 (locator :: <physical-locator>, from-locator :: <physical-locator>) | |
269 => (relative-locator :: <physical-locator>); | |
270 | |
271 define method relative-locator | |
272 (locator :: <directory-locator>, from-locator :: <directory-locator>) | |
273 => (relative-locator :: <directory-locator>) | |
274 let path = locator.locator-path; | |
275 let from-path = from-locator.locator-path; | |
276 case | |
277 ~locator.locator-relative? & from-locator.locator-relative? => | |
278 locator-error | |
279 ("Cannot find relative path of absolute locator %= from relative locator %=", | |
280 locator, from-locator); | |
281 locator.locator-server ~= from-locator.locator-server => | |
282 locator; | |
283 path = from-path => | |
284 make(object-class(locator), | |
285 path: vector(#"self"), | |
286 relative?: #t); | |
287 otherwise => | |
288 make(object-class(locator), | |
289 path: relative-path(path, from-path, test: locator.locator-test), | |
290 relative?: #t); | |
291 end | |
292 end method relative-locator; | |
293 | |
294 define method relative-locator | |
295 (locator :: <file-locator>, from-directory :: <directory-locator>) | |
296 => (relative-locator :: <file-locator>) | |
297 let directory = locator.locator-directory; | |
298 let relative-directory = directory & relative-locator(directory, from-directory); | |
299 if (relative-directory ~= directory) | |
300 simplify-locator | |
301 (make(object-class(locator), | |
302 directory: relative-directory, | |
303 base: locator.locator-base, | |
304 extension: locator.locator-extension)) | |
305 else | |
306 locator | |
307 end | |
308 end method relative-locator; | |
309 | |
310 define method relative-locator | |
311 (locator :: <physical-locator>, from-locator :: <file-locator>) | |
312 => (relative-locator :: <physical-locator>) | |
313 let from-directory = from-locator.locator-directory; | |
314 case | |
315 from-directory => | |
316 relative-locator(locator, from-directory); | |
317 ~locator.locator-relative? => | |
318 locator-error | |
319 ("Cannot find relative path of absolute locator %= from relative locator %=", | |
320 locator, from-locator); | |
321 otherwise => | |
322 locator; | |
323 end | |
324 end method relative-locator; | |
325 | |
326 /// Merge locators | |
327 | |
328 define open generic merge-locators | |
329 (locator :: <physical-locator>, from-locator :: <physical-locator>) | |
330 => (merged-locator :: <physical-locator>); | |
331 | |
332 /// Merge locators | |
333 | |
334 define method merge-locators | |
335 (locator :: <directory-locator>, from-locator :: <directory-locator>) | |
336 => (merged-locator :: <directory-locator>) | |
337 if (locator.locator-relative?) | |
338 let path = concatenate(from-locator.locator-path, locator.locator-path); | |
339 simplify-locator | |
340 (make(object-class(locator), | |
341 server: from-locator.locator-server, | |
342 path: path, | |
343 relative?: from-locator.locator-relative?)) | |
344 else | |
345 locator | |
346 end | |
347 end method merge-locators; | |
348 | |
349 define method merge-locators | |
350 (locator :: <file-locator>, from-locator :: <directory-locator>) | |
351 => (merged-locator :: <file-locator>) | |
352 let directory = locator.locator-directory; | |
353 let merged-directory | |
354 = if (directory) | |
355 merge-locators(directory, from-locator) | |
356 else | |
357 simplify-locator(from-locator) | |
358 end; | |
359 if (merged-directory ~= directory) | |
360 make(object-class(locator), | |
361 directory: merged-directory, | |
362 base: locator.locator-base, | |
363 extension: locator.locator-extension) | |
364 else | |
365 locator | |
366 end | |
367 end method merge-locators; | |
368 | |
369 define method merge-locators | |
370 (locator :: <physical-locator>, from-locator :: <file-locator>) | |
371 => (merged-locator :: <physical-locator>) | |
372 let from-directory = from-locator.locator-directory; | |
373 if (from-directory) | |
374 merge-locators(locator, from-directory) | |
375 else | |
376 locator | |
377 end | |
378 end method merge-locators; | |
379 | |
380 /// Locator protocols | |
381 | |
382 define sideways method supports-open-locator? | |
383 (locator :: <file-locator>) => (openable? :: <boolean>) | |
384 ~locator.locator-relative? | |
385 end method supports-open-locator?; | |
386 | |
387 define sideways method open-locator | |
388 (locator :: <file-locator>, #rest keywords, #key, #all-keys) | |
389 => (stream :: <stream>) | |
390 apply(open-file-stream, locator, keywords) | |
391 end method open-locator; | |
392 </textarea></div> | |
393 | |
394 <script> | |
395 var editor = CodeMirror.fromTextArea(document.getElementById("code"), { | |
396 mode: "text/x-dylan", | |
397 lineNumbers: true, | |
398 matchBrackets: true, | |
399 continueComments: "Enter", | |
400 extraKeys: {"Ctrl-Q": "toggleComment"}, | |
401 tabMode: "indent", | |
402 indentUnit: 2 | |
403 }); | |
404 </script> | |
405 | |
406 <p><strong>MIME types defined:</strong> <code>text/x-dylan</code>.</p> | |
407 </article> |