github.com/elliott5/community@v0.14.1-0.20160709191136-823126fb026a/app/public/codemirror/mode/dylan/index.html (about)

     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>