<!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 © 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>