File modules/editor/codemirror/mode/dylan/index.html

Last commit: Sun Dec 17 01:14:09 2017 +0100	Jan Dankert	Integration eines weiteren Code-Editors: Codemirror. Demnächst müssen wir hier mal aufräumen und andere Editoren rauswerfen.


     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 type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
    14 <div id=nav>
    15   <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></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/codemirror">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>



Download modules/editor/codemirror/mode/dylan/index.html


History
Sun, 17 Dec 2017 01:14:09 +0100	Jan Dankert	Integration eines weiteren Code-Editors: Codemirror. Demnächst müssen wir hier mal aufräumen und andere Editoren rauswerfen.