diff options
author | Richard Mahn <richmahn@users.noreply.github.com> | 2016-07-22 23:29:20 -0600 |
---|---|---|
committer | 无闻 <u@gogs.io> | 2016-07-23 13:29:20 +0800 |
commit | 69dae1ec1c5265e815c8b0fedff3399438e2e380 (patch) | |
tree | d3d675c58db46baf72f2402e2f38d2de1cb2cb5e /public/plugins/codemirror-5.17.0/mode/dylan | |
parent | cf85e9eb7b125156fc3289f6a1306e16b748929b (diff) |
Added coding style modes to SimpleMDE (#3286)
* Added coding style modes to SimpleMDE
* Moved the CodeMirror addon from simplemd to codemirror directory
Diffstat (limited to 'public/plugins/codemirror-5.17.0/mode/dylan')
-rw-r--r-- | public/plugins/codemirror-5.17.0/mode/dylan/dylan.js | 344 | ||||
-rw-r--r-- | public/plugins/codemirror-5.17.0/mode/dylan/index.html | 407 | ||||
-rw-r--r-- | public/plugins/codemirror-5.17.0/mode/dylan/test.js | 88 |
3 files changed, 839 insertions, 0 deletions
diff --git a/public/plugins/codemirror-5.17.0/mode/dylan/dylan.js b/public/plugins/codemirror-5.17.0/mode/dylan/dylan.js new file mode 100644 index 00000000..1b46bc82 --- /dev/null +++ b/public/plugins/codemirror-5.17.0/mode/dylan/dylan.js @@ -0,0 +1,344 @@ +// 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); + } + + function tokenBase(stream, state) { + // String + var ch = stream.peek(); + if (ch == "'" || ch == '"') { + stream.next(); + return chain(stream, state, tokenString(ch, "string")); + } + // Comment + else if (ch == "/") { + stream.next(); + if (stream.eat("*")) { + return chain(stream, state, tokenComment); + } else if (stream.eat("/")) { + stream.skipToEnd(); + return "comment"; + } + stream.backUp(1); + } + // Decimal + else if (/[+\-\d\.]/.test(ch)) { + if (stream.match(/^[+-]?[0-9]*\.[0-9]*([esdx][+-]?[0-9]+)?/i) || + stream.match(/^[+-]?[0-9]+([esdx][+-]?[0-9]+)/i) || + stream.match(/^[+-]?\d+/)) { + return "number"; + } + } + // Hash + else if (ch == "#") { + stream.next(); + // Symbol with string syntax + ch = stream.peek(); + if (ch == '"') { + stream.next(); + return chain(stream, state, tokenString('"', "string")); + } + // Binary number + else if (ch == "b") { + stream.next(); + stream.eatWhile(/[01]/); + return "number"; + } + // Hex number + else if (ch == "x") { + stream.next(); + stream.eatWhile(/[\da-f]/i); + return "number"; + } + // Octal number + else if (ch == "o") { + stream.next(); + stream.eatWhile(/[0-7]/); + return "number"; + } + // Token concatenation in macros + else if (ch == '#') { + stream.next(); + return "punctuation"; + } + // Sequence literals + else if ((ch == '[') || (ch == '(')) { + stream.next(); + return "bracket"; + // Hash symbol + } else if (stream.match(/f|t|all-keys|include|key|next|rest/i)) { + return "atom"; + } else { + stream.eatWhile(/[-a-zA-Z]/); + return "error"; + } + } else if (ch == "~") { + stream.next(); + ch = stream.peek(); + if (ch == "=") { + stream.next(); + ch = stream.peek(); + if (ch == "=") { + stream.next(); + return "operator"; + } + return "operator"; + } + return "operator"; + } else if (ch == ":") { + stream.next(); + ch = stream.peek(); + if (ch == "=") { + stream.next(); + return "operator"; + } else if (ch == ":") { + stream.next(); + return "punctuation"; + } + } else if ("[](){}".indexOf(ch) != -1) { + stream.next(); + return "bracket"; + } else if (".,".indexOf(ch) != -1) { + stream.next(); + return "punctuation"; + } else if (stream.match("end")) { + return "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 patternStyles[name]; + } + } + if (/[+\-*\/^=<>&|]/.test(ch)) { + stream.next(); + return "operator"; + } + if (stream.match("define")) { + return "def"; + } else { + stream.eatWhile(/[\w\-]/); + // Keyword + if (wordLookup[stream.current()]) { + return styleLookup[stream.current()]; + } else if (stream.current().match(symbol)) { + return "variable"; + } else { + stream.next(); + return "variable-2"; + } + } + } + + function tokenComment(stream, state) { + var maybeEnd = false, maybeNested = false, nestedCount = 0, ch; + while ((ch = stream.next())) { + if (ch == "/" && maybeEnd) { + if (nestedCount > 0) { + nestedCount--; + } else { + state.tokenize = tokenBase; + break; + } + } else if (ch == "*" && maybeNested) { + nestedCount++; + } + maybeEnd = (ch == "*"); + maybeNested = (ch == "/"); + } + return "comment"; + } + + function tokenString(quote, style) { + return function(stream, state) { + var escaped = false, next, end = false; + while ((next = stream.next()) != null) { + if (next == quote && !escaped) { + end = true; + break; + } + escaped = !escaped && next == "\\"; + } + if (end || !escaped) { + state.tokenize = tokenBase; + } + return 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"); + +}); diff --git a/public/plugins/codemirror-5.17.0/mode/dylan/index.html b/public/plugins/codemirror-5.17.0/mode/dylan/index.html new file mode 100644 index 00000000..ddf5ad06 --- /dev/null +++ b/public/plugins/codemirror-5.17.0/mode/dylan/index.html @@ -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> diff --git a/public/plugins/codemirror-5.17.0/mode/dylan/test.js b/public/plugins/codemirror-5.17.0/mode/dylan/test.js new file mode 100644 index 00000000..bf25be27 --- /dev/null +++ b/public/plugins/codemirror-5.17.0/mode/dylan/test.js @@ -0,0 +1,88 @@ +// CodeMirror, copyright (c) by Marijn Haverbeke and others +// Distributed under an MIT license: http://codemirror.net/LICENSE + +(function() { + var mode = CodeMirror.getMode({indentUnit: 2}, "dylan"); + function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); } + + MT('comments', + '[comment // This is a line comment]', + '[comment /* This is a block comment */]', + '[comment /* This is a multi]', + '[comment line comment]', + '[comment */]', + '[comment /* And this is a /*]', + '[comment /* nested */ comment */]'); + + MT('unary_operators', + '[operator -][variable a]', + '[operator -] [variable a]', + '[operator ~][variable a]', + '[operator ~] [variable a]'); + + MT('binary_operators', + '[variable a] [operator +] [variable b]', + '[variable a] [operator -] [variable b]', + '[variable a] [operator *] [variable b]', + '[variable a] [operator /] [variable b]', + '[variable a] [operator ^] [variable b]', + '[variable a] [operator =] [variable b]', + '[variable a] [operator ==] [variable b]', + '[variable a] [operator ~=] [variable b]', + '[variable a] [operator ~==] [variable b]', + '[variable a] [operator <] [variable b]', + '[variable a] [operator <=] [variable b]', + '[variable a] [operator >] [variable b]', + '[variable a] [operator >=] [variable b]', + '[variable a] [operator &] [variable b]', + '[variable a] [operator |] [variable b]', + '[variable a] [operator :=] [variable b]'); + + MT('integers', + '[number 1]', + '[number 123]', + '[number -123]', + '[number +456]', + '[number #b010]', + '[number #o073]', + '[number #xabcDEF123]'); + + MT('floats', + '[number .3]', + '[number -1.]', + '[number -2.335]', + '[number +3.78d1]', + '[number 3.78s-1]', + '[number -3.32e+5]'); + + MT('characters_and_strings', + "[string 'a']", + "[string '\\\\'']", + '[string ""]', + '[string "a"]', + '[string "abc def"]', + '[string "More escaped characters: \\\\\\\\ \\\\a \\\\b \\\\e \\\\f \\\\n \\\\r \\\\t \\\\0 ..."]'); + + MT('brackets', + '[bracket #[[]]]', + '[bracket #()]', + '[bracket #(][number 1][bracket )]', + '[bracket [[][number 1][punctuation ,] [number 3][bracket ]]]', + '[bracket ()]', + '[bracket {}]', + '[keyword if] [bracket (][variable foo][bracket )]', + '[bracket (][number 1][bracket )]', + '[bracket [[][number 1][bracket ]]]'); + + MT('hash_words', + '[punctuation ##]', + '[atom #f]', '[atom #F]', + '[atom #t]', '[atom #T]', + '[atom #all-keys]', + '[atom #include]', + '[atom #key]', + '[atom #next]', + '[atom #rest]', + '[string #"foo"]', + '[error #invalid]'); +})(); |