.
This commit is contained in:
299
root/res/editor.md/lib/codemirror/mode/dylan/dylan.js
vendored
Normal file
299
root/res/editor.md/lib/codemirror/mode/dylan/dylan.js
vendored
Normal file
@@ -0,0 +1,299 @@
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function(mod) {
|
||||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
||||
mod(require("../../lib/codemirror"));
|
||||
else if (typeof define == "function" && define.amd) // AMD
|
||||
define(["../../lib/codemirror"], mod);
|
||||
else // Plain browser env
|
||||
mod(CodeMirror);
|
||||
})(function(CodeMirror) {
|
||||
"use strict";
|
||||
|
||||
CodeMirror.defineMode("dylan", function(_config) {
|
||||
// Words
|
||||
var words = {
|
||||
// Words that introduce unnamed definitions like "define interface"
|
||||
unnamedDefinition: ["interface"],
|
||||
|
||||
// Words that introduce simple named definitions like "define library"
|
||||
namedDefinition: ["module", "library", "macro",
|
||||
"C-struct", "C-union",
|
||||
"C-function", "C-callable-wrapper"
|
||||
],
|
||||
|
||||
// Words that introduce type definitions like "define class".
|
||||
// These are also parameterized like "define method" and are
|
||||
// appended to otherParameterizedDefinitionWords
|
||||
typeParameterizedDefinition: ["class", "C-subtype", "C-mapped-subtype"],
|
||||
|
||||
// Words that introduce trickier definitions like "define method".
|
||||
// These require special definitions to be added to startExpressions
|
||||
otherParameterizedDefinition: ["method", "function",
|
||||
"C-variable", "C-address"
|
||||
],
|
||||
|
||||
// Words that introduce module constant definitions.
|
||||
// These must also be simple definitions and are
|
||||
// appended to otherSimpleDefinitionWords
|
||||
constantSimpleDefinition: ["constant"],
|
||||
|
||||
// Words that introduce module variable definitions.
|
||||
// These must also be simple definitions and are
|
||||
// appended to otherSimpleDefinitionWords
|
||||
variableSimpleDefinition: ["variable"],
|
||||
|
||||
// Other words that introduce simple definitions
|
||||
// (without implicit bodies).
|
||||
otherSimpleDefinition: ["generic", "domain",
|
||||
"C-pointer-type",
|
||||
"table"
|
||||
],
|
||||
|
||||
// Words that begin statements with implicit bodies.
|
||||
statement: ["if", "block", "begin", "method", "case",
|
||||
"for", "select", "when", "unless", "until",
|
||||
"while", "iterate", "profiling", "dynamic-bind"
|
||||
],
|
||||
|
||||
// Patterns that act as separators in compound statements.
|
||||
// This may include any general pattern that must be indented
|
||||
// specially.
|
||||
separator: ["finally", "exception", "cleanup", "else",
|
||||
"elseif", "afterwards"
|
||||
],
|
||||
|
||||
// Keywords that do not require special indentation handling,
|
||||
// but which should be highlighted
|
||||
other: ["above", "below", "by", "from", "handler", "in",
|
||||
"instance", "let", "local", "otherwise", "slot",
|
||||
"subclass", "then", "to", "keyed-by", "virtual"
|
||||
],
|
||||
|
||||
// Condition signaling function calls
|
||||
signalingCalls: ["signal", "error", "cerror",
|
||||
"break", "check-type", "abort"
|
||||
]
|
||||
};
|
||||
|
||||
words["otherDefinition"] =
|
||||
words["unnamedDefinition"]
|
||||
.concat(words["namedDefinition"])
|
||||
.concat(words["otherParameterizedDefinition"]);
|
||||
|
||||
words["definition"] =
|
||||
words["typeParameterizedDefinition"]
|
||||
.concat(words["otherDefinition"]);
|
||||
|
||||
words["parameterizedDefinition"] =
|
||||
words["typeParameterizedDefinition"]
|
||||
.concat(words["otherParameterizedDefinition"]);
|
||||
|
||||
words["simpleDefinition"] =
|
||||
words["constantSimpleDefinition"]
|
||||
.concat(words["variableSimpleDefinition"])
|
||||
.concat(words["otherSimpleDefinition"]);
|
||||
|
||||
words["keyword"] =
|
||||
words["statement"]
|
||||
.concat(words["separator"])
|
||||
.concat(words["other"]);
|
||||
|
||||
// Patterns
|
||||
var symbolPattern = "[-_a-zA-Z?!*@<>$%]+";
|
||||
var symbol = new RegExp("^" + symbolPattern);
|
||||
var patterns = {
|
||||
// Symbols with special syntax
|
||||
symbolKeyword: symbolPattern + ":",
|
||||
symbolClass: "<" + symbolPattern + ">",
|
||||
symbolGlobal: "\\*" + symbolPattern + "\\*",
|
||||
symbolConstant: "\\$" + symbolPattern
|
||||
};
|
||||
var patternStyles = {
|
||||
symbolKeyword: "atom",
|
||||
symbolClass: "tag",
|
||||
symbolGlobal: "variable-2",
|
||||
symbolConstant: "variable-3"
|
||||
};
|
||||
|
||||
// Compile all patterns to regular expressions
|
||||
for (var patternName in patterns)
|
||||
if (patterns.hasOwnProperty(patternName))
|
||||
patterns[patternName] = new RegExp("^" + patterns[patternName]);
|
||||
|
||||
// Names beginning "with-" and "without-" are commonly
|
||||
// used as statement macro
|
||||
patterns["keyword"] = [/^with(?:out)?-[-_a-zA-Z?!*@<>$%]+/];
|
||||
|
||||
var styles = {};
|
||||
styles["keyword"] = "keyword";
|
||||
styles["definition"] = "def";
|
||||
styles["simpleDefinition"] = "def";
|
||||
styles["signalingCalls"] = "builtin";
|
||||
|
||||
// protected words lookup table
|
||||
var wordLookup = {};
|
||||
var styleLookup = {};
|
||||
|
||||
[
|
||||
"keyword",
|
||||
"definition",
|
||||
"simpleDefinition",
|
||||
"signalingCalls"
|
||||
].forEach(function(type) {
|
||||
words[type].forEach(function(word) {
|
||||
wordLookup[word] = type;
|
||||
styleLookup[word] = styles[type];
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
function chain(stream, state, f) {
|
||||
state.tokenize = f;
|
||||
return f(stream, state);
|
||||
}
|
||||
|
||||
var type, content;
|
||||
|
||||
function ret(_type, style, _content) {
|
||||
type = _type;
|
||||
content = _content;
|
||||
return style;
|
||||
}
|
||||
|
||||
function tokenBase(stream, state) {
|
||||
// String
|
||||
var ch = stream.peek();
|
||||
if (ch == "'" || ch == '"') {
|
||||
stream.next();
|
||||
return chain(stream, state, tokenString(ch, "string", "string"));
|
||||
}
|
||||
// Comment
|
||||
else if (ch == "/") {
|
||||
stream.next();
|
||||
if (stream.eat("*")) {
|
||||
return chain(stream, state, tokenComment);
|
||||
} else if (stream.eat("/")) {
|
||||
stream.skipToEnd();
|
||||
return ret("comment", "comment");
|
||||
} else {
|
||||
stream.skipTo(" ");
|
||||
return ret("operator", "operator");
|
||||
}
|
||||
}
|
||||
// Decimal
|
||||
else if (/\d/.test(ch)) {
|
||||
stream.match(/^\d*(?:\.\d*)?(?:e[+\-]?\d+)?/);
|
||||
return ret("number", "number");
|
||||
}
|
||||
// Hash
|
||||
else if (ch == "#") {
|
||||
stream.next();
|
||||
// Symbol with string syntax
|
||||
ch = stream.peek();
|
||||
if (ch == '"') {
|
||||
stream.next();
|
||||
return chain(stream, state, tokenString('"', "symbol", "string-2"));
|
||||
}
|
||||
// Binary number
|
||||
else if (ch == "b") {
|
||||
stream.next();
|
||||
stream.eatWhile(/[01]/);
|
||||
return ret("number", "number");
|
||||
}
|
||||
// Hex number
|
||||
else if (ch == "x") {
|
||||
stream.next();
|
||||
stream.eatWhile(/[\da-f]/i);
|
||||
return ret("number", "number");
|
||||
}
|
||||
// Octal number
|
||||
else if (ch == "o") {
|
||||
stream.next();
|
||||
stream.eatWhile(/[0-7]/);
|
||||
return ret("number", "number");
|
||||
}
|
||||
// Hash symbol
|
||||
else {
|
||||
stream.eatWhile(/[-a-zA-Z]/);
|
||||
return ret("hash", "keyword");
|
||||
}
|
||||
} else if (stream.match("end")) {
|
||||
return ret("end", "keyword");
|
||||
}
|
||||
for (var name in patterns) {
|
||||
if (patterns.hasOwnProperty(name)) {
|
||||
var pattern = patterns[name];
|
||||
if ((pattern instanceof Array && pattern.some(function(p) {
|
||||
return stream.match(p);
|
||||
})) || stream.match(pattern))
|
||||
return ret(name, patternStyles[name], stream.current());
|
||||
}
|
||||
}
|
||||
if (stream.match("define")) {
|
||||
return ret("definition", "def");
|
||||
} else {
|
||||
stream.eatWhile(/[\w\-]/);
|
||||
// Keyword
|
||||
if (wordLookup[stream.current()]) {
|
||||
return ret(wordLookup[stream.current()], styleLookup[stream.current()], stream.current());
|
||||
} else if (stream.current().match(symbol)) {
|
||||
return ret("variable", "variable");
|
||||
} else {
|
||||
stream.next();
|
||||
return ret("other", "variable-2");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function tokenComment(stream, state) {
|
||||
var maybeEnd = false,
|
||||
ch;
|
||||
while ((ch = stream.next())) {
|
||||
if (ch == "/" && maybeEnd) {
|
||||
state.tokenize = tokenBase;
|
||||
break;
|
||||
}
|
||||
maybeEnd = (ch == "*");
|
||||
}
|
||||
return ret("comment", "comment");
|
||||
}
|
||||
|
||||
function tokenString(quote, type, style) {
|
||||
return function(stream, state) {
|
||||
var next, end = false;
|
||||
while ((next = stream.next()) != null) {
|
||||
if (next == quote) {
|
||||
end = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (end)
|
||||
state.tokenize = tokenBase;
|
||||
return ret(type, style);
|
||||
};
|
||||
}
|
||||
|
||||
// Interface
|
||||
return {
|
||||
startState: function() {
|
||||
return {
|
||||
tokenize: tokenBase,
|
||||
currentIndent: 0
|
||||
};
|
||||
},
|
||||
token: function(stream, state) {
|
||||
if (stream.eatSpace())
|
||||
return null;
|
||||
var style = state.tokenize(stream, state);
|
||||
return style;
|
||||
},
|
||||
blockCommentStart: "/*",
|
||||
blockCommentEnd: "*/"
|
||||
};
|
||||
});
|
||||
|
||||
CodeMirror.defineMIME("text/x-dylan", "dylan");
|
||||
|
||||
});
|
||||
407
root/res/editor.md/lib/codemirror/mode/dylan/index.html
vendored
Normal file
407
root/res/editor.md/lib/codemirror/mode/dylan/index.html
vendored
Normal file
@@ -0,0 +1,407 @@
|
||||
<!doctype html>
|
||||
|
||||
<title>CodeMirror: Dylan mode</title>
|
||||
<meta charset="utf-8"/>
|
||||
<link rel=stylesheet href="../../doc/docs.css">
|
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css">
|
||||
<script src="../../lib/codemirror.js"></script>
|
||||
<script src="../../addon/edit/matchbrackets.js"></script>
|
||||
<script src="../../addon/comment/continuecomment.js"></script>
|
||||
<script src="../../addon/comment/comment.js"></script>
|
||||
<script src="dylan.js"></script>
|
||||
<style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
|
||||
<div id=nav>
|
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
|
||||
|
||||
<ul>
|
||||
<li><a href="../../index.html">Home</a>
|
||||
<li><a href="../../doc/manual.html">Manual</a>
|
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a>
|
||||
</ul>
|
||||
<ul>
|
||||
<li><a href="../index.html">Language modes</a>
|
||||
<li><a class=active href="#">Dylan</a>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<article>
|
||||
<h2>Dylan mode</h2>
|
||||
|
||||
|
||||
<div><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.
|
||||
Warranty: Distributed WITHOUT WARRANTY OF ANY KIND
|
||||
|
||||
define open generic locator-server
|
||||
(locator :: <locator>) => (server :: false-or(<server-locator>));
|
||||
define open generic locator-host
|
||||
(locator :: <locator>) => (host :: false-or(<string>));
|
||||
define open generic locator-volume
|
||||
(locator :: <locator>) => (volume :: false-or(<string>));
|
||||
define open generic locator-directory
|
||||
(locator :: <locator>) => (directory :: false-or(<directory-locator>));
|
||||
define open generic locator-relative?
|
||||
(locator :: <locator>) => (relative? :: <boolean>);
|
||||
define open generic locator-path
|
||||
(locator :: <locator>) => (path :: <sequence>);
|
||||
define open generic locator-base
|
||||
(locator :: <locator>) => (base :: false-or(<string>));
|
||||
define open generic locator-extension
|
||||
(locator :: <locator>) => (extension :: false-or(<string>));
|
||||
|
||||
/// Locator classes
|
||||
|
||||
define open abstract class <directory-locator> (<physical-locator>)
|
||||
end class <directory-locator>;
|
||||
|
||||
define open abstract class <file-locator> (<physical-locator>)
|
||||
end class <file-locator>;
|
||||
|
||||
define method as
|
||||
(class == <directory-locator>, string :: <string>)
|
||||
=> (locator :: <directory-locator>)
|
||||
as(<native-directory-locator>, string)
|
||||
end method as;
|
||||
|
||||
define method make
|
||||
(class == <directory-locator>,
|
||||
#key server :: false-or(<server-locator>) = #f,
|
||||
path :: <sequence> = #[],
|
||||
relative? :: <boolean> = #f,
|
||||
name :: false-or(<string>) = #f)
|
||||
=> (locator :: <directory-locator>)
|
||||
make(<native-directory-locator>,
|
||||
server: server,
|
||||
path: path,
|
||||
relative?: relative?,
|
||||
name: name)
|
||||
end method make;
|
||||
|
||||
define method as
|
||||
(class == <file-locator>, string :: <string>)
|
||||
=> (locator :: <file-locator>)
|
||||
as(<native-file-locator>, string)
|
||||
end method as;
|
||||
|
||||
define method make
|
||||
(class == <file-locator>,
|
||||
#key directory :: false-or(<directory-locator>) = #f,
|
||||
base :: false-or(<string>) = #f,
|
||||
extension :: false-or(<string>) = #f,
|
||||
name :: false-or(<string>) = #f)
|
||||
=> (locator :: <file-locator>)
|
||||
make(<native-file-locator>,
|
||||
directory: directory,
|
||||
base: base,
|
||||
extension: extension,
|
||||
name: name)
|
||||
end method make;
|
||||
|
||||
/// Locator coercion
|
||||
|
||||
//---*** andrewa: This caching scheme doesn't work yet, so disable it.
|
||||
define constant $cache-locators? = #f;
|
||||
define constant $cache-locator-strings? = #f;
|
||||
|
||||
define constant $locator-to-string-cache = make(<object-table>, weak: #"key");
|
||||
define constant $string-to-locator-cache = make(<string-table>, weak: #"value");
|
||||
|
||||
define open generic locator-as-string
|
||||
(class :: subclass(<string>), locator :: <locator>)
|
||||
=> (string :: <string>);
|
||||
|
||||
define open generic string-as-locator
|
||||
(class :: subclass(<locator>), string :: <string>)
|
||||
=> (locator :: <locator>);
|
||||
|
||||
define sealed sideways method as
|
||||
(class :: subclass(<string>), locator :: <locator>)
|
||||
=> (string :: <string>)
|
||||
let string = element($locator-to-string-cache, locator, default: #f);
|
||||
if (string)
|
||||
as(class, string)
|
||||
else
|
||||
let string = locator-as-string(class, locator);
|
||||
if ($cache-locator-strings?)
|
||||
element($locator-to-string-cache, locator) := string;
|
||||
else
|
||||
string
|
||||
end
|
||||
end
|
||||
end method as;
|
||||
|
||||
define sealed sideways method as
|
||||
(class :: subclass(<locator>), string :: <string>)
|
||||
=> (locator :: <locator>)
|
||||
let locator = element($string-to-locator-cache, string, default: #f);
|
||||
if (instance?(locator, class))
|
||||
locator
|
||||
else
|
||||
let locator = string-as-locator(class, string);
|
||||
if ($cache-locators?)
|
||||
element($string-to-locator-cache, string) := locator;
|
||||
else
|
||||
locator
|
||||
end
|
||||
end
|
||||
end method as;
|
||||
|
||||
/// Locator conditions
|
||||
|
||||
define class <locator-error> (<format-string-condition>, <error>)
|
||||
end class <locator-error>;
|
||||
|
||||
define function locator-error
|
||||
(format-string :: <string>, #rest format-arguments)
|
||||
error(make(<locator-error>,
|
||||
format-string: format-string,
|
||||
format-arguments: format-arguments))
|
||||
end function locator-error;
|
||||
|
||||
/// Useful locator protocols
|
||||
|
||||
define open generic locator-test
|
||||
(locator :: <directory-locator>) => (test :: <function>);
|
||||
|
||||
define method locator-test
|
||||
(locator :: <directory-locator>) => (test :: <function>)
|
||||
\=
|
||||
end method locator-test;
|
||||
|
||||
define open generic locator-might-have-links?
|
||||
(locator :: <directory-locator>) => (links? :: <boolean>);
|
||||
|
||||
define method locator-might-have-links?
|
||||
(locator :: <directory-locator>) => (links? :: singleton(#f))
|
||||
#f
|
||||
end method locator-might-have-links?;
|
||||
|
||||
define method locator-relative?
|
||||
(locator :: <file-locator>) => (relative? :: <boolean>)
|
||||
let directory = locator.locator-directory;
|
||||
~directory | directory.locator-relative?
|
||||
end method locator-relative?;
|
||||
|
||||
define method current-directory-locator?
|
||||
(locator :: <directory-locator>) => (current-directory? :: <boolean>)
|
||||
locator.locator-relative?
|
||||
& locator.locator-path = #[#"self"]
|
||||
end method current-directory-locator?;
|
||||
|
||||
define method locator-directory
|
||||
(locator :: <directory-locator>) => (parent :: false-or(<directory-locator>))
|
||||
let path = locator.locator-path;
|
||||
unless (empty?(path))
|
||||
make(object-class(locator),
|
||||
server: locator.locator-server,
|
||||
path: copy-sequence(path, end: path.size - 1),
|
||||
relative?: locator.locator-relative?)
|
||||
end
|
||||
end method locator-directory;
|
||||
|
||||
/// Simplify locator
|
||||
|
||||
define open generic simplify-locator
|
||||
(locator :: <physical-locator>)
|
||||
=> (simplified-locator :: <physical-locator>);
|
||||
|
||||
define method simplify-locator
|
||||
(locator :: <directory-locator>)
|
||||
=> (simplified-locator :: <directory-locator>)
|
||||
let path = locator.locator-path;
|
||||
let relative? = locator.locator-relative?;
|
||||
let resolve-parent? = ~locator.locator-might-have-links?;
|
||||
let simplified-path
|
||||
= simplify-path(path,
|
||||
resolve-parent?: resolve-parent?,
|
||||
relative?: relative?);
|
||||
if (path ~= simplified-path)
|
||||
make(object-class(locator),
|
||||
server: locator.locator-server,
|
||||
path: simplified-path,
|
||||
relative?: locator.locator-relative?)
|
||||
else
|
||||
locator
|
||||
end
|
||||
end method simplify-locator;
|
||||
|
||||
define method simplify-locator
|
||||
(locator :: <file-locator>) => (simplified-locator :: <file-locator>)
|
||||
let directory = locator.locator-directory;
|
||||
let simplified-directory = directory & simplify-locator(directory);
|
||||
if (directory ~= simplified-directory)
|
||||
make(object-class(locator),
|
||||
directory: simplified-directory,
|
||||
base: locator.locator-base,
|
||||
extension: locator.locator-extension)
|
||||
else
|
||||
locator
|
||||
end
|
||||
end method simplify-locator;
|
||||
|
||||
/// Subdirectory locator
|
||||
|
||||
define open generic subdirectory-locator
|
||||
(locator :: <directory-locator>, #rest sub-path)
|
||||
=> (subdirectory :: <directory-locator>);
|
||||
|
||||
define method subdirectory-locator
|
||||
(locator :: <directory-locator>, #rest sub-path)
|
||||
=> (subdirectory :: <directory-locator>)
|
||||
let old-path = locator.locator-path;
|
||||
let new-path = concatenate-as(<simple-object-vector>, old-path, sub-path);
|
||||
make(object-class(locator),
|
||||
server: locator.locator-server,
|
||||
path: new-path,
|
||||
relative?: locator.locator-relative?)
|
||||
end method subdirectory-locator;
|
||||
|
||||
/// Relative locator
|
||||
|
||||
define open generic relative-locator
|
||||
(locator :: <physical-locator>, from-locator :: <physical-locator>)
|
||||
=> (relative-locator :: <physical-locator>);
|
||||
|
||||
define method relative-locator
|
||||
(locator :: <directory-locator>, from-locator :: <directory-locator>)
|
||||
=> (relative-locator :: <directory-locator>)
|
||||
let path = locator.locator-path;
|
||||
let from-path = from-locator.locator-path;
|
||||
case
|
||||
~locator.locator-relative? & from-locator.locator-relative? =>
|
||||
locator-error
|
||||
("Cannot find relative path of absolute locator %= from relative locator %=",
|
||||
locator, from-locator);
|
||||
locator.locator-server ~= from-locator.locator-server =>
|
||||
locator;
|
||||
path = from-path =>
|
||||
make(object-class(locator),
|
||||
path: vector(#"self"),
|
||||
relative?: #t);
|
||||
otherwise =>
|
||||
make(object-class(locator),
|
||||
path: relative-path(path, from-path, test: locator.locator-test),
|
||||
relative?: #t);
|
||||
end
|
||||
end method relative-locator;
|
||||
|
||||
define method relative-locator
|
||||
(locator :: <file-locator>, from-directory :: <directory-locator>)
|
||||
=> (relative-locator :: <file-locator>)
|
||||
let directory = locator.locator-directory;
|
||||
let relative-directory = directory & relative-locator(directory, from-directory);
|
||||
if (relative-directory ~= directory)
|
||||
simplify-locator
|
||||
(make(object-class(locator),
|
||||
directory: relative-directory,
|
||||
base: locator.locator-base,
|
||||
extension: locator.locator-extension))
|
||||
else
|
||||
locator
|
||||
end
|
||||
end method relative-locator;
|
||||
|
||||
define method relative-locator
|
||||
(locator :: <physical-locator>, from-locator :: <file-locator>)
|
||||
=> (relative-locator :: <physical-locator>)
|
||||
let from-directory = from-locator.locator-directory;
|
||||
case
|
||||
from-directory =>
|
||||
relative-locator(locator, from-directory);
|
||||
~locator.locator-relative? =>
|
||||
locator-error
|
||||
("Cannot find relative path of absolute locator %= from relative locator %=",
|
||||
locator, from-locator);
|
||||
otherwise =>
|
||||
locator;
|
||||
end
|
||||
end method relative-locator;
|
||||
|
||||
/// Merge locators
|
||||
|
||||
define open generic merge-locators
|
||||
(locator :: <physical-locator>, from-locator :: <physical-locator>)
|
||||
=> (merged-locator :: <physical-locator>);
|
||||
|
||||
/// Merge locators
|
||||
|
||||
define method merge-locators
|
||||
(locator :: <directory-locator>, from-locator :: <directory-locator>)
|
||||
=> (merged-locator :: <directory-locator>)
|
||||
if (locator.locator-relative?)
|
||||
let path = concatenate(from-locator.locator-path, locator.locator-path);
|
||||
simplify-locator
|
||||
(make(object-class(locator),
|
||||
server: from-locator.locator-server,
|
||||
path: path,
|
||||
relative?: from-locator.locator-relative?))
|
||||
else
|
||||
locator
|
||||
end
|
||||
end method merge-locators;
|
||||
|
||||
define method merge-locators
|
||||
(locator :: <file-locator>, from-locator :: <directory-locator>)
|
||||
=> (merged-locator :: <file-locator>)
|
||||
let directory = locator.locator-directory;
|
||||
let merged-directory
|
||||
= if (directory)
|
||||
merge-locators(directory, from-locator)
|
||||
else
|
||||
simplify-locator(from-locator)
|
||||
end;
|
||||
if (merged-directory ~= directory)
|
||||
make(object-class(locator),
|
||||
directory: merged-directory,
|
||||
base: locator.locator-base,
|
||||
extension: locator.locator-extension)
|
||||
else
|
||||
locator
|
||||
end
|
||||
end method merge-locators;
|
||||
|
||||
define method merge-locators
|
||||
(locator :: <physical-locator>, from-locator :: <file-locator>)
|
||||
=> (merged-locator :: <physical-locator>)
|
||||
let from-directory = from-locator.locator-directory;
|
||||
if (from-directory)
|
||||
merge-locators(locator, from-directory)
|
||||
else
|
||||
locator
|
||||
end
|
||||
end method merge-locators;
|
||||
|
||||
/// Locator protocols
|
||||
|
||||
define sideways method supports-open-locator?
|
||||
(locator :: <file-locator>) => (openable? :: <boolean>)
|
||||
~locator.locator-relative?
|
||||
end method supports-open-locator?;
|
||||
|
||||
define sideways method open-locator
|
||||
(locator :: <file-locator>, #rest keywords, #key, #all-keys)
|
||||
=> (stream :: <stream>)
|
||||
apply(open-file-stream, locator, keywords)
|
||||
end method open-locator;
|
||||
</textarea></div>
|
||||
|
||||
<script>
|
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
|
||||
mode: "text/x-dylan",
|
||||
lineNumbers: true,
|
||||
matchBrackets: true,
|
||||
continueComments: "Enter",
|
||||
extraKeys: {"Ctrl-Q": "toggleComment"},
|
||||
tabMode: "indent",
|
||||
indentUnit: 2
|
||||
});
|
||||
</script>
|
||||
|
||||
<p><strong>MIME types defined:</strong> <code>text/x-dylan</code>.</p>
|
||||
</article>
|
||||
Reference in New Issue
Block a user