PageRenderTime 70ms CodeModel.GetById 30ms RepoModel.GetById 1ms app.codeStats 0ms

/pygments/pygments/lexers/functional.py

https://bitbucket.org/tcorll/butlertest
Python | 2597 lines | 2017 code | 217 blank | 363 comment | 25 complexity | dc4ba95035313373ea5462615f2136d3 MD5 | raw file
Possible License(s): Apache-2.0, GPL-2.0, LGPL-3.0, BSD-2-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. # -*- coding: utf-8 -*-
    2. 

  2. """
    3. 

  3.     pygments.lexers.functional
    4. 

  4.     ~~~~~~~~~~~~~~~~~~~~~~~~~~
    5. 

  5. 

  6.     Lexers for functional languages.
    7. 

  7. 

  8.     :copyright: Copyright 2006-2012 by the Pygments team, see AUTHORS.
    9. 

  9.     :license: BSD, see LICENSE for details.
    10. 

  10. """
    11. 

    12. 

  12. import re
    13. 

  13. 

  14. from pygments.lexer import Lexer, RegexLexer, bygroups, include, do_insertions
    15. 

  15. from pygments.token import Text, Comment, Operator, Keyword, Name, \
    16. 

  16.      String, Number, Punctuation, Literal, Generic, Error
    17. 

  17. 

  18. __all__ = ['RacketLexer', 'SchemeLexer', 'CommonLispLexer', 'HaskellLexer',
    19. 

  19.            'LiterateHaskellLexer', 'SMLLexer', 'OcamlLexer', 'ErlangLexer',
    20. 

  20.            'ErlangShellLexer', 'OpaLexer', 'CoqLexer', 'NewLispLexer',
    21. 

  21.            'ElixirLexer', 'ElixirConsoleLexer', 'KokaLexer']
    22. 

  22. 

  23. 

  24. class RacketLexer(RegexLexer):
    25. 

  25.     """
    26. 

  26.     Lexer for `Racket <http://racket-lang.org/>`_ source code (formerly known as
    27. 

  27.     PLT Scheme).
    28. 

  28. 

  29.     *New in Pygments 1.6.*
    30. 

  30.     """
    31. 

    32. 

  32.     name = 'Racket'
    33. 

  33.     aliases = ['racket', 'rkt']
    34. 

  34.     filenames = ['*.rkt', '*.rktl']
    35. 

  35.     mimetypes = ['text/x-racket', 'application/x-racket']
    36. 

  36. 

  37.     # From namespace-mapped-symbols
    38. 

  38.     keywords = [
    39. 

  39.         '#%app', '#%datum', '#%expression', '#%module-begin',
    40. 

  40.         '#%plain-app', '#%plain-lambda', '#%plain-module-begin',
    41. 

  41.         '#%provide', '#%require', '#%stratified-body', '#%top',
    42. 

  42.         '#%top-interaction', '#%variable-reference', '...', 'and', 'begin',
    43. 

  43.         'begin-for-syntax', 'begin0', 'case', 'case-lambda', 'cond',
    44. 

  44.         'datum->syntax-object', 'define', 'define-for-syntax',
    45. 

  45.         'define-struct', 'define-syntax', 'define-syntax-rule',
    46. 

  46.         'define-syntaxes', 'define-values', 'define-values-for-syntax',
    47. 

  47.         'delay', 'do', 'expand-path', 'fluid-let', 'hash-table-copy',
    48. 

  48.         'hash-table-count', 'hash-table-for-each', 'hash-table-get',
    49. 

  49.         'hash-table-iterate-first', 'hash-table-iterate-key',
    50. 

  50.         'hash-table-iterate-next', 'hash-table-iterate-value',
    51. 

  51.         'hash-table-map', 'hash-table-put!', 'hash-table-remove!',
    52. 

  52.         'hash-table?', 'if', 'lambda', 'let', 'let*', 'let*-values',
    53. 

  53.         'let-struct', 'let-syntax', 'let-syntaxes', 'let-values', 'let/cc',
    54. 

  54.         'let/ec', 'letrec', 'letrec-syntax', 'letrec-syntaxes',
    55. 

  55.         'letrec-syntaxes+values', 'letrec-values', 'list-immutable',
    56. 

  56.         'make-hash-table', 'make-immutable-hash-table', 'make-namespace',
    57. 

  57.         'module', 'module-identifier=?', 'module-label-identifier=?',
    58. 

  58.         'module-template-identifier=?', 'module-transformer-identifier=?',
    59. 

  59.         'namespace-transformer-require', 'or', 'parameterize',
    60. 

  60.         'parameterize*', 'parameterize-break', 'provide',
    61. 

  61.         'provide-for-label', 'provide-for-syntax', 'quasiquote',
    62. 

  62.         'quasisyntax', 'quasisyntax/loc', 'quote', 'quote-syntax',
    63. 

  63.         'quote-syntax/prune', 'require', 'require-for-label',
    64. 

  64.         'require-for-syntax', 'require-for-template', 'set!',
    65. 

  65.         'set!-values', 'syntax', 'syntax-case', 'syntax-case*',
    66. 

  66.         'syntax-id-rules', 'syntax-object->datum', 'syntax-rules',
    67. 

  67.         'syntax/loc', 'time', 'transcript-off', 'transcript-on', 'unless',
    68. 

  68.         'unquote', 'unquote-splicing', 'unsyntax', 'unsyntax-splicing',
    69. 

  69.         'when', 'with-continuation-mark', 'with-handlers',
    70. 

  70.         'with-handlers*', 'with-syntax', 'λ'
    71. 

  71.     ]
    72. 

  72. 

  73.     # From namespace-mapped-symbols
    74. 

  74.     builtins = [
    75. 

  75.         '*', '+', '-', '/', '<', '<=', '=', '>', '>=',
    76. 

  76.         'abort-current-continuation', 'abs', 'absolute-path?', 'acos',
    77. 

  77.         'add1', 'alarm-evt', 'always-evt', 'andmap', 'angle', 'append',
    78. 

  78.         'apply', 'arithmetic-shift', 'arity-at-least',
    79. 

  79.         'arity-at-least-value', 'arity-at-least?', 'asin', 'assoc', 'assq',
    80. 

  80.         'assv', 'atan', 'banner', 'bitwise-and', 'bitwise-bit-field',
    81. 

  81.         'bitwise-bit-set?', 'bitwise-ior', 'bitwise-not', 'bitwise-xor',
    82. 

  82.         'boolean?', 'bound-identifier=?', 'box', 'box-immutable', 'box?',
    83. 

  83.         'break-enabled', 'break-thread', 'build-path',
    84. 

  84.         'build-path/convention-type', 'byte-pregexp', 'byte-pregexp?',
    85. 

  85.         'byte-ready?', 'byte-regexp', 'byte-regexp?', 'byte?', 'bytes',
    86. 

  86.         'bytes->immutable-bytes', 'bytes->list', 'bytes->path',
    87. 

  87.         'bytes->path-element', 'bytes->string/latin-1',
    88. 

  88.         'bytes->string/locale', 'bytes->string/utf-8', 'bytes-append',
    89. 

  89.         'bytes-close-converter', 'bytes-convert', 'bytes-convert-end',
    90. 

  90.         'bytes-converter?', 'bytes-copy', 'bytes-copy!', 'bytes-fill!',
    91. 

  91.         'bytes-length', 'bytes-open-converter', 'bytes-ref', 'bytes-set!',
    92. 

  92.         'bytes-utf-8-index', 'bytes-utf-8-length', 'bytes-utf-8-ref',
    93. 

  93.         'bytes<?', 'bytes=?', 'bytes>?', 'bytes?', 'caaaar', 'caaadr',
    94. 

  94.         'caaar', 'caadar', 'caaddr', 'caadr', 'caar', 'cadaar', 'cadadr',
    95. 

  95.         'cadar', 'caddar', 'cadddr', 'caddr', 'cadr',
    96. 

  96.         'call-in-nested-thread', 'call-with-break-parameterization',
    97. 

  97.         'call-with-composable-continuation',
    98. 

  98.         'call-with-continuation-barrier', 'call-with-continuation-prompt',
    99. 

  99.         'call-with-current-continuation', 'call-with-escape-continuation',
    100. 

  100.         'call-with-exception-handler',
    101. 

  101.         'call-with-immediate-continuation-mark', 'call-with-input-file',
    102. 

  102.         'call-with-output-file', 'call-with-parameterization',
    103. 

  103.         'call-with-semaphore', 'call-with-semaphore/enable-break',
    104. 

  104.         'call-with-values', 'call/cc', 'call/ec', 'car', 'cdaaar',
    105. 

  105.         'cdaadr', 'cdaar', 'cdadar', 'cdaddr', 'cdadr', 'cdar', 'cddaar',
    106. 

  106.         'cddadr', 'cddar', 'cdddar', 'cddddr', 'cdddr', 'cddr', 'cdr',
    107. 

  107.         'ceiling', 'channel-get', 'channel-put', 'channel-put-evt',
    108. 

  108.         'channel-try-get', 'channel?', 'chaperone-box', 'chaperone-evt',
    109. 

  109.         'chaperone-hash', 'chaperone-of?', 'chaperone-procedure',
    110. 

  110.         'chaperone-struct', 'chaperone-struct-type', 'chaperone-vector',
    111. 

  111.         'chaperone?', 'char->integer', 'char-alphabetic?', 'char-blank?',
    112. 

  112.         'char-ci<=?', 'char-ci<?', 'char-ci=?', 'char-ci>=?', 'char-ci>?',
    113. 

  113.         'char-downcase', 'char-foldcase', 'char-general-category',
    114. 

  114.         'char-graphic?', 'char-iso-control?', 'char-lower-case?',
    115. 

  115.         'char-numeric?', 'char-punctuation?', 'char-ready?',
    116. 

  116.         'char-symbolic?', 'char-title-case?', 'char-titlecase',
    117. 

  117.         'char-upcase', 'char-upper-case?', 'char-utf-8-length',
    118. 

  118.         'char-whitespace?', 'char<=?', 'char<?', 'char=?', 'char>=?',
    119. 

  119.         'char>?', 'char?', 'check-duplicate-identifier',
    120. 

  120.         'checked-procedure-check-and-extract', 'choice-evt',
    121. 

  121.         'cleanse-path', 'close-input-port', 'close-output-port',
    122. 

  122.         'collect-garbage', 'collection-file-path', 'collection-path',
    123. 

  123.         'compile', 'compile-allow-set!-undefined',
    124. 

  124.         'compile-context-preservation-enabled',
    125. 

  125.         'compile-enforce-module-constants', 'compile-syntax',
    126. 

  126.         'compiled-expression?', 'compiled-module-expression?',
    127. 

  127.         'complete-path?', 'complex?', 'cons',
    128. 

  128.         'continuation-mark-set->context', 'continuation-mark-set->list',
    129. 

  129.         'continuation-mark-set->list*', 'continuation-mark-set-first',
    130. 

  130.         'continuation-mark-set?', 'continuation-marks',
    131. 

  131.         'continuation-prompt-available?', 'continuation-prompt-tag?',
    132. 

  132.         'continuation?', 'copy-file', 'cos',
    133. 

  133.         'current-break-parameterization', 'current-code-inspector',
    134. 

  134.         'current-command-line-arguments', 'current-compile',
    135. 

  135.         'current-continuation-marks', 'current-custodian',
    136. 

  136.         'current-directory', 'current-drive', 'current-error-port',
    137. 

  137.         'current-eval', 'current-evt-pseudo-random-generator',
    138. 

  138.         'current-gc-milliseconds', 'current-get-interaction-input-port',
    139. 

  139.         'current-inexact-milliseconds', 'current-input-port',
    140. 

  140.         'current-inspector', 'current-library-collection-paths',
    141. 

  141.         'current-load', 'current-load-extension',
    142. 

  142.         'current-load-relative-directory', 'current-load/use-compiled',
    143. 

  143.         'current-locale', 'current-memory-use', 'current-milliseconds',
    144. 

  144.         'current-module-declare-name', 'current-module-declare-source',
    145. 

  145.         'current-module-name-resolver', 'current-namespace',
    146. 

  146.         'current-output-port', 'current-parameterization',
    147. 

  147.         'current-preserved-thread-cell-values', 'current-print',
    148. 

  148.         'current-process-milliseconds', 'current-prompt-read',
    149. 

  149.         'current-pseudo-random-generator', 'current-read-interaction',
    150. 

  150.         'current-reader-guard', 'current-readtable', 'current-seconds',
    151. 

  151.         'current-security-guard', 'current-subprocess-custodian-mode',
    152. 

  152.         'current-thread', 'current-thread-group',
    153. 

  153.         'current-thread-initial-stack-size',
    154. 

  154.         'current-write-relative-directory', 'custodian-box-value',
    155. 

  155.         'custodian-box?', 'custodian-limit-memory',
    156. 

  156.         'custodian-managed-list', 'custodian-memory-accounting-available?',
    157. 

  157.         'custodian-require-memory', 'custodian-shutdown-all', 'custodian?',
    158. 

  158.         'custom-print-quotable-accessor', 'custom-print-quotable?',
    159. 

  159.         'custom-write-accessor', 'custom-write?', 'date', 'date*',
    160. 

  160.         'date*-nanosecond', 'date*-time-zone-name', 'date*?', 'date-day',
    161. 

  161.         'date-dst?', 'date-hour', 'date-minute', 'date-month',
    162. 

  162.         'date-second', 'date-time-zone-offset', 'date-week-day',
    163. 

  163.         'date-year', 'date-year-day', 'date?', 'datum-intern-literal',
    164. 

  164.         'default-continuation-prompt-tag', 'delete-directory',
    165. 

  165.         'delete-file', 'denominator', 'directory-exists?',
    166. 

  166.         'directory-list', 'display', 'displayln', 'dump-memory-stats',
    167. 

  167.         'dynamic-require', 'dynamic-require-for-syntax', 'dynamic-wind',
    168. 

  168.         'eof', 'eof-object?', 'ephemeron-value', 'ephemeron?', 'eprintf',
    169. 

  169.         'eq-hash-code', 'eq?', 'equal-hash-code',
    170. 

  170.         'equal-secondary-hash-code', 'equal?', 'equal?/recur',
    171. 

  171.         'eqv-hash-code', 'eqv?', 'error', 'error-display-handler',
    172. 

  172.         'error-escape-handler', 'error-print-context-length',
    173. 

  173.         'error-print-source-location', 'error-print-width',
    174. 

  174.         'error-value->string-handler', 'eval', 'eval-jit-enabled',
    175. 

  175.         'eval-syntax', 'even?', 'evt?', 'exact->inexact', 'exact-integer?',
    176. 

  176.         'exact-nonnegative-integer?', 'exact-positive-integer?', 'exact?',
    177. 

  177.         'executable-yield-handler', 'exit', 'exit-handler', 'exn',
    178. 

  178.         'exn-continuation-marks', 'exn-message', 'exn:break',
    179. 

  179.         'exn:break-continuation', 'exn:break?', 'exn:fail',
    180. 

  180.         'exn:fail:contract', 'exn:fail:contract:arity',
    181. 

  181.         'exn:fail:contract:arity?', 'exn:fail:contract:continuation',
    182. 

  182.         'exn:fail:contract:continuation?',
    183. 

  183.         'exn:fail:contract:divide-by-zero',
    184. 

  184.         'exn:fail:contract:divide-by-zero?',
    185. 

  185.         'exn:fail:contract:non-fixnum-result',
    186. 

  186.         'exn:fail:contract:non-fixnum-result?',
    187. 

  187.         'exn:fail:contract:variable', 'exn:fail:contract:variable-id',
    188. 

  188.         'exn:fail:contract:variable?', 'exn:fail:contract?',
    189. 

  189.         'exn:fail:filesystem', 'exn:fail:filesystem:exists',
    190. 

  190.         'exn:fail:filesystem:exists?', 'exn:fail:filesystem:version',
    191. 

  191.         'exn:fail:filesystem:version?', 'exn:fail:filesystem?',
    192. 

  192.         'exn:fail:network', 'exn:fail:network?', 'exn:fail:out-of-memory',
    193. 

  193.         'exn:fail:out-of-memory?', 'exn:fail:read',
    194. 

  194.         'exn:fail:read-srclocs', 'exn:fail:read:eof', 'exn:fail:read:eof?',
    195. 

  195.         'exn:fail:read:non-char', 'exn:fail:read:non-char?',
    196. 

  196.         'exn:fail:read?', 'exn:fail:syntax', 'exn:fail:syntax-exprs',
    197. 

  197.         'exn:fail:syntax:unbound', 'exn:fail:syntax:unbound?',
    198. 

  198.         'exn:fail:syntax?', 'exn:fail:unsupported',
    199. 

  199.         'exn:fail:unsupported?', 'exn:fail:user', 'exn:fail:user?',
    200. 

  200.         'exn:fail?', 'exn:srclocs-accessor', 'exn:srclocs?', 'exn?', 'exp',
    201. 

  201.         'expand', 'expand-once', 'expand-syntax', 'expand-syntax-once',
    202. 

  202.         'expand-syntax-to-top-form', 'expand-to-top-form',
    203. 

  203.         'expand-user-path', 'expt', 'file-exists?',
    204. 

  204.         'file-or-directory-identity', 'file-or-directory-modify-seconds',
    205. 

  205.         'file-or-directory-permissions', 'file-position', 'file-size',
    206. 

  206.         'file-stream-buffer-mode', 'file-stream-port?',
    207. 

  207.         'filesystem-root-list', 'find-executable-path',
    208. 

  208.         'find-library-collection-paths', 'find-system-path', 'fixnum?',
    209. 

  209.         'floating-point-bytes->real', 'flonum?', 'floor', 'flush-output',
    210. 

  210.         'for-each', 'force', 'format', 'fprintf', 'free-identifier=?',
    211. 

  211.         'gcd', 'generate-temporaries', 'gensym', 'get-output-bytes',
    212. 

  212.         'get-output-string', 'getenv', 'global-port-print-handler',
    213. 

  213.         'guard-evt', 'handle-evt', 'handle-evt?', 'hash', 'hash-equal?',
    214. 

  214.         'hash-eqv?', 'hash-has-key?', 'hash-placeholder?', 'hash-ref!',
    215. 

  215.         'hasheq', 'hasheqv', 'identifier-binding',
    216. 

  216.         'identifier-label-binding', 'identifier-prune-lexical-context',
    217. 

  217.         'identifier-prune-to-source-module',
    218. 

  218.         'identifier-remove-from-definition-context',
    219. 

  219.         'identifier-template-binding', 'identifier-transformer-binding',
    220. 

  220.         'identifier?', 'imag-part', 'immutable?', 'impersonate-box',
    221. 

  221.         'impersonate-hash', 'impersonate-procedure', 'impersonate-struct',
    222. 

  222.         'impersonate-vector', 'impersonator-of?',
    223. 

  223.         'impersonator-prop:application-mark',
    224. 

  224.         'impersonator-property-accessor-procedure?',
    225. 

  225.         'impersonator-property?', 'impersonator?', 'inexact->exact',
    226. 

  226.         'inexact-real?', 'inexact?', 'input-port?', 'inspector?',
    227. 

  227.         'integer->char', 'integer->integer-bytes',
    228. 

  228.         'integer-bytes->integer', 'integer-length', 'integer-sqrt',
    229. 

  229.         'integer-sqrt/remainder', 'integer?',
    230. 

  230.         'internal-definition-context-seal', 'internal-definition-context?',
    231. 

  231.         'keyword->string', 'keyword<?', 'keyword?', 'kill-thread', 'lcm',
    232. 

  232.         'length', 'liberal-define-context?', 'link-exists?', 'list',
    233. 

  233.         'list*', 'list->bytes', 'list->string', 'list->vector', 'list-ref',
    234. 

  234.         'list-tail', 'list?', 'load', 'load-extension',
    235. 

  235.         'load-on-demand-enabled', 'load-relative',
    236. 

  236.         'load-relative-extension', 'load/cd', 'load/use-compiled',
    237. 

  237.         'local-expand', 'local-expand/capture-lifts',
    238. 

  238.         'local-transformer-expand',
    239. 

  239.         'local-transformer-expand/capture-lifts', 'locale-string-encoding',
    240. 

  240.         'log', 'magnitude', 'make-arity-at-least', 'make-bytes',
    241. 

  241.         'make-channel', 'make-continuation-prompt-tag', 'make-custodian',
    242. 

  242.         'make-custodian-box', 'make-date', 'make-date*',
    243. 

  243.         'make-derived-parameter', 'make-directory', 'make-ephemeron',
    244. 

  244.         'make-exn', 'make-exn:break', 'make-exn:fail',
    245. 

  245.         'make-exn:fail:contract', 'make-exn:fail:contract:arity',
    246. 

  246.         'make-exn:fail:contract:continuation',
    247. 

  247.         'make-exn:fail:contract:divide-by-zero',
    248. 

  248.         'make-exn:fail:contract:non-fixnum-result',
    249. 

  249.         'make-exn:fail:contract:variable', 'make-exn:fail:filesystem',
    250. 

  250.         'make-exn:fail:filesystem:exists',
    251. 

  251.         'make-exn:fail:filesystem:version', 'make-exn:fail:network',
    252. 

  252.         'make-exn:fail:out-of-memory', 'make-exn:fail:read',
    253. 

  253.         'make-exn:fail:read:eof', 'make-exn:fail:read:non-char',
    254. 

  254.         'make-exn:fail:syntax', 'make-exn:fail:syntax:unbound',
    255. 

  255.         'make-exn:fail:unsupported', 'make-exn:fail:user',
    256. 

  256.         'make-file-or-directory-link', 'make-hash-placeholder',
    257. 

  257.         'make-hasheq-placeholder', 'make-hasheqv',
    258. 

  258.         'make-hasheqv-placeholder', 'make-immutable-hasheqv',
    259. 

  259.         'make-impersonator-property', 'make-input-port', 'make-inspector',
    260. 

  260.         'make-known-char-range-list', 'make-output-port', 'make-parameter',
    261. 

  261.         'make-pipe', 'make-placeholder', 'make-polar',
    262. 

  262.         'make-prefab-struct', 'make-pseudo-random-generator',
    263. 

  263.         'make-reader-graph', 'make-readtable', 'make-rectangular',
    264. 

  264.         'make-rename-transformer', 'make-resolved-module-path',
    265. 

  265.         'make-security-guard', 'make-semaphore', 'make-set!-transformer',
    266. 

  266.         'make-shared-bytes', 'make-sibling-inspector',
    267. 

  267.         'make-special-comment', 'make-srcloc', 'make-string',
    268. 

  268.         'make-struct-field-accessor', 'make-struct-field-mutator',
    269. 

  269.         'make-struct-type', 'make-struct-type-property',
    270. 

  270.         'make-syntax-delta-introducer', 'make-syntax-introducer',
    271. 

  271.         'make-thread-cell', 'make-thread-group', 'make-vector',
    272. 

  272.         'make-weak-box', 'make-weak-hasheqv', 'make-will-executor', 'map',
    273. 

  273.         'max', 'mcar', 'mcdr', 'mcons', 'member', 'memq', 'memv', 'min',
    274. 

  274.         'module->exports', 'module->imports', 'module->language-info',
    275. 

  275.         'module->namespace', 'module-compiled-exports',
    276. 

  276.         'module-compiled-imports', 'module-compiled-language-info',
    277. 

  277.         'module-compiled-name', 'module-path-index-join',
    278. 

  278.         'module-path-index-resolve', 'module-path-index-split',
    279. 

  279.         'module-path-index?', 'module-path?', 'module-predefined?',
    280. 

  280.         'module-provide-protected?', 'modulo', 'mpair?', 'nack-guard-evt',
    281. 

  281.         'namespace-attach-module', 'namespace-attach-module-declaration',
    282. 

  282.         'namespace-base-phase', 'namespace-mapped-symbols',
    283. 

  283.         'namespace-module-identifier', 'namespace-module-registry',
    284. 

  284.         'namespace-require', 'namespace-require/constant',
    285. 

  285.         'namespace-require/copy', 'namespace-require/expansion-time',
    286. 

  286.         'namespace-set-variable-value!', 'namespace-symbol->identifier',
    287. 

  287.         'namespace-syntax-introduce', 'namespace-undefine-variable!',
    288. 

  288.         'namespace-unprotect-module', 'namespace-variable-value',
    289. 

  289.         'namespace?', 'negative?', 'never-evt', 'newline',
    290. 

  290.         'normal-case-path', 'not', 'null', 'null?', 'number->string',
    291. 

  291.         'number?', 'numerator', 'object-name', 'odd?', 'open-input-bytes',
    292. 

  292.         'open-input-file', 'open-input-output-file', 'open-input-string',
    293. 

  293.         'open-output-bytes', 'open-output-file', 'open-output-string',
    294. 

  294.         'ormap', 'output-port?', 'pair?', 'parameter-procedure=?',
    295. 

  295.         'parameter?', 'parameterization?', 'path->bytes',
    296. 

  296.         'path->complete-path', 'path->directory-path', 'path->string',
    297. 

  297.         'path-add-suffix', 'path-convention-type', 'path-element->bytes',
    298. 

  298.         'path-element->string', 'path-for-some-system?',
    299. 

  299.         'path-list-string->path-list', 'path-replace-suffix',
    300. 

  300.         'path-string?', 'path?', 'peek-byte', 'peek-byte-or-special',
    301. 

  301.         'peek-bytes', 'peek-bytes!', 'peek-bytes-avail!',
    302. 

  302.         'peek-bytes-avail!*', 'peek-bytes-avail!/enable-break',
    303. 

  303.         'peek-char', 'peek-char-or-special', 'peek-string', 'peek-string!',
    304. 

  304.         'pipe-content-length', 'placeholder-get', 'placeholder-set!',
    305. 

  305.         'placeholder?', 'poll-guard-evt', 'port-closed-evt',
    306. 

  306.         'port-closed?', 'port-commit-peeked', 'port-count-lines!',
    307. 

  307.         'port-count-lines-enabled', 'port-display-handler',
    308. 

  308.         'port-file-identity', 'port-file-unlock', 'port-next-location',
    309. 

  309.         'port-print-handler', 'port-progress-evt',
    310. 

  310.         'port-provides-progress-evts?', 'port-read-handler',
    311. 

  311.         'port-try-file-lock?', 'port-write-handler', 'port-writes-atomic?',
    312. 

  312.         'port-writes-special?', 'port?', 'positive?',
    313. 

  313.         'prefab-key->struct-type', 'prefab-struct-key', 'pregexp',
    314. 

  314.         'pregexp?', 'primitive-closure?', 'primitive-result-arity',
    315. 

  315.         'primitive?', 'print', 'print-as-expression',
    316. 

  316.         'print-boolean-long-form', 'print-box', 'print-graph',
    317. 

  317.         'print-hash-table', 'print-mpair-curly-braces',
    318. 

  318.         'print-pair-curly-braces', 'print-reader-abbreviations',
    319. 

  319.         'print-struct', 'print-syntax-width', 'print-unreadable',
    320. 

  320.         'print-vector-length', 'printf', 'procedure->method',
    321. 

  321.         'procedure-arity', 'procedure-arity-includes?', 'procedure-arity?',
    322. 

  322.         'procedure-closure-contents-eq?', 'procedure-extract-target',
    323. 

  323.         'procedure-reduce-arity', 'procedure-rename',
    324. 

  324.         'procedure-struct-type?', 'procedure?', 'promise?',
    325. 

  325.         'prop:arity-string', 'prop:checked-procedure',
    326. 

  326.         'prop:custom-print-quotable', 'prop:custom-write',
    327. 

  327.         'prop:equal+hash', 'prop:evt', 'prop:exn:srclocs',
    328. 

  328.         'prop:impersonator-of', 'prop:input-port',
    329. 

  329.         'prop:liberal-define-context', 'prop:output-port',
    330. 

  330.         'prop:procedure', 'prop:rename-transformer',
    331. 

  331.         'prop:set!-transformer', 'pseudo-random-generator->vector',
    332. 

  332.         'pseudo-random-generator-vector?', 'pseudo-random-generator?',
    333. 

  333.         'putenv', 'quotient', 'quotient/remainder', 'raise',
    334. 

  334.         'raise-arity-error', 'raise-mismatch-error', 'raise-syntax-error',
    335. 

  335.         'raise-type-error', 'raise-user-error', 'random', 'random-seed',
    336. 

  336.         'rational?', 'rationalize', 'read', 'read-accept-bar-quote',
    337. 

  337.         'read-accept-box', 'read-accept-compiled', 'read-accept-dot',
    338. 

  338.         'read-accept-graph', 'read-accept-infix-dot', 'read-accept-lang',
    339. 

  339.         'read-accept-quasiquote', 'read-accept-reader', 'read-byte',
    340. 

  340.         'read-byte-or-special', 'read-bytes', 'read-bytes!',
    341. 

  341.         'read-bytes-avail!', 'read-bytes-avail!*',
    342. 

  342.         'read-bytes-avail!/enable-break', 'read-bytes-line',
    343. 

  343.         'read-case-sensitive', 'read-char', 'read-char-or-special',
    344. 

  344.         'read-curly-brace-as-paren', 'read-decimal-as-inexact',
    345. 

  345.         'read-eval-print-loop', 'read-language', 'read-line',
    346. 

  346.         'read-on-demand-source', 'read-square-bracket-as-paren',
    347. 

  347.         'read-string', 'read-string!', 'read-syntax',
    348. 

  348.         'read-syntax/recursive', 'read/recursive', 'readtable-mapping',
    349. 

  349.         'readtable?', 'real->double-flonum', 'real->floating-point-bytes',
    350. 

  350.         'real->single-flonum', 'real-part', 'real?', 'regexp',
    351. 

  351.         'regexp-match', 'regexp-match-peek', 'regexp-match-peek-immediate',
    352. 

  352.         'regexp-match-peek-positions',
    353. 

  353.         'regexp-match-peek-positions-immediate',
    354. 

  354.         'regexp-match-peek-positions-immediate/end',
    355. 

  355.         'regexp-match-peek-positions/end', 'regexp-match-positions',
    356. 

  356.         'regexp-match-positions/end', 'regexp-match/end', 'regexp-match?',
    357. 

  357.         'regexp-max-lookbehind', 'regexp-replace', 'regexp-replace*',
    358. 

  358.         'regexp?', 'relative-path?', 'remainder',
    359. 

  359.         'rename-file-or-directory', 'rename-transformer-target',
    360. 

  360.         'rename-transformer?', 'resolve-path', 'resolved-module-path-name',
    361. 

  361.         'resolved-module-path?', 'reverse', 'round', 'seconds->date',
    362. 

  362.         'security-guard?', 'semaphore-peek-evt', 'semaphore-post',
    363. 

  363.         'semaphore-try-wait?', 'semaphore-wait',
    364. 

  364.         'semaphore-wait/enable-break', 'semaphore?',
    365. 

  365.         'set!-transformer-procedure', 'set!-transformer?', 'set-box!',
    366. 

  366.         'set-mcar!', 'set-mcdr!', 'set-port-next-location!',
    367. 

  367.         'shared-bytes', 'shell-execute', 'simplify-path', 'sin',
    368. 

  368.         'single-flonum?', 'sleep', 'special-comment-value',
    369. 

  369.         'special-comment?', 'split-path', 'sqrt', 'srcloc',
    370. 

  370.         'srcloc-column', 'srcloc-line', 'srcloc-position', 'srcloc-source',
    371. 

  371.         'srcloc-span', 'srcloc?', 'string', 'string->bytes/latin-1',
    372. 

  372.         'string->bytes/locale', 'string->bytes/utf-8',
    373. 

  373.         'string->immutable-string', 'string->keyword', 'string->list',
    374. 

  374.         'string->number', 'string->path', 'string->path-element',
    375. 

  375.         'string->symbol', 'string->uninterned-symbol',
    376. 

  376.         'string->unreadable-symbol', 'string-append', 'string-ci<=?',
    377. 

  377.         'string-ci<?', 'string-ci=?', 'string-ci>=?', 'string-ci>?',
    378. 

  378.         'string-copy', 'string-copy!', 'string-downcase', 'string-fill!',
    379. 

  379.         'string-foldcase', 'string-length', 'string-locale-ci<?',
    380. 

  380.         'string-locale-ci=?', 'string-locale-ci>?',
    381. 

  381.         'string-locale-downcase', 'string-locale-upcase',
    382. 

  382.         'string-locale<?', 'string-locale=?', 'string-locale>?',
    383. 

  383.         'string-normalize-nfc', 'string-normalize-nfd',
    384. 

  384.         'string-normalize-nfkc', 'string-normalize-nfkd', 'string-ref',
    385. 

  385.         'string-set!', 'string-titlecase', 'string-upcase',
    386. 

  386.         'string-utf-8-length', 'string<=?', 'string<?', 'string=?',
    387. 

  387.         'string>=?', 'string>?', 'string?', 'struct->vector',
    388. 

  388.         'struct-accessor-procedure?', 'struct-constructor-procedure?',
    389. 

  389.         'struct-info', 'struct-mutator-procedure?',
    390. 

  390.         'struct-predicate-procedure?', 'struct-type-info',
    391. 

  391.         'struct-type-make-constructor', 'struct-type-make-predicate',
    392. 

  392.         'struct-type-property-accessor-procedure?',
    393. 

  393.         'struct-type-property?', 'struct-type?', 'struct:arity-at-least',
    394. 

  394.         'struct:date', 'struct:date*', 'struct:exn', 'struct:exn:break',
    395. 

  395.         'struct:exn:fail', 'struct:exn:fail:contract',
    396. 

  396.         'struct:exn:fail:contract:arity',
    397. 

  397.         'struct:exn:fail:contract:continuation',
    398. 

  398.         'struct:exn:fail:contract:divide-by-zero',
    399. 

  399.         'struct:exn:fail:contract:non-fixnum-result',
    400. 

  400.         'struct:exn:fail:contract:variable', 'struct:exn:fail:filesystem',
    401. 

  401.         'struct:exn:fail:filesystem:exists',
    402. 

  402.         'struct:exn:fail:filesystem:version', 'struct:exn:fail:network',
    403. 

  403.         'struct:exn:fail:out-of-memory', 'struct:exn:fail:read',
    404. 

  404.         'struct:exn:fail:read:eof', 'struct:exn:fail:read:non-char',
    405. 

  405.         'struct:exn:fail:syntax', 'struct:exn:fail:syntax:unbound',
    406. 

  406.         'struct:exn:fail:unsupported', 'struct:exn:fail:user',
    407. 

  407.         'struct:srcloc', 'struct?', 'sub1', 'subbytes', 'subprocess',
    408. 

  408.         'subprocess-group-enabled', 'subprocess-kill', 'subprocess-pid',
    409. 

  409.         'subprocess-status', 'subprocess-wait', 'subprocess?', 'substring',
    410. 

  410.         'symbol->string', 'symbol-interned?', 'symbol-unreadable?',
    411. 

  411.         'symbol?', 'sync', 'sync/enable-break', 'sync/timeout',
    412. 

  412.         'sync/timeout/enable-break', 'syntax->list', 'syntax-arm',
    413. 

  413.         'syntax-column', 'syntax-disarm', 'syntax-e', 'syntax-line',
    414. 

  414.         'syntax-local-bind-syntaxes', 'syntax-local-certifier',
    415. 

  415.         'syntax-local-context', 'syntax-local-expand-expression',
    416. 

  416.         'syntax-local-get-shadower', 'syntax-local-introduce',
    417. 

  417.         'syntax-local-lift-context', 'syntax-local-lift-expression',
    418. 

  418.         'syntax-local-lift-module-end-declaration',
    419. 

  419.         'syntax-local-lift-provide', 'syntax-local-lift-require',
    420. 

  420.         'syntax-local-lift-values-expression',
    421. 

  421.         'syntax-local-make-definition-context',
    422. 

  422.         'syntax-local-make-delta-introducer',
    423. 

  423.         'syntax-local-module-defined-identifiers',
    424. 

  424.         'syntax-local-module-exports',
    425. 

  425.         'syntax-local-module-required-identifiers', 'syntax-local-name',
    426. 

  426.         'syntax-local-phase-level',
    427. 

  427.         'syntax-local-transforming-module-provides?', 'syntax-local-value',
    428. 

  428.         'syntax-local-value/immediate', 'syntax-original?',
    429. 

  429.         'syntax-position', 'syntax-property',
    430. 

  430.         'syntax-property-symbol-keys', 'syntax-protect', 'syntax-rearm',
    431. 

  431.         'syntax-recertify', 'syntax-shift-phase-level', 'syntax-source',
    432. 

  432.         'syntax-source-module', 'syntax-span', 'syntax-taint',
    433. 

  433.         'syntax-tainted?', 'syntax-track-origin',
    434. 

  434.         'syntax-transforming-module-expression?', 'syntax-transforming?',
    435. 

  435.         'syntax?', 'system-big-endian?', 'system-idle-evt',
    436. 

  436.         'system-language+country', 'system-library-subpath',
    437. 

  437.         'system-path-convention-type', 'system-type', 'tan',
    438. 

  438.         'tcp-abandon-port', 'tcp-accept', 'tcp-accept-evt',
    439. 

  439.         'tcp-accept-ready?', 'tcp-accept/enable-break', 'tcp-addresses',
    440. 

  440.         'tcp-close', 'tcp-connect', 'tcp-connect/enable-break',
    441. 

  441.         'tcp-listen', 'tcp-listener?', 'tcp-port?', 'terminal-port?',
    442. 

  442.         'thread', 'thread-cell-ref', 'thread-cell-set!', 'thread-cell?',
    443. 

  443.         'thread-dead-evt', 'thread-dead?', 'thread-group?',
    444. 

  444.         'thread-resume', 'thread-resume-evt', 'thread-rewind-receive',
    445. 

  445.         'thread-running?', 'thread-suspend', 'thread-suspend-evt',
    446. 

  446.         'thread-wait', 'thread/suspend-to-kill', 'thread?', 'time-apply',
    447. 

  447.         'truncate', 'udp-addresses', 'udp-bind!', 'udp-bound?',
    448. 

  448.         'udp-close', 'udp-connect!', 'udp-connected?', 'udp-open-socket',
    449. 

  449.         'udp-receive!', 'udp-receive!*', 'udp-receive!-evt',
    450. 

  450.         'udp-receive!/enable-break', 'udp-receive-ready-evt', 'udp-send',
    451. 

  451.         'udp-send*', 'udp-send-evt', 'udp-send-ready-evt', 'udp-send-to',
    452. 

  452.         'udp-send-to*', 'udp-send-to-evt', 'udp-send-to/enable-break',
    453. 

  453.         'udp-send/enable-break', 'udp?', 'unbox',
    454. 

  454.         'uncaught-exception-handler', 'use-collection-link-paths',
    455. 

  455.         'use-compiled-file-paths', 'use-user-specific-search-paths',
    456. 

  456.         'values', 'variable-reference->empty-namespace',
    457. 

  457.         'variable-reference->module-base-phase',
    458. 

  458.         'variable-reference->module-declaration-inspector',
    459. 

  459.         'variable-reference->module-source',
    460. 

  460.         'variable-reference->namespace', 'variable-reference->phase',
    461. 

  461.         'variable-reference->resolved-module-path',
    462. 

  462.         'variable-reference-constant?', 'variable-reference?', 'vector',
    463. 

  463.         'vector->immutable-vector', 'vector->list',
    464. 

  464.         'vector->pseudo-random-generator',
    465. 

  465.         'vector->pseudo-random-generator!', 'vector->values',
    466. 

  466.         'vector-fill!', 'vector-immutable', 'vector-length', 'vector-ref',
    467. 

  467.         'vector-set!', 'vector-set-performance-stats!', 'vector?',
    468. 

  468.         'version', 'void', 'void?', 'weak-box-value', 'weak-box?',
    469. 

  469.         'will-execute', 'will-executor?', 'will-register',
    470. 

  470.         'will-try-execute', 'with-input-from-file', 'with-output-to-file',
    471. 

  471.         'wrap-evt', 'write', 'write-byte', 'write-bytes',
    472. 

  472.         'write-bytes-avail', 'write-bytes-avail*', 'write-bytes-avail-evt',
    473. 

  473.         'write-bytes-avail/enable-break', 'write-char', 'write-special',
    474. 

  474.         'write-special-avail*', 'write-special-evt', 'write-string', 'zero?'
    475. 

  475.     ]
    476. 

  476. 

  477.     # From SchemeLexer
    478. 

  478.     valid_name = r'[a-zA-Z0-9!$%&*+,/:<=>?@^_~|-]+'
    479. 

  479. 

  480.     tokens = {
    481. 

  481.         'root' : [
    482. 

  482.             (r';.*$', Comment.Single),
    483. 

  483.             (r'#\|[^|]+\|#', Comment.Multiline),
    484. 

  484. 

  485.             # whitespaces - usually not relevant
    486. 

  486.             (r'\s+', Text),
    487. 

  487. 

  488.             ## numbers: Keep in mind Racket reader hash prefixes,
    489. 

  489.             ## which can denote the base or the type. These don't map
    490. 

  490.             ## neatly onto pygments token types; some judgment calls
    491. 

  491.             ## here.  Note that none of these regexps attempt to
    492. 

  492.             ## exclude identifiers that start with a number, such as a
    493. 

  493.             ## variable named "100-Continue".
    494. 

  494. 

  495.             # #b
    496. 

  496.             (r'#b[-+]?[01]+\.[01]+', Number.Float),
    497. 

  497.             (r'#b[01]+e[-+]?[01]+', Number.Float),
    498. 

  498.             (r'#b[-+]?[01]/[01]+', Number),
    499. 

  499.             (r'#b[-+]?[01]+', Number.Integer),
    500. 

  500.             (r'#b\S*', Error),
    501. 

  501. 

  502.             # #d OR no hash prefix
    503. 

  503.             (r'(#d)?[-+]?\d+\.\d+', Number.Float),
    504. 

  504.             (r'(#d)?\d+e[-+]?\d+', Number.Float),
    505. 

  505.             (r'(#d)?[-+]?\d+/\d+', Number),
    506. 

  506.             (r'(#d)?[-+]?\d+', Number.Integer),
    507. 

  507.             (r'#d\S*', Error),
    508. 

  508. 

  509.             # #e
    510. 

  510.             (r'#e[-+]?\d+\.\d+', Number.Float),
    511. 

  511.             (r'#e\d+e[-+]?\d+', Number.Float),
    512. 

  512.             (r'#e[-+]?\d+/\d+', Number),
    513. 

  513.             (r'#e[-+]?\d+', Number),
    514. 

  514.             (r'#e\S*', Error),
    515. 

  515. 

  516.             # #i is always inexact-real, i.e. float
    517. 

  517.             (r'#i[-+]?\d+\.\d+', Number.Float),
    518. 

  518.             (r'#i\d+e[-+]?\d+', Number.Float),
    519. 

  519.             (r'#i[-+]?\d+/\d+', Number.Float),
    520. 

  520.             (r'#i[-+]?\d+', Number.Float),
    521. 

  521.             (r'#i\S*', Error),
    522. 

  522. 

  523.             # #o
    524. 

  524.             (r'#o[-+]?[0-7]+\.[0-7]+', Number.Oct),
    525. 

  525.             (r'#o[0-7]+e[-+]?[0-7]+', Number.Oct),
    526. 

  526.             (r'#o[-+]?[0-7]+/[0-7]+', Number.Oct),
    527. 

  527.             (r'#o[-+]?[0-7]+', Number.Oct),
    528. 

  528.             (r'#o\S*', Error),
    529. 

  529. 

  530.             # #x
    531. 

  531.             (r'#x[-+]?[0-9a-fA-F]+\.[0-9a-fA-F]+', Number.Hex),
    532. 

  532.             # the exponent variation (e.g. #x1e1) is N/A
    533. 

  533.             (r'#x[-+]?[0-9a-fA-F]+/[0-9a-fA-F]+', Number.Hex),
    534. 

  534.             (r'#x[-+]?[0-9a-fA-F]+', Number.Hex),
    535. 

  535.             (r'#x\S*', Error),
    536. 

  536. 

  537. 

  538.             # strings, symbols and characters
    539. 

  539.             (r'"(\\\\|\\"|[^"])*"', String),
    540. 

  540.             (r"'" + valid_name, String.Symbol),
    541. 

  541.             (r"#\\([()/'\"._!§$%& ?=+-]{1}|[a-zA-Z0-9]+)", String.Char),
    542. 

  542.             (r'#rx".+"', String.Regex),
    543. 

  543.             (r'#px".+"', String.Regex),
    544. 

  544. 

  545.             # constants
    546. 

  546.             (r'(#t|#f)', Name.Constant),
    547. 

  547. 

  548.             # keyword argument names (e.g. #:keyword)
    549. 

  549.             (r'#:\S+', Keyword.Declaration),
    550. 

  550. 

  551.             # #lang
    552. 

  552.             (r'#lang \S+', Keyword.Namespace),
    553. 

  553. 

  554.             # special operators
    555. 

  555.             (r"('|#|`|,@|,|\.)", Operator),
    556. 

  556. 

  557.             # highlight the keywords
    558. 

  558.             ('(%s)' % '|'.join([
    559. 

  559.                 re.escape(entry) + ' ' for entry in keywords]),
    560. 

  560.                 Keyword
    561. 

  561.             ),
    562. 

  562. 

  563.             # first variable in a quoted string like
    564. 

  564.             # '(this is syntactic sugar)
    565. 

  565.             (r"(?<='\()" + valid_name, Name.Variable),
    566. 

  566.             (r"(?<=#\()" + valid_name, Name.Variable),
    567. 

  567. 

  568.             # highlight the builtins
    569. 

  569.             ("(?<=\()(%s)" % '|'.join([
    570. 

  570.                 re.escape(entry) + ' ' for entry in builtins]),
    571. 

  571.                 Name.Builtin
    572. 

  572.             ),
    573. 

  573. 

  574.             # the remaining functions; handle both ( and [
    575. 

  575.             (r'(?<=(\(|\[|\{))' + valid_name, Name.Function),
    576. 

  576. 

  577.             # find the remaining variables
    578. 

  578.             (valid_name, Name.Variable),
    579. 

  579. 

  580.             # the famous parentheses!
    581. 

  581.             (r'(\(|\)|\[|\]|\{|\})', Punctuation),
    582. 

  582.         ],
    583. 

  583.     }
    584. 

  584. 

  585. 

  586. class SchemeLexer(RegexLexer):
    587. 

  587.     """
    588. 

  588.     A Scheme lexer, parsing a stream and outputting the tokens
    589. 

  589.     needed to highlight scheme code.
    590. 

  590.     This lexer could be most probably easily subclassed to parse
    591. 

  591.     other LISP-Dialects like Common Lisp, Emacs Lisp or AutoLisp.
    592. 

  592. 

  593.     This parser is checked with pastes from the LISP pastebin
    594. 

  594.     at http://paste.lisp.org/ to cover as much syntax as possible.
    595. 

  595. 

  596.     It supports the full Scheme syntax as defined in R5RS.
    597. 

  597. 

  598.     *New in Pygments 0.6.*
    599. 

  599.     """
    600. 

  600.     name = 'Scheme'
    601. 

  601.     aliases = ['scheme', 'scm']
    602. 

  602.     filenames = ['*.scm', '*.ss']
    603. 

  603.     mimetypes = ['text/x-scheme', 'application/x-scheme']
    604. 

  604. 

  605.     # list of known keywords and builtins taken form vim 6.4 scheme.vim
    606. 

  606.     # syntax file.
    607. 

  607.     keywords = [
    608. 

  608.         'lambda', 'define', 'if', 'else', 'cond', 'and', 'or', 'case', 'let',
    609. 

  609.         'let*', 'letrec', 'begin', 'do', 'delay', 'set!', '=>', 'quote',
    610. 

  610.         'quasiquote', 'unquote', 'unquote-splicing', 'define-syntax',
    611. 

  611.         'let-syntax', 'letrec-syntax', 'syntax-rules'
    612. 

  612.     ]
    613. 

  613.     builtins = [
    614. 

  614.         '*', '+', '-', '/', '<', '<=', '=', '>', '>=', 'abs', 'acos', 'angle',
    615. 

  615.         'append', 'apply', 'asin', 'assoc', 'assq', 'assv', 'atan',
    616. 

  616.         'boolean?', 'caaaar', 'caaadr', 'caaar', 'caadar', 'caaddr', 'caadr',
    617. 

  617.         'caar', 'cadaar', 'cadadr', 'cadar', 'caddar', 'cadddr', 'caddr',
    618. 

  618.         'cadr', 'call-with-current-continuation', 'call-with-input-file',
    619. 

  619.         'call-with-output-file', 'call-with-values', 'call/cc', 'car',
    620. 

  620.         'cdaaar', 'cdaadr', 'cdaar', 'cdadar', 'cdaddr', 'cdadr', 'cdar',
    621. 

  621.         'cddaar', 'cddadr', 'cddar', 'cdddar', 'cddddr', 'cdddr', 'cddr',
    622. 

  622.         'cdr', 'ceiling', 'char->integer', 'char-alphabetic?', 'char-ci<=?',
    623. 

  623.         'char-ci<?', 'char-ci=?', 'char-ci>=?', 'char-ci>?', 'char-downcase',
    624. 

  624.         'char-lower-case?', 'char-numeric?', 'char-ready?', 'char-upcase',
    625. 

  625.         'char-upper-case?', 'char-whitespace?', 'char<=?', 'char<?', 'char=?',
    626. 

  626.         'char>=?', 'char>?', 'char?', 'close-input-port', 'close-output-port',
    627. 

  627.         'complex?', 'cons', 'cos', 'current-input-port', 'current-output-port',
    628. 

  628.         'denominator', 'display', 'dynamic-wind', 'eof-object?', 'eq?',
    629. 

  629.         'equal?', 'eqv?', 'eval', 'even?', 'exact->inexact', 'exact?', 'exp',
    630. 

  630.         'expt', 'floor', 'for-each', 'force', 'gcd', 'imag-part',
    631. 

  631.         'inexact->exact', 'inexact?', 'input-port?', 'integer->char',
    632. 

  632.         'integer?', 'interaction-environment', 'lcm', 'length', 'list',
    633. 

  633.         'list->string', 'list->vector', 'list-ref', 'list-tail', 'list?',
    634. 

  634.         'load', 'log', 'magnitude', 'make-polar', 'make-rectangular',
    635. 

  635.         'make-string', 'make-vector', 'map', 'max', 'member', 'memq', 'memv',
    636. 

  636.         'min', 'modulo', 'negative?', 'newline', 'not', 'null-environment',
    637. 

  637.         'null?', 'number->string', 'number?', 'numerator', 'odd?',
    638. 

  638.         'open-input-file', 'open-output-file', 'output-port?', 'pair?',
    639. 

  639.         'peek-char', 'port?', 'positive?', 'procedure?', 'quotient',
    640. 

  640.         'rational?', 'rationalize', 'read', 'read-char', 'real-part', 'real?',
    641. 

  641.         'remainder', 'reverse', 'round', 'scheme-report-environment',
    642. 

  642.         'set-car!', 'set-cdr!', 'sin', 'sqrt', 'string', 'string->list',
    643. 

  643.         'string->number', 'string->symbol', 'string-append', 'string-ci<=?',
    644. 

  644.         'string-ci<?', 'string-ci=?', 'string-ci>=?', 'string-ci>?',
    645. 

  645.         'string-copy', 'string-fill!', 'string-length', 'string-ref',
    646. 

  646.         'string-set!', 'string<=?', 'string<?', 'string=?', 'string>=?',
    647. 

  647.         'string>?', 'string?', 'substring', 'symbol->string', 'symbol?',
    648. 

  648.         'tan', 'transcript-off', 'transcript-on', 'truncate', 'values',
    649. 

  649.         'vector', 'vector->list', 'vector-fill!', 'vector-length',
    650. 

  650.         'vector-ref', 'vector-set!', 'vector?', 'with-input-from-file',
    651. 

  651.         'with-output-to-file', 'write', 'write-char', 'zero?'
    652. 

  652.     ]
    653. 

  653. 

  654.     # valid names for identifiers
    655. 

  655.     # well, names can only not consist fully of numbers
    656. 

  656.     # but this should be good enough for now
    657. 

  657.     valid_name = r'[a-zA-Z0-9!$%&*+,/:<=>?@^_~|-]+'
    658. 

  658. 

  659.     tokens = {
    660. 

  660.         'root' : [
    661. 

  661.             # the comments - always starting with semicolon
    662. 

  662.             # and going to the end of the line
    663. 

  663.             (r';.*$', Comment.Single),
    664. 

  664. 

  665.             # whitespaces - usually not relevant
    666. 

  666.             (r'\s+', Text),
    667. 

  667. 

  668.             # numbers
    669. 

  669.             (r'-?\d+\.\d+', Number.Float),
    670. 

  670.             (r'-?\d+', Number.Integer),
    671. 

  671.             # support for uncommon kinds of numbers -
    672. 

  672.             # have to figure out what the characters mean
    673. 

  673.             #(r'(#e|#i|#b|#o|#d|#x)[\d.]+', Number),
    674. 

  674. 

  675.             # strings, symbols and characters
    676. 

  676.             (r'"(\\\\|\\"|[^"])*"', String),
    677. 

  677.             (r"'" + valid_name, String.Symbol),
    678. 

  678.             (r"#\\([()/'\"._!§$%& ?=+-]{1}|[a-zA-Z0-9]+)", String.Char),
    679. 

  679. 

  680.             # constants
    681. 

  681.             (r'(#t|#f)', Name.Constant),
    682. 

  682. 

  683.             # special operators
    684. 

  684.             (r"('|#|`|,@|,|\.)", Operator),
    685. 

  685. 

  686.             # highlight the keywords
    687. 

  687.             ('(%s)' % '|'.join([
    688. 

  688.                 re.escape(entry) + ' ' for entry in keywords]),
    689. 

  689.                 Keyword
    690. 

  690.             ),
    691. 

  691. 

  692.             # first variable in a quoted string like
    693. 

  693.             # '(this is syntactic sugar)
    694. 

  694.             (r"(?<='\()" + valid_name, Name.Variable),
    695. 

  695.             (r"(?<=#\()" + valid_name, Name.Variable),
    696. 

  696. 

  697.             # highlight the builtins
    698. 

  698.             ("(?<=\()(%s)" % '|'.join([
    699. 

  699.                 re.escape(entry) + ' ' for entry in builtins]),
    700. 

  700.                 Name.Builtin
    701. 

  701.             ),
    702. 

  702. 

  703.             # the remaining functions
    704. 

  704.             (r'(?<=\()' + valid_name, Name.Function),
    705. 

  705.             # find the remaining variables
    706. 

  706.             (valid_name, Name.Variable),
    707. 

  707. 

  708.             # the famous parentheses!
    709. 

  709.             (r'(\(|\))', Punctuation),
    710. 

  710.             (r'(\[|\])', Punctuation),
    711. 

  711.         ],
    712. 

  712.     }
    713. 

  713. 

  714. 

  715. class CommonLispLexer(RegexLexer):
    716. 

  716.     """
    717. 

  717.     A Common Lisp lexer.
    718. 

  718. 

  719.     *New in Pygments 0.9.*
    720. 

  720.     """
    721. 

  721.     name = 'Common Lisp'
    722. 

  722.     aliases = ['common-lisp', 'cl']
    723. 

  723.     filenames = ['*.cl', '*.lisp', '*.el']  # use for Elisp too
    724. 

  724.     mimetypes = ['text/x-common-lisp']
    725. 

  725. 

  726.     flags = re.IGNORECASE | re.MULTILINE
    727. 

  727. 

  728.     ### couple of useful regexes
    729. 

  729. 

  730.     # characters that are not macro-characters and can be used to begin a symbol
    731. 

  731.     nonmacro = r'\\.|[a-zA-Z0-9!$%&*+-/<=>?@\[\]^_{}~]'
    732. 

  732.     constituent = nonmacro + '|[#.:]'
    733. 

  733.     terminated = r'(?=[ "()\'\n,;`])' # whitespace or terminating macro characters
    734. 

  734. 

  735.     ### symbol token, reverse-engineered from hyperspec
    736. 

  736.     # Take a deep breath...
    737. 

  737.     symbol = r'(\|[^|]+\||(?:%s)(?:%s)*)' % (nonmacro, constituent)
    738. 

  738. 

  739.     def __init__(self, **options):
    740. 

  740.         from pygments.lexers._clbuiltins import BUILTIN_FUNCTIONS, \
    741. 

  741.             SPECIAL_FORMS, MACROS, LAMBDA_LIST_KEYWORDS, DECLARATIONS, \
    742. 

  742.             BUILTIN_TYPES, BUILTIN_CLASSES
    743. 

  743.         self.builtin_function = BUILTIN_FUNCTIONS
    744. 

  744.         self.special_forms = SPECIAL_FORMS
    745. 

  745.         self.macros = MACROS
    746. 

  746.         self.lambda_list_keywords = LAMBDA_LIST_KEYWORDS
    747. 

  747.         self.declarations = DECLARATIONS
    748. 

  748.         self.builtin_types = BUILTIN_TYPES
    749. 

  749.         self.builtin_classes = BUILTIN_CLASSES
    750. 

  750.         RegexLexer.__init__(self, **options)
    751. 

  751. 

  752.     def get_tokens_unprocessed(self, text):
    753. 

  753.         stack = ['root']
    754. 

  754.         for index, token, value in RegexLexer.get_tokens_unprocessed(self, text, stack):
    755. 

  755.             if token is Name.Variable:
    756. 

  756.                 if value in self.builtin_function:
    757. 

  757.                     yield index, Name.Builtin, value
    758. 

  758.                     continue
    759. 

  759.                 if value in self.special_forms:
    760. 

  760.                     yield index, Keyword, value
    761. 

  761.                     continue
    762. 

  762.                 if value in self.macros:
    763. 

  763.                     yield index, Name.Builtin, value
    764. 

  764.                     continue
    765. 

  765.                 if value in self.lambda_list_keywords:
    766. 

  766.                     yield index, Keyword, value
    767. 

  767.                     continue
    768. 

  768.                 if value in self.declarations:
    769. 

  769.                     yield index, Keyword, value
    770. 

  770.                     continue
    771. 

  771.                 if value in self.builtin_types:
    772. 

  772.                     yield index, Keyword.Type, value
    773. 

  773.                     continue
    774. 

  774.                 if value in self.builtin_classes:
    775. 

  775.                     yield index, Name.Class, value
    776. 

  776.                     continue
    777. 

  777.             yield index, token, value
    778. 

  778. 

  779.     tokens = {
    780. 

  780.         'root' : [
    781. 

  781.             ('', Text, 'body'),
    782. 

  782.         ],
    783. 

  783.         'multiline-comment' : [
    784. 

  784.             (r'#\|', Comment.Multiline, '#push'), # (cf. Hyperspec 2.4.8.19)
    785. 

  785.             (r'\|#', Comment.Multiline, '#pop'),
    786. 

  786.             (r'[^|#]+', Comment.Multiline),
    787. 

  787.             (r'[|#]', Comment.Multiline),
    788. 

  788.         ],
    789. 

  789.         'commented-form' : [
    790. 

  790.             (r'\(', Comment.Preproc, '#push'),
    791. 

  791.             (r'\)', Comment.Preproc, '#pop'),
    792. 

  792.             (r'[^()]+', Comment.Preproc),
    793. 

  793.         ],
    794. 

  794.         'body' : [
    795. 

  795.             # whitespace
    796. 

  796.             (r'\s+', Text),
    797. 

  797. 

  798.             # single-line comment
    799. 

  799.             (r';.*$', Comment.Single),
    800. 

  800. 

  801.             # multi-line comment
    802. 

  802.             (r'#\|', Comment.Multiline, 'multiline-comment'),
    803. 

  803. 

  804.             # encoding comment (?)
    805. 

  805.             (r'#\d*Y.*$', Comment.Special),
    806. 

  806. 

  807.             # strings and characters
    808. 

  808.             (r'"(\\.|\\\n|[^"\\])*"', String),
    809. 

  809.             # quoting
    810. 

  810.             (r":" + symbol, String.Symbol),
    811. 

  811.             (r"'" + symbol, String.Symbol),
    812. 

  812.             (r"'", Operator),
    813. 

  813.             (r"`", Operator),
    814. 

  814. 

  815.             # decimal numbers
    816. 

  816.             (r'[-+]?\d+\.?' + terminated, Number.Integer),
    817. 

  817.             (r'[-+]?\d+/\d+' + terminated, Number),
    818. 

  818.             (r'[-+]?(\d*\.\d+([defls][-+]?\d+)?|\d+(\.\d*)?[defls][-+]?\d+)' \
    819. 

  819.                 + terminated, Number.Float),
    820. 

  820. 

  821.             # sharpsign strings and characters
    822. 

  822.             (r"#\\." + terminated, String.Char),
    823. 

  823.             (r"#\\" + symbol, String.Char),
    824. 

  824. 

  825.             # vector
    826. 

  826.             (r'#\(', Operator, 'body'),
    827. 

  827. 

  828.             # bitstring
    829. 

  829.             (r'#\d*\*[01]*', Literal.Other),
    830. 

  830. 

  831.             # uninterned symbol
    832. 

  832.             (r'#:' + symbol, String.Symbol),
    833. 

  833. 

  834.             # read-time and load-time evaluation
    835. 

  835.             (r'#[.,]', Operator),
    836. 

  836. 

  837.             # function shorthand
    838. 

  838.             (r'#\'', Name.Function),
    839. 

  839. 

  840.             # binary rational
    841. 

  841.             (r'#[bB][+-]?[01]+(/[01]+)?', Number),
    842. 

  842. 

  843.             # octal rational
    844. 

  844.             (r'#[oO][+-]?[0-7]+(/[0-7]+)?', Number.Oct),
    845. 

  845. 

  846.             # hex rational
    847. 

  847.             (r'#[xX][+-]?[0-9a-fA-F]+(/[0-9a-fA-F]+)?', Number.Hex),
    848. 

  848. 

  849.             # radix rational
    850. 

  850.             (r'#\d+[rR][+-]?[0-9a-zA-Z]+(/[0-9a-zA-Z]+)?', Number),
    851. 

  851. 

  852.             # complex
    853. 

  853.             (r'(#[cC])(\()', bygroups(Number, Punctuation), 'body'),
    854. 

  854. 

  855.             # array
    856. 

  856.             (r'(#\d+[aA])(\()', bygroups(Literal.Other, Punctuation), 'body'),
    857. 

  857. 

  858.             # structure
    859. 

  859.             (r'(#[sS])(\()', bygroups(Literal.Other, Punctuation), 'body'),
    860. 

  860. 

  861.             # path
    862. 

  862.             (r'#[pP]?"(\\.|[^"])*"', Literal.Other),
    863. 

  863. 

  864.             # reference
    865. 

  865.             (r'#\d+=', Operator),
    866. 

  866.             (r'#\d+#', Operator),
    867. 

  867. 

  868.             # read-time comment
    869. 

  869.             (r'#+nil' + terminated + '\s*\(', Comment.Preproc, 'commented-form'),
    870. 

  870. 

  871.             # read-time conditional
    872. 

  872.             (r'#[+-]', Operator),
    873. 

  873. 

  874.             # special operators that should have been parsed already
    875. 

  875.             (r'(,@|,|\.)', Operator),
    876. 

  876. 

  877.             # special constants
    878. 

  878.             (r'(t|nil)' + terminated, Name.Constant),
    879. 

  879. 

  880.             # functions and variables
    881. 

  881.             (r'\*' + symbol + '\*', Name.Variable.Global),
    882. 

  882.             (symbol, Name.Variable),
    883. 

  883. 

  884.             # parentheses
    885. 

  885.             (r'\(', Punctuation, 'body'),
    886. 

  886.             (r'\)', Punctuation, '#pop'),
    887. 

  887.         ],
    888. 

  888.     }
    889. 

  889. 

  890. 

  891. class HaskellLexer(RegexLexer):
    892. 

  892.     """
    893. 

  893.     A Haskell lexer based on the lexemes defined in the Haskell 98 Report.
    894. 

  894. 

  895.     *New in Pygments 0.8.*
    896. 

  896.     """
    897. 

  897.     name = 'Haskell'
    898. 

  898.     aliases = ['haskell', 'hs']
    899. 

  899.     filenames = ['*.hs']
    900. 

  900.     mimetypes = ['text/x-haskell']
    901. 

  901. 

  902.     reserved = ['case','class','data','default','deriving','do','else',
    903. 

  903.                 'if','in','infix[lr]?','instance',
    904. 

  904.                 'let','newtype','of','then','type','where','_']
    905. 

  905.     ascii = ['NUL','SOH','[SE]TX','EOT','ENQ','ACK',
    906. 

  906.              'BEL','BS','HT','LF','VT','FF','CR','S[OI]','DLE',
    907. 

  907.              'DC[1-4]','NAK','SYN','ETB','CAN',
    908. 

  908.              'EM','SUB','ESC','[FGRU]S','SP','DEL']
    909. 

  909. 

  910.     tokens = {
    911. 

  911.         'root': [
    912. 

  912.             # Whitespace:
    913. 

  913.             (r'\s+', Text),
    914. 

  914.             #(r'--\s*|.*$', Comment.Doc),
    915. 

  915.             (r'--(?![!#$%&*+./<=>?@\^|_~:\\]).*?$', Comment.Single),
    916. 

  916.             (r'{-', Comment.Multiline, 'comment'),
    917. 

  917.             # Lexemes:
    918. 

  918.             #  Identifiers
    919. 

  919.             (r'\bimport\b', Keyword.Reserved, 'import'),
    920. 

  920.             (r'\bmodule\b', Keyword.Reserved, 'module'),
    921. 

  921.             (r'\berror\b', Name.Exception),
    922. 

  922.             (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
    923. 

  923.             (r'^[_a-z][\w\']*', Name.Function),
    924. 

  924.             (r"'?[_a-z][\w']*", Name),
    925. 

  925.             (r"('')?[A-Z][\w\']*", Keyword.Type),
    926. 

  926.             #  Operators
    927. 

  927.             (r'\\(?![:!#$%&*+.\\/<=>?@^|~-]+)', Name.Function), # lambda operator
    928. 

  928.             (r'(<-|::|->|=>|=)(?![:!#$%&*+.\\/<=>?@^|~-]+)', Operator.Word), # specials
    929. 

  929.             (r':[:!#$%&*+.\\/<=>?@^|~-]*', Keyword.Type), # Constructor operators
    930. 

  930.             (r'[:!#$%&*+.\\/<=>?@^|~-]+', Operator), # Other operators
    931. 

  931.             #  Numbers
    932. 

  932.             (r'\d+[eE][+-]?\d+', Number.Float),
    933. 

  933.             (r'\d+\.\d+([eE][+-]?\d+)?', Number.Float),
    934. 

  934.             (r'0[oO][0-7]+', Number.Oct),
    935. 

  935.             (r'0[xX][\da-fA-F]+', Number.Hex),
    936. 

  936.             (r'\d+', Number.Integer),
    937. 

  937.             #  Character/String Literals
    938. 

  938.             (r"'", String.Char, 'character'),
    939. 

  939.             (r'"', String, 'string'),
    940. 

  940.             #  Special
    941. 

  941.             (r'\[\]', Keyword.Type),
    942. 

  942.             (r'\(\)', Name.Builtin),
    943. 

  943.             (r'[][(),;`{}]', Punctuation),
    944. 

  944.         ],
    945. 

  945.         'import': [
    946. 

  946.             # Import statements
    947. 

  947.             (r'\s+', Text),
    948. 

  948.             (r'"', String, 'string'),
    949. 

  949.             # after "funclist" state
    950. 

  950.             (r'\)', Punctuation, '#pop'),
    951. 

  951.             (r'qualified\b', Keyword),
    952. 

  952.             # import X as Y
    953. 

  953.             (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(as)(\s+)([A-Z][a-zA-Z0-9_.]*)',
    954. 

  954.              bygroups(Name.Namespace, Text, Keyword, Text, Name), '#pop'),
    955. 

  955.             # import X hiding (functions)
    956. 

  956.             (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(hiding)(\s+)(\()',
    957. 

  957.              bygroups(Name.Namespace, Text, Keyword, Text, Punctuation), 'funclist'),
    958. 

  958.             # import X (functions)
    959. 

  959.             (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(\()',
    960. 

  960.              bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
    961. 

  961.             # import X
    962. 

  962.             (r'[a-zA-Z0-9_.]+', Name.Namespace, '#pop'),
    963. 

  963.         ],
    964. 

  964.         'module': [
    965. 

  965.             (r'\s+', Text),
    966. 

  966.             (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(\()',
    967. 

  967.              bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
    968. 

  968.             (r'[A-Z][a-zA-Z0-9_.]*', Name.Namespace, '#pop'),
    969. 

  969.         ],
    970. 

  970.         'funclist': [
    971. 

  971.             (r'\s+', Text),
    972. 

  972.             (r'[A-Z][a-zA-Z0-9_]*', Keyword.Type),
    973. 

  973.             (r'(_[\w\']+|[a-z][\w\']*)', Name.Function),
    974. 

  974.             (r'--.*$', Comment.Single),
    975. 

  975.             (r'{-', Comment.Multiline, 'comment'),
    976. 

  976.             (r',', Punctuation),
    977. 

  977.             (r'[:!#$%&*+.\\/<=>?@^|~-]+', Operator),
    978. 

  978.             # (HACK, but it makes sense to push two instances, believe me)
    979. 

  979.             (r'\(', Punctuation, ('funclist', 'funclist')),
    980. 

  980.             (r'\)', Punctuation, '#pop:2'),
    981. 

  981.         ],
    982. 

  982.         'comment': [
    983. 

  983.             # Multiline Comments
    984. 

  984.             (r'[^-{}]+', Comment.Multiline),
    985. 

  985.             (r'{-', Comment.Multiline, '#push'),
    986. 

  986.             (r'-}', Comment.Multiline, '#pop'),
    987. 

  987.             (r'[-{}]', Comment.Multiline),
    988. 

  988.         ],
    989. 

  989.         'character': [
    990. 

  990.             # Allows multi-chars, incorrectly.
    991. 

  991.             (r"[^\\']", String.Char),
    992. 

  992.             (r"\\", String.Escape, 'escape'),
    993. 

  993.             ("'", String.Char, '#pop'),
    994. 

  994.         ],
    995. 

  995.         'string': [
    996. 

  996.             (r'[^\\"]+', String),
    997. 

  997.             (r"\\", String.Escape, 'escape'),
    998. 

  998.             ('"', String, '#pop'),
    999. 

  999.         ],
    1000. 

  1000.         'escape': [
    1001. 

  1001.             (r'[abfnrtv"\'&\\]', String.Escape, '#pop'),
    1002. 

  1002.             (r'\^[][A-Z@\^_]', String.Escape, '#pop'),
    1003. 

  1003.             ('|'.join(ascii), String.Escape, '#pop'),
    1004. 

  1004.             (r'o[0-7]+', String.Escape, '#pop'),
    1005. 

  1005.             (r'x[\da-fA-F]+', String.Escape, '#pop'),
    1006. 

  1006.             (r'\d+', String.Escape, '#pop'),
    1007. 

  1007.             (r'\s+\\', String.Escape, '#pop'),
    1008. 

  1008.         ],
    1009. 

  1009.     }
    1010. 

  1010. 

  1011. 

  1012. line_re = re.compile('.*?\n')
    1013. 

  1013. bird_re = re.compile(r'(>[ \t]*)(.*\n)')
    1014. 

  1014. 

  1015. class LiterateHaskellLexer(Lexer):
    1016. 

  1016.     """
    1017. 

  1017.     For Literate Haskell (Bird-style or LaTeX) source.
    1018. 

  1018. 

  1019.     Additional options accepted:
    1020. 

  1020. 

  1021.     `litstyle`
    1022. 

  1022.         If given, must be ``"bird"`` or ``"latex"``.  If not given, the style
    1023. 

  1023.         is autodetected: if the first non-whitespace character in the source
    1024. 

  1024.         is a backslash or percent character, LaTeX is assumed, else Bird.
    1025. 

  1025. 

  1026.     *New in Pygments 0.9.*
    1027. 

  1027.     """
    1028. 

  1028.     name = 'Literate Haskell'
    1029. 

  1029.     aliases = ['lhs', 'literate-haskell']
    1030. 

  1030.     filenames = ['*.lhs']
    1031. 

  1031.     mimetypes = ['text/x-literate-haskell']
    1032. 

  1032. 

  1033.     def get_tokens_unprocessed(self, text):
    1034. 

  1034.         hslexer = HaskellLexer(**self.options)
    1035. 

  1035. 

  1036.         style = self.options.get('litstyle')
    1037. 

  1037.         if style is None:
    1038. 

  1038.             style = (text.lstrip()[0:1] in '%\\') and 'latex' or 'bird'
    1039. 

  1039. 

  1040.         code = ''
    1041. 

  1041.         insertions = []
    1042. 

  1042.         if style == 'bird':
    1043. 

  1043.             # bird-style
    1044. 

  1044.             for match in line_re.finditer(text):
    1045. 

  1045.                 line = match.group()
    1046. 

  1046.       …
    1047.

Large files files are truncated, but you can click here to view the full file