Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

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

2""" 

3 pygments.lexers.lisp 

4 ~~~~~~~~~~~~~~~~~~~~ 

5 

6 Lexers for Lispy languages. 

7 

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

9 :license: BSD, see LICENSE for details. 

10""" 

11 

12import re 

13 

14from pygments.lexer import RegexLexer, include, bygroups, words, default 

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

16 Number, Punctuation, Literal, Error 

17 

18from pygments.lexers.python import PythonLexer 

19 

20__all__ = ['SchemeLexer', 'CommonLispLexer', 'HyLexer', 'RacketLexer', 

21 'NewLispLexer', 'EmacsLispLexer', 'ShenLexer', 'CPSALexer', 

22 'XtlangLexer', 'FennelLexer'] 

23 

24 

25class SchemeLexer(RegexLexer): 

26 """ 

27 A Scheme lexer, parsing a stream and outputting the tokens 

28 needed to highlight scheme code. 

29 This lexer could be most probably easily subclassed to parse 

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

31 

32 This parser is checked with pastes from the LISP pastebin 

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

34 

35 It supports the full Scheme syntax as defined in R5RS. 

36 

37 .. versionadded:: 0.6 

38 """ 

39 name = 'Scheme' 

40 aliases = ['scheme', 'scm'] 

41 filenames = ['*.scm', '*.ss'] 

42 mimetypes = ['text/x-scheme', 'application/x-scheme'] 

43 

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

45 # syntax file. 

46 keywords = ( 

47 'lambda', 'define', 'if', 'else', 'cond', 'and', 'or', 'case', 'let', 

48 'let*', 'letrec', 'begin', 'do', 'delay', 'set!', '=>', 'quote', 

49 'quasiquote', 'unquote', 'unquote-splicing', 'define-syntax', 

50 'let-syntax', 'letrec-syntax', 'syntax-rules' 

51 ) 

52 builtins = ( 

53 '*', '+', '-', '/', '<', '<=', '=', '>', '>=', 'abs', 'acos', 'angle', 

54 'append', 'apply', 'asin', 'assoc', 'assq', 'assv', 'atan', 

55 'boolean?', 'caaaar', 'caaadr', 'caaar', 'caadar', 'caaddr', 'caadr', 

56 'caar', 'cadaar', 'cadadr', 'cadar', 'caddar', 'cadddr', 'caddr', 

57 'cadr', 'call-with-current-continuation', 'call-with-input-file', 

58 'call-with-output-file', 'call-with-values', 'call/cc', 'car', 

59 'cdaaar', 'cdaadr', 'cdaar', 'cdadar', 'cdaddr', 'cdadr', 'cdar', 

60 'cddaar', 'cddadr', 'cddar', 'cdddar', 'cddddr', 'cdddr', 'cddr', 

61 'cdr', 'ceiling', 'char->integer', 'char-alphabetic?', 'char-ci<=?', 

62 'char-ci<?', 'char-ci=?', 'char-ci>=?', 'char-ci>?', 'char-downcase', 

63 'char-lower-case?', 'char-numeric?', 'char-ready?', 'char-upcase', 

64 'char-upper-case?', 'char-whitespace?', 'char<=?', 'char<?', 'char=?', 

65 'char>=?', 'char>?', 'char?', 'close-input-port', 'close-output-port', 

66 'complex?', 'cons', 'cos', 'current-input-port', 'current-output-port', 

67 'denominator', 'display', 'dynamic-wind', 'eof-object?', 'eq?', 

68 'equal?', 'eqv?', 'eval', 'even?', 'exact->inexact', 'exact?', 'exp', 

69 'expt', 'floor', 'for-each', 'force', 'gcd', 'imag-part', 

70 'inexact->exact', 'inexact?', 'input-port?', 'integer->char', 

71 'integer?', 'interaction-environment', 'lcm', 'length', 'list', 

72 'list->string', 'list->vector', 'list-ref', 'list-tail', 'list?', 

73 'load', 'log', 'magnitude', 'make-polar', 'make-rectangular', 

74 'make-string', 'make-vector', 'map', 'max', 'member', 'memq', 'memv', 

75 'min', 'modulo', 'negative?', 'newline', 'not', 'null-environment', 

76 'null?', 'number->string', 'number?', 'numerator', 'odd?', 

77 'open-input-file', 'open-output-file', 'output-port?', 'pair?', 

78 'peek-char', 'port?', 'positive?', 'procedure?', 'quotient', 

79 'rational?', 'rationalize', 'read', 'read-char', 'real-part', 'real?', 

80 'remainder', 'reverse', 'round', 'scheme-report-environment', 

81 'set-car!', 'set-cdr!', 'sin', 'sqrt', 'string', 'string->list', 

82 'string->number', 'string->symbol', 'string-append', 'string-ci<=?', 

83 'string-ci<?', 'string-ci=?', 'string-ci>=?', 'string-ci>?', 

84 'string-copy', 'string-fill!', 'string-length', 'string-ref', 

85 'string-set!', 'string<=?', 'string<?', 'string=?', 'string>=?', 

86 'string>?', 'string?', 'substring', 'symbol->string', 'symbol?', 

87 'tan', 'transcript-off', 'transcript-on', 'truncate', 'values', 

88 'vector', 'vector->list', 'vector-fill!', 'vector-length', 

89 'vector-ref', 'vector-set!', 'vector?', 'with-input-from-file', 

90 'with-output-to-file', 'write', 'write-char', 'zero?' 

91 ) 

92 

93 # valid names for identifiers 

94 # well, names can only not consist fully of numbers 

95 # but this should be good enough for now 

96 valid_name = r'[\w!$%&*+,/:<=>?@^~|-]+' 

97 

98 tokens = { 

99 'root': [ 

100 # the comments 

101 # and going to the end of the line 

102 (r';.*$', Comment.Single), 

103 # multi-line comment 

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

105 # commented form (entire sexpr folliwng) 

106 (r'#;\s*\(', Comment, 'commented-form'), 

107 # signifies that the program text that follows is written with the 

108 # lexical and datum syntax described in r6rs 

109 (r'#!r6rs', Comment), 

110 

111 # whitespaces - usually not relevant 

112 (r'\s+', Text), 

113 

114 # numbers 

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

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

117 # support for uncommon kinds of numbers - 

118 # have to figure out what the characters mean 

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

120 

121 # strings, symbols and characters 

122 (r'"(\\\\|\\[^\\]|[^"\\])*"', String), 

123 (r"'" + valid_name, String.Symbol), 

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

125 

126 # constants 

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

128 

129 # special operators 

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

131 

132 # highlight the keywords 

133 ('(%s)' % '|'.join(re.escape(entry) + ' ' for entry in keywords), 

134 Keyword), 

135 

136 # first variable in a quoted string like 

137 # '(this is syntactic sugar) 

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

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

140 

141 # highlight the builtins 

142 (r"(?<=\()(%s)" % '|'.join(re.escape(entry) + ' ' for entry in builtins), 

143 Name.Builtin), 

144 

145 # the remaining functions 

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

147 # find the remaining variables 

148 (valid_name, Name.Variable), 

149 

150 # the famous parentheses! 

151 (r'(\(|\))', Punctuation), 

152 (r'(\[|\])', Punctuation), 

153 ], 

154 'multiline-comment': [ 

155 (r'#\|', Comment.Multiline, '#push'), 

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

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

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

159 ], 

160 'commented-form': [ 

161 (r'\(', Comment, '#push'), 

162 (r'\)', Comment, '#pop'), 

163 (r'[^()]+', Comment), 

164 ], 

165 } 

166 

167 

168class CommonLispLexer(RegexLexer): 

169 """ 

170 A Common Lisp lexer. 

171 

172 .. versionadded:: 0.9 

173 """ 

174 name = 'Common Lisp' 

175 aliases = ['common-lisp', 'cl', 'lisp'] 

176 filenames = ['*.cl', '*.lisp'] 

177 mimetypes = ['text/x-common-lisp'] 

178 

179 flags = re.IGNORECASE | re.MULTILINE 

180 

181 # couple of useful regexes 

182 

183 # characters that are not macro-characters and can be used to begin a symbol 

184 nonmacro = r'\\.|[\w!$%&*+-/<=>?@\[\]^{}~]' 

185 constituent = nonmacro + '|[#.:]' 

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

187 

188 # symbol token, reverse-engineered from hyperspec 

189 # Take a deep breath... 

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

191 

192 def __init__(self, **options): 

193 from pygments.lexers._cl_builtins import BUILTIN_FUNCTIONS, \ 

194 SPECIAL_FORMS, MACROS, LAMBDA_LIST_KEYWORDS, DECLARATIONS, \ 

195 BUILTIN_TYPES, BUILTIN_CLASSES 

196 self.builtin_function = BUILTIN_FUNCTIONS 

197 self.special_forms = SPECIAL_FORMS 

198 self.macros = MACROS 

199 self.lambda_list_keywords = LAMBDA_LIST_KEYWORDS 

200 self.declarations = DECLARATIONS 

201 self.builtin_types = BUILTIN_TYPES 

202 self.builtin_classes = BUILTIN_CLASSES 

203 RegexLexer.__init__(self, **options) 

204 

205 def get_tokens_unprocessed(self, text): 

206 stack = ['root'] 

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

208 if token is Name.Variable: 

209 if value in self.builtin_function: 

210 yield index, Name.Builtin, value 

211 continue 

212 if value in self.special_forms: 

213 yield index, Keyword, value 

214 continue 

215 if value in self.macros: 

216 yield index, Name.Builtin, value 

217 continue 

218 if value in self.lambda_list_keywords: 

219 yield index, Keyword, value 

220 continue 

221 if value in self.declarations: 

222 yield index, Keyword, value 

223 continue 

224 if value in self.builtin_types: 

225 yield index, Keyword.Type, value 

226 continue 

227 if value in self.builtin_classes: 

228 yield index, Name.Class, value 

229 continue 

230 yield index, token, value 

231 

232 tokens = { 

233 'root': [ 

234 default('body'), 

235 ], 

236 'multiline-comment': [ 

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

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

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

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

241 ], 

242 'commented-form': [ 

243 (r'\(', Comment.Preproc, '#push'), 

244 (r'\)', Comment.Preproc, '#pop'), 

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

246 ], 

247 'body': [ 

248 # whitespace 

249 (r'\s+', Text), 

250 

251 # single-line comment 

252 (r';.*$', Comment.Single), 

253 

254 # multi-line comment 

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

256 

257 # encoding comment (?) 

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

259 

260 # strings and characters 

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

262 # quoting 

263 (r":" + symbol, String.Symbol), 

264 (r"::" + symbol, String.Symbol), 

265 (r":#" + symbol, String.Symbol), 

266 (r"'" + symbol, String.Symbol), 

267 (r"'", Operator), 

268 (r"`", Operator), 

269 

270 # decimal numbers 

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

272 (r'[-+]?\d+/\d+' + terminated, Number), 

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

274 terminated, Number.Float), 

275 

276 # sharpsign strings and characters 

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

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

279 

280 # vector 

281 (r'#\(', Operator, 'body'), 

282 

283 # bitstring 

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

285 

286 # uninterned symbol 

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

288 

289 # read-time and load-time evaluation 

290 (r'#[.,]', Operator), 

291 

292 # function shorthand 

293 (r'#\'', Name.Function), 

294 

295 # binary rational 

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

297 

298 # octal rational 

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

300 

301 # hex rational 

302 (r'#x[+-]?[0-9a-f]+(/[0-9a-f]+)?', Number.Hex), 

303 

304 # radix rational 

305 (r'#\d+r[+-]?[0-9a-z]+(/[0-9a-z]+)?', Number), 

306 

307 # complex 

308 (r'(#c)(\()', bygroups(Number, Punctuation), 'body'), 

309 

310 # array 

311 (r'(#\d+a)(\()', bygroups(Literal.Other, Punctuation), 'body'), 

312 

313 # structure 

314 (r'(#s)(\()', bygroups(Literal.Other, Punctuation), 'body'), 

315 

316 # path 

317 (r'#p?"(\\.|[^"])*"', Literal.Other), 

318 

319 # reference 

320 (r'#\d+=', Operator), 

321 (r'#\d+#', Operator), 

322 

323 # read-time comment 

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

325 

326 # read-time conditional 

327 (r'#[+-]', Operator), 

328 

329 # special operators that should have been parsed already 

330 (r'(,@|,|\.)', Operator), 

331 

332 # special constants 

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

334 

335 # functions and variables 

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

337 (symbol, Name.Variable), 

338 

339 # parentheses 

340 (r'\(', Punctuation, 'body'), 

341 (r'\)', Punctuation, '#pop'), 

342 ], 

343 } 

344 

345 

346class HyLexer(RegexLexer): 

347 """ 

348 Lexer for `Hy <http://hylang.org/>`_ source code. 

349 

350 .. versionadded:: 2.0 

351 """ 

352 name = 'Hy' 

353 aliases = ['hylang'] 

354 filenames = ['*.hy'] 

355 mimetypes = ['text/x-hy', 'application/x-hy'] 

356 

357 special_forms = ( 

358 'cond', 'for', '->', '->>', 'car', 

359 'cdr', 'first', 'rest', 'let', 'when', 'unless', 

360 'import', 'do', 'progn', 'get', 'slice', 'assoc', 'with-decorator', 

361 ',', 'list_comp', 'kwapply', '~', 'is', 'in', 'is-not', 'not-in', 

362 'quasiquote', 'unquote', 'unquote-splice', 'quote', '|', '<<=', '>>=', 

363 'foreach', 'while', 

364 'eval-and-compile', 'eval-when-compile' 

365 ) 

366 

367 declarations = ( 

368 'def', 'defn', 'defun', 'defmacro', 'defclass', 'lambda', 'fn', 'setv' 

369 ) 

370 

371 hy_builtins = () 

372 

373 hy_core = ( 

374 'cycle', 'dec', 'distinct', 'drop', 'even?', 'filter', 'inc', 

375 'instance?', 'iterable?', 'iterate', 'iterator?', 'neg?', 

376 'none?', 'nth', 'numeric?', 'odd?', 'pos?', 'remove', 'repeat', 

377 'repeatedly', 'take', 'take_nth', 'take_while', 'zero?' 

378 ) 

379 

380 builtins = hy_builtins + hy_core 

381 

382 # valid names for identifiers 

383 # well, names can only not consist fully of numbers 

384 # but this should be good enough for now 

385 valid_name = r'(?!#)[\w!$%*+<=>?/.#:-]+' 

386 

387 def _multi_escape(entries): 

388 return words(entries, suffix=' ') 

389 

390 tokens = { 

391 'root': [ 

392 # the comments - always starting with semicolon 

393 # and going to the end of the line 

394 (r';.*$', Comment.Single), 

395 

396 # whitespaces - usually not relevant 

397 (r'[,\s]+', Text), 

398 

399 # numbers 

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

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

402 (r'0[0-7]+j?', Number.Oct), 

403 (r'0[xX][a-fA-F0-9]+', Number.Hex), 

404 

405 # strings, symbols and characters 

406 (r'"(\\\\|\\[^\\]|[^"\\])*"', String), 

407 (r"'" + valid_name, String.Symbol), 

408 (r"\\(.|[a-z]+)", String.Char), 

409 (r'^(\s*)([rRuU]{,2}"""(?:.|\n)*?""")', bygroups(Text, String.Doc)), 

410 (r"^(\s*)([rRuU]{,2}'''(?:.|\n)*?''')", bygroups(Text, String.Doc)), 

411 

412 # keywords 

413 (r'::?' + valid_name, String.Symbol), 

414 

415 # special operators 

416 (r'~@|[`\'#^~&@]', Operator), 

417 

418 include('py-keywords'), 

419 include('py-builtins'), 

420 

421 # highlight the special forms 

422 (_multi_escape(special_forms), Keyword), 

423 

424 # Technically, only the special forms are 'keywords'. The problem 

425 # is that only treating them as keywords means that things like 

426 # 'defn' and 'ns' need to be highlighted as builtins. This is ugly 

427 # and weird for most styles. So, as a compromise we're going to 

428 # highlight them as Keyword.Declarations. 

429 (_multi_escape(declarations), Keyword.Declaration), 

430 

431 # highlight the builtins 

432 (_multi_escape(builtins), Name.Builtin), 

433 

434 # the remaining functions 

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

436 

437 # find the remaining variables 

438 (valid_name, Name.Variable), 

439 

440 # Hy accepts vector notation 

441 (r'(\[|\])', Punctuation), 

442 

443 # Hy accepts map notation 

444 (r'(\{|\})', Punctuation), 

445 

446 # the famous parentheses! 

447 (r'(\(|\))', Punctuation), 

448 

449 ], 

450 'py-keywords': PythonLexer.tokens['keywords'], 

451 'py-builtins': PythonLexer.tokens['builtins'], 

452 } 

453 

454 def analyse_text(text): 

455 if '(import ' in text or '(defn ' in text: 

456 return 0.9 

457 

458 

459class RacketLexer(RegexLexer): 

460 """ 

461 Lexer for `Racket <http://racket-lang.org/>`_ source code (formerly 

462 known as PLT Scheme). 

463 

464 .. versionadded:: 1.6 

465 """ 

466 

467 name = 'Racket' 

468 aliases = ['racket', 'rkt'] 

469 filenames = ['*.rkt', '*.rktd', '*.rktl'] 

470 mimetypes = ['text/x-racket', 'application/x-racket'] 

471 

472 # Generated by example.rkt 

473 _keywords = ( 

474 '#%app', '#%datum', '#%declare', '#%expression', '#%module-begin', 

475 '#%plain-app', '#%plain-lambda', '#%plain-module-begin', 

476 '#%printing-module-begin', '#%provide', '#%require', 

477 '#%stratified-body', '#%top', '#%top-interaction', 

478 '#%variable-reference', '->', '->*', '->*m', '->d', '->dm', '->i', 

479 '->m', '...', ':do-in', '==', '=>', '_', 'absent', 'abstract', 

480 'all-defined-out', 'all-from-out', 'and', 'any', 'augment', 'augment*', 

481 'augment-final', 'augment-final*', 'augride', 'augride*', 'begin', 

482 'begin-for-syntax', 'begin0', 'case', 'case->', 'case->m', 

483 'case-lambda', 'class', 'class*', 'class-field-accessor', 

484 'class-field-mutator', 'class/c', 'class/derived', 'combine-in', 

485 'combine-out', 'command-line', 'compound-unit', 'compound-unit/infer', 

486 'cond', 'cons/dc', 'contract', 'contract-out', 'contract-struct', 

487 'contracted', 'define', 'define-compound-unit', 

488 'define-compound-unit/infer', 'define-contract-struct', 

489 'define-custom-hash-types', 'define-custom-set-types', 

490 'define-for-syntax', 'define-local-member-name', 'define-logger', 

491 'define-match-expander', 'define-member-name', 

492 'define-module-boundary-contract', 'define-namespace-anchor', 

493 'define-opt/c', 'define-sequence-syntax', 'define-serializable-class', 

494 'define-serializable-class*', 'define-signature', 

495 'define-signature-form', 'define-struct', 'define-struct/contract', 

496 'define-struct/derived', 'define-syntax', 'define-syntax-rule', 

497 'define-syntaxes', 'define-unit', 'define-unit-binding', 

498 'define-unit-from-context', 'define-unit/contract', 

499 'define-unit/new-import-export', 'define-unit/s', 'define-values', 

500 'define-values-for-export', 'define-values-for-syntax', 

501 'define-values/invoke-unit', 'define-values/invoke-unit/infer', 

502 'define/augment', 'define/augment-final', 'define/augride', 

503 'define/contract', 'define/final-prop', 'define/match', 

504 'define/overment', 'define/override', 'define/override-final', 

505 'define/private', 'define/public', 'define/public-final', 

506 'define/pubment', 'define/subexpression-pos-prop', 

507 'define/subexpression-pos-prop/name', 'delay', 'delay/idle', 

508 'delay/name', 'delay/strict', 'delay/sync', 'delay/thread', 'do', 

509 'else', 'except', 'except-in', 'except-out', 'export', 'extends', 

510 'failure-cont', 'false', 'false/c', 'field', 'field-bound?', 'file', 

511 'flat-murec-contract', 'flat-rec-contract', 'for', 'for*', 'for*/and', 

512 'for*/async', 'for*/first', 'for*/fold', 'for*/fold/derived', 

513 'for*/hash', 'for*/hasheq', 'for*/hasheqv', 'for*/last', 'for*/list', 

514 'for*/lists', 'for*/mutable-set', 'for*/mutable-seteq', 

515 'for*/mutable-seteqv', 'for*/or', 'for*/product', 'for*/set', 

516 'for*/seteq', 'for*/seteqv', 'for*/stream', 'for*/sum', 'for*/vector', 

517 'for*/weak-set', 'for*/weak-seteq', 'for*/weak-seteqv', 'for-label', 

518 'for-meta', 'for-syntax', 'for-template', 'for/and', 'for/async', 

519 'for/first', 'for/fold', 'for/fold/derived', 'for/hash', 'for/hasheq', 

520 'for/hasheqv', 'for/last', 'for/list', 'for/lists', 'for/mutable-set', 

521 'for/mutable-seteq', 'for/mutable-seteqv', 'for/or', 'for/product', 

522 'for/set', 'for/seteq', 'for/seteqv', 'for/stream', 'for/sum', 

523 'for/vector', 'for/weak-set', 'for/weak-seteq', 'for/weak-seteqv', 

524 'gen:custom-write', 'gen:dict', 'gen:equal+hash', 'gen:set', 

525 'gen:stream', 'generic', 'get-field', 'hash/dc', 'if', 'implies', 

526 'import', 'include', 'include-at/relative-to', 

527 'include-at/relative-to/reader', 'include/reader', 'inherit', 

528 'inherit-field', 'inherit/inner', 'inherit/super', 'init', 

529 'init-depend', 'init-field', 'init-rest', 'inner', 'inspect', 

530 'instantiate', 'interface', 'interface*', 'invariant-assertion', 

531 'invoke-unit', 'invoke-unit/infer', 'lambda', 'lazy', 'let', 'let*', 

532 'let*-values', 'let-syntax', 'let-syntaxes', 'let-values', 'let/cc', 

533 'let/ec', 'letrec', 'letrec-syntax', 'letrec-syntaxes', 

534 'letrec-syntaxes+values', 'letrec-values', 'lib', 'link', 'local', 

535 'local-require', 'log-debug', 'log-error', 'log-fatal', 'log-info', 

536 'log-warning', 'match', 'match*', 'match*/derived', 'match-define', 

537 'match-define-values', 'match-lambda', 'match-lambda*', 

538 'match-lambda**', 'match-let', 'match-let*', 'match-let*-values', 

539 'match-let-values', 'match-letrec', 'match-letrec-values', 

540 'match/derived', 'match/values', 'member-name-key', 'mixin', 'module', 

541 'module*', 'module+', 'nand', 'new', 'nor', 'object-contract', 

542 'object/c', 'only', 'only-in', 'only-meta-in', 'open', 'opt/c', 'or', 

543 'overment', 'overment*', 'override', 'override*', 'override-final', 

544 'override-final*', 'parameterize', 'parameterize*', 

545 'parameterize-break', 'parametric->/c', 'place', 'place*', 

546 'place/context', 'planet', 'prefix', 'prefix-in', 'prefix-out', 

547 'private', 'private*', 'prompt-tag/c', 'protect-out', 'provide', 

548 'provide-signature-elements', 'provide/contract', 'public', 'public*', 

549 'public-final', 'public-final*', 'pubment', 'pubment*', 'quasiquote', 

550 'quasisyntax', 'quasisyntax/loc', 'quote', 'quote-syntax', 

551 'quote-syntax/prune', 'recontract-out', 'recursive-contract', 

552 'relative-in', 'rename', 'rename-in', 'rename-inner', 'rename-out', 

553 'rename-super', 'require', 'send', 'send*', 'send+', 'send-generic', 

554 'send/apply', 'send/keyword-apply', 'set!', 'set!-values', 

555 'set-field!', 'shared', 'stream', 'stream*', 'stream-cons', 'struct', 

556 'struct*', 'struct-copy', 'struct-field-index', 'struct-out', 

557 'struct/c', 'struct/ctc', 'struct/dc', 'submod', 'super', 

558 'super-instantiate', 'super-make-object', 'super-new', 'syntax', 

559 'syntax-case', 'syntax-case*', 'syntax-id-rules', 'syntax-rules', 

560 'syntax/loc', 'tag', 'this', 'this%', 'thunk', 'thunk*', 'time', 

561 'unconstrained-domain->', 'unit', 'unit-from-context', 'unit/c', 

562 'unit/new-import-export', 'unit/s', 'unless', 'unquote', 

563 'unquote-splicing', 'unsyntax', 'unsyntax-splicing', 'values/drop', 

564 'when', 'with-continuation-mark', 'with-contract', 

565 'with-contract-continuation-mark', 'with-handlers', 'with-handlers*', 

566 'with-method', 'with-syntax', 'λ' 

567 ) 

568 

569 # Generated by example.rkt 

570 _builtins = ( 

571 '*', '*list/c', '+', '-', '/', '<', '</c', '<=', '<=/c', '=', '=/c', 

572 '>', '>/c', '>=', '>=/c', 'abort-current-continuation', 'abs', 

573 'absolute-path?', 'acos', 'add-between', 'add1', 'alarm-evt', 

574 'always-evt', 'and/c', 'andmap', 'angle', 'any/c', 'append', 'append*', 

575 'append-map', 'apply', 'argmax', 'argmin', 'arithmetic-shift', 

576 'arity-at-least', 'arity-at-least-value', 'arity-at-least?', 

577 'arity-checking-wrapper', 'arity-includes?', 'arity=?', 

578 'arrow-contract-info', 'arrow-contract-info-accepts-arglist', 

579 'arrow-contract-info-chaperone-procedure', 

580 'arrow-contract-info-check-first-order', 'arrow-contract-info?', 

581 'asin', 'assf', 'assoc', 'assq', 'assv', 'atan', 

582 'bad-number-of-results', 'banner', 'base->-doms/c', 'base->-rngs/c', 

583 'base->?', 'between/c', 'bitwise-and', 'bitwise-bit-field', 

584 'bitwise-bit-set?', 'bitwise-ior', 'bitwise-not', 'bitwise-xor', 

585 'blame-add-car-context', 'blame-add-cdr-context', 'blame-add-context', 

586 'blame-add-missing-party', 'blame-add-nth-arg-context', 

587 'blame-add-range-context', 'blame-add-unknown-context', 

588 'blame-context', 'blame-contract', 'blame-fmt->-string', 

589 'blame-missing-party?', 'blame-negative', 'blame-original?', 

590 'blame-positive', 'blame-replace-negative', 'blame-source', 

591 'blame-swap', 'blame-swapped?', 'blame-update', 'blame-value', 

592 'blame?', 'boolean=?', 'boolean?', 'bound-identifier=?', 'box', 

593 'box-cas!', 'box-immutable', 'box-immutable/c', 'box/c', 'box?', 

594 'break-enabled', 'break-parameterization?', 'break-thread', 

595 'build-chaperone-contract-property', 'build-compound-type-name', 

596 'build-contract-property', 'build-flat-contract-property', 

597 'build-list', 'build-path', 'build-path/convention-type', 

598 'build-string', 'build-vector', 'byte-pregexp', 'byte-pregexp?', 

599 'byte-ready?', 'byte-regexp', 'byte-regexp?', 'byte?', 'bytes', 

600 'bytes->immutable-bytes', 'bytes->list', 'bytes->path', 

601 'bytes->path-element', 'bytes->string/latin-1', 'bytes->string/locale', 

602 'bytes->string/utf-8', 'bytes-append', 'bytes-append*', 

603 'bytes-close-converter', 'bytes-convert', 'bytes-convert-end', 

604 'bytes-converter?', 'bytes-copy', 'bytes-copy!', 

605 'bytes-environment-variable-name?', 'bytes-fill!', 'bytes-join', 

606 'bytes-length', 'bytes-no-nuls?', 'bytes-open-converter', 'bytes-ref', 

607 'bytes-set!', 'bytes-utf-8-index', 'bytes-utf-8-length', 

608 'bytes-utf-8-ref', 'bytes<?', 'bytes=?', 'bytes>?', 'bytes?', 'caaaar', 

609 'caaadr', 'caaar', 'caadar', 'caaddr', 'caadr', 'caar', 'cadaar', 

610 'cadadr', 'cadar', 'caddar', 'cadddr', 'caddr', 'cadr', 

611 'call-in-nested-thread', 'call-with-atomic-output-file', 

612 'call-with-break-parameterization', 

613 'call-with-composable-continuation', 'call-with-continuation-barrier', 

614 'call-with-continuation-prompt', 'call-with-current-continuation', 

615 'call-with-default-reading-parameterization', 

616 'call-with-escape-continuation', 'call-with-exception-handler', 

617 'call-with-file-lock/timeout', 'call-with-immediate-continuation-mark', 

618 'call-with-input-bytes', 'call-with-input-file', 

619 'call-with-input-file*', 'call-with-input-string', 

620 'call-with-output-bytes', 'call-with-output-file', 

621 'call-with-output-file*', 'call-with-output-string', 

622 'call-with-parameterization', 'call-with-semaphore', 

623 'call-with-semaphore/enable-break', 'call-with-values', 'call/cc', 

624 'call/ec', 'car', 'cartesian-product', 'cdaaar', 'cdaadr', 'cdaar', 

625 'cdadar', 'cdaddr', 'cdadr', 'cdar', 'cddaar', 'cddadr', 'cddar', 

626 'cdddar', 'cddddr', 'cdddr', 'cddr', 'cdr', 'ceiling', 'channel-get', 

627 'channel-put', 'channel-put-evt', 'channel-put-evt?', 

628 'channel-try-get', 'channel/c', 'channel?', 'chaperone-box', 

629 'chaperone-channel', 'chaperone-continuation-mark-key', 

630 'chaperone-contract-property?', 'chaperone-contract?', 'chaperone-evt', 

631 'chaperone-hash', 'chaperone-hash-set', 'chaperone-of?', 

632 'chaperone-procedure', 'chaperone-procedure*', 'chaperone-prompt-tag', 

633 'chaperone-struct', 'chaperone-struct-type', 'chaperone-vector', 

634 'chaperone?', 'char->integer', 'char-alphabetic?', 'char-blank?', 

635 'char-ci<=?', 'char-ci<?', 'char-ci=?', 'char-ci>=?', 'char-ci>?', 

636 'char-downcase', 'char-foldcase', 'char-general-category', 

637 'char-graphic?', 'char-in', 'char-in/c', 'char-iso-control?', 

638 'char-lower-case?', 'char-numeric?', 'char-punctuation?', 

639 'char-ready?', 'char-symbolic?', 'char-title-case?', 'char-titlecase', 

640 'char-upcase', 'char-upper-case?', 'char-utf-8-length', 

641 'char-whitespace?', 'char<=?', 'char<?', 'char=?', 'char>=?', 'char>?', 

642 'char?', 'check-duplicate-identifier', 'check-duplicates', 

643 'checked-procedure-check-and-extract', 'choice-evt', 

644 'class->interface', 'class-info', 'class-seal', 'class-unseal', 

645 'class?', 'cleanse-path', 'close-input-port', 'close-output-port', 

646 'coerce-chaperone-contract', 'coerce-chaperone-contracts', 

647 'coerce-contract', 'coerce-contract/f', 'coerce-contracts', 

648 'coerce-flat-contract', 'coerce-flat-contracts', 'collect-garbage', 

649 'collection-file-path', 'collection-path', 'combinations', 'compile', 

650 'compile-allow-set!-undefined', 'compile-context-preservation-enabled', 

651 'compile-enforce-module-constants', 'compile-syntax', 

652 'compiled-expression-recompile', 'compiled-expression?', 

653 'compiled-module-expression?', 'complete-path?', 'complex?', 'compose', 

654 'compose1', 'conjoin', 'conjugate', 'cons', 'cons/c', 'cons?', 'const', 

655 'continuation-mark-key/c', 'continuation-mark-key?', 

656 'continuation-mark-set->context', 'continuation-mark-set->list', 

657 'continuation-mark-set->list*', 'continuation-mark-set-first', 

658 'continuation-mark-set?', 'continuation-marks', 

659 'continuation-prompt-available?', 'continuation-prompt-tag?', 

660 'continuation?', 'contract-continuation-mark-key', 

661 'contract-custom-write-property-proc', 'contract-exercise', 

662 'contract-first-order', 'contract-first-order-passes?', 

663 'contract-late-neg-projection', 'contract-name', 'contract-proc', 

664 'contract-projection', 'contract-property?', 

665 'contract-random-generate', 'contract-random-generate-fail', 

666 'contract-random-generate-fail?', 

667 'contract-random-generate-get-current-environment', 

668 'contract-random-generate-stash', 'contract-random-generate/choose', 

669 'contract-stronger?', 'contract-struct-exercise', 

670 'contract-struct-generate', 'contract-struct-late-neg-projection', 

671 'contract-struct-list-contract?', 'contract-val-first-projection', 

672 'contract?', 'convert-stream', 'copy-directory/files', 'copy-file', 

673 'copy-port', 'cos', 'cosh', 'count', 'current-blame-format', 

674 'current-break-parameterization', 'current-code-inspector', 

675 'current-command-line-arguments', 'current-compile', 

676 'current-compiled-file-roots', 'current-continuation-marks', 

677 'current-contract-region', 'current-custodian', 'current-directory', 

678 'current-directory-for-user', 'current-drive', 

679 'current-environment-variables', 'current-error-port', 'current-eval', 

680 'current-evt-pseudo-random-generator', 

681 'current-force-delete-permissions', 'current-future', 

682 'current-gc-milliseconds', 'current-get-interaction-input-port', 

683 'current-inexact-milliseconds', 'current-input-port', 

684 'current-inspector', 'current-library-collection-links', 

685 'current-library-collection-paths', 'current-load', 

686 'current-load-extension', 'current-load-relative-directory', 

687 'current-load/use-compiled', 'current-locale', 'current-logger', 

688 'current-memory-use', 'current-milliseconds', 

689 'current-module-declare-name', 'current-module-declare-source', 

690 'current-module-name-resolver', 'current-module-path-for-load', 

691 'current-namespace', 'current-output-port', 'current-parameterization', 

692 'current-plumber', 'current-preserved-thread-cell-values', 

693 'current-print', 'current-process-milliseconds', 'current-prompt-read', 

694 'current-pseudo-random-generator', 'current-read-interaction', 

695 'current-reader-guard', 'current-readtable', 'current-seconds', 

696 'current-security-guard', 'current-subprocess-custodian-mode', 

697 'current-thread', 'current-thread-group', 

698 'current-thread-initial-stack-size', 

699 'current-write-relative-directory', 'curry', 'curryr', 

700 'custodian-box-value', 'custodian-box?', 'custodian-limit-memory', 

701 'custodian-managed-list', 'custodian-memory-accounting-available?', 

702 'custodian-require-memory', 'custodian-shutdown-all', 'custodian?', 

703 'custom-print-quotable-accessor', 'custom-print-quotable?', 

704 'custom-write-accessor', 'custom-write-property-proc', 'custom-write?', 

705 'date', 'date*', 'date*-nanosecond', 'date*-time-zone-name', 'date*?', 

706 'date-day', 'date-dst?', 'date-hour', 'date-minute', 'date-month', 

707 'date-second', 'date-time-zone-offset', 'date-week-day', 'date-year', 

708 'date-year-day', 'date?', 'datum->syntax', 'datum-intern-literal', 

709 'default-continuation-prompt-tag', 'degrees->radians', 

710 'delete-directory', 'delete-directory/files', 'delete-file', 

711 'denominator', 'dict->list', 'dict-can-functional-set?', 

712 'dict-can-remove-keys?', 'dict-clear', 'dict-clear!', 'dict-copy', 

713 'dict-count', 'dict-empty?', 'dict-for-each', 'dict-has-key?', 

714 'dict-implements/c', 'dict-implements?', 'dict-iter-contract', 

715 'dict-iterate-first', 'dict-iterate-key', 'dict-iterate-next', 

716 'dict-iterate-value', 'dict-key-contract', 'dict-keys', 'dict-map', 

717 'dict-mutable?', 'dict-ref', 'dict-ref!', 'dict-remove', 

718 'dict-remove!', 'dict-set', 'dict-set!', 'dict-set*', 'dict-set*!', 

719 'dict-update', 'dict-update!', 'dict-value-contract', 'dict-values', 

720 'dict?', 'directory-exists?', 'directory-list', 'disjoin', 'display', 

721 'display-lines', 'display-lines-to-file', 'display-to-file', 

722 'displayln', 'double-flonum?', 'drop', 'drop-common-prefix', 

723 'drop-right', 'dropf', 'dropf-right', 'dump-memory-stats', 

724 'dup-input-port', 'dup-output-port', 'dynamic->*', 'dynamic-get-field', 

725 'dynamic-object/c', 'dynamic-place', 'dynamic-place*', 

726 'dynamic-require', 'dynamic-require-for-syntax', 'dynamic-send', 

727 'dynamic-set-field!', 'dynamic-wind', 'eighth', 'empty', 

728 'empty-sequence', 'empty-stream', 'empty?', 

729 'environment-variables-copy', 'environment-variables-names', 

730 'environment-variables-ref', 'environment-variables-set!', 

731 'environment-variables?', 'eof', 'eof-evt', 'eof-object?', 

732 'ephemeron-value', 'ephemeron?', 'eprintf', 'eq-contract-val', 

733 'eq-contract?', 'eq-hash-code', 'eq?', 'equal-contract-val', 

734 'equal-contract?', 'equal-hash-code', 'equal-secondary-hash-code', 

735 'equal<%>', 'equal?', 'equal?/recur', 'eqv-hash-code', 'eqv?', 'error', 

736 'error-display-handler', 'error-escape-handler', 

737 'error-print-context-length', 'error-print-source-location', 

738 'error-print-width', 'error-value->string-handler', 'eval', 

739 'eval-jit-enabled', 'eval-syntax', 'even?', 'evt/c', 'evt?', 

740 'exact->inexact', 'exact-ceiling', 'exact-floor', 'exact-integer?', 

741 'exact-nonnegative-integer?', 'exact-positive-integer?', 'exact-round', 

742 'exact-truncate', 'exact?', 'executable-yield-handler', 'exit', 

743 'exit-handler', 'exn', 'exn-continuation-marks', 'exn-message', 

744 'exn:break', 'exn:break-continuation', 'exn:break:hang-up', 

745 'exn:break:hang-up?', 'exn:break:terminate', 'exn:break:terminate?', 

746 'exn:break?', 'exn:fail', 'exn:fail:contract', 

747 'exn:fail:contract:arity', 'exn:fail:contract:arity?', 

748 'exn:fail:contract:blame', 'exn:fail:contract:blame-object', 

749 'exn:fail:contract:blame?', 'exn:fail:contract:continuation', 

750 'exn:fail:contract:continuation?', 'exn:fail:contract:divide-by-zero', 

751 'exn:fail:contract:divide-by-zero?', 

752 'exn:fail:contract:non-fixnum-result', 

753 'exn:fail:contract:non-fixnum-result?', 'exn:fail:contract:variable', 

754 'exn:fail:contract:variable-id', 'exn:fail:contract:variable?', 

755 'exn:fail:contract?', 'exn:fail:filesystem', 

756 'exn:fail:filesystem:errno', 'exn:fail:filesystem:errno-errno', 

757 'exn:fail:filesystem:errno?', 'exn:fail:filesystem:exists', 

758 'exn:fail:filesystem:exists?', 'exn:fail:filesystem:missing-module', 

759 'exn:fail:filesystem:missing-module-path', 

760 'exn:fail:filesystem:missing-module?', 'exn:fail:filesystem:version', 

761 'exn:fail:filesystem:version?', 'exn:fail:filesystem?', 

762 'exn:fail:network', 'exn:fail:network:errno', 

763 'exn:fail:network:errno-errno', 'exn:fail:network:errno?', 

764 'exn:fail:network?', 'exn:fail:object', 'exn:fail:object?', 

765 'exn:fail:out-of-memory', 'exn:fail:out-of-memory?', 'exn:fail:read', 

766 'exn:fail:read-srclocs', 'exn:fail:read:eof', 'exn:fail:read:eof?', 

767 'exn:fail:read:non-char', 'exn:fail:read:non-char?', 'exn:fail:read?', 

768 'exn:fail:syntax', 'exn:fail:syntax-exprs', 

769 'exn:fail:syntax:missing-module', 

770 'exn:fail:syntax:missing-module-path', 

771 'exn:fail:syntax:missing-module?', 'exn:fail:syntax:unbound', 

772 'exn:fail:syntax:unbound?', 'exn:fail:syntax?', 'exn:fail:unsupported', 

773 'exn:fail:unsupported?', 'exn:fail:user', 'exn:fail:user?', 

774 'exn:fail?', 'exn:misc:match?', 'exn:missing-module-accessor', 

775 'exn:missing-module?', 'exn:srclocs-accessor', 'exn:srclocs?', 'exn?', 

776 'exp', 'expand', 'expand-once', 'expand-syntax', 'expand-syntax-once', 

777 'expand-syntax-to-top-form', 'expand-to-top-form', 'expand-user-path', 

778 'explode-path', 'expt', 'externalizable<%>', 'failure-result/c', 

779 'false?', 'field-names', 'fifth', 'file->bytes', 'file->bytes-lines', 

780 'file->lines', 'file->list', 'file->string', 'file->value', 

781 'file-exists?', 'file-name-from-path', 'file-or-directory-identity', 

782 'file-or-directory-modify-seconds', 'file-or-directory-permissions', 

783 'file-position', 'file-position*', 'file-size', 

784 'file-stream-buffer-mode', 'file-stream-port?', 'file-truncate', 

785 'filename-extension', 'filesystem-change-evt', 

786 'filesystem-change-evt-cancel', 'filesystem-change-evt?', 

787 'filesystem-root-list', 'filter', 'filter-map', 'filter-not', 

788 'filter-read-input-port', 'find-executable-path', 'find-files', 

789 'find-library-collection-links', 'find-library-collection-paths', 

790 'find-relative-path', 'find-system-path', 'findf', 'first', 

791 'first-or/c', 'fixnum?', 'flat-contract', 'flat-contract-predicate', 

792 'flat-contract-property?', 'flat-contract?', 'flat-named-contract', 

793 'flatten', 'floating-point-bytes->real', 'flonum?', 'floor', 

794 'flush-output', 'fold-files', 'foldl', 'foldr', 'for-each', 'force', 

795 'format', 'fourth', 'fprintf', 'free-identifier=?', 

796 'free-label-identifier=?', 'free-template-identifier=?', 

797 'free-transformer-identifier=?', 'fsemaphore-count', 'fsemaphore-post', 

798 'fsemaphore-try-wait?', 'fsemaphore-wait', 'fsemaphore?', 'future', 

799 'future?', 'futures-enabled?', 'gcd', 'generate-member-key', 

800 'generate-temporaries', 'generic-set?', 'generic?', 'gensym', 

801 'get-output-bytes', 'get-output-string', 'get-preference', 

802 'get/build-late-neg-projection', 'get/build-val-first-projection', 

803 'getenv', 'global-port-print-handler', 'group-by', 'group-execute-bit', 

804 'group-read-bit', 'group-write-bit', 'guard-evt', 'handle-evt', 

805 'handle-evt?', 'has-blame?', 'has-contract?', 'hash', 'hash->list', 

806 'hash-clear', 'hash-clear!', 'hash-copy', 'hash-copy-clear', 

807 'hash-count', 'hash-empty?', 'hash-eq?', 'hash-equal?', 'hash-eqv?', 

808 'hash-for-each', 'hash-has-key?', 'hash-iterate-first', 

809 'hash-iterate-key', 'hash-iterate-key+value', 'hash-iterate-next', 

810 'hash-iterate-pair', 'hash-iterate-value', 'hash-keys', 'hash-map', 

811 'hash-placeholder?', 'hash-ref', 'hash-ref!', 'hash-remove', 

812 'hash-remove!', 'hash-set', 'hash-set!', 'hash-set*', 'hash-set*!', 

813 'hash-update', 'hash-update!', 'hash-values', 'hash-weak?', 'hash/c', 

814 'hash?', 'hasheq', 'hasheqv', 'identifier-binding', 

815 'identifier-binding-symbol', 'identifier-label-binding', 

816 'identifier-prune-lexical-context', 

817 'identifier-prune-to-source-module', 

818 'identifier-remove-from-definition-context', 

819 'identifier-template-binding', 'identifier-transformer-binding', 

820 'identifier?', 'identity', 'if/c', 'imag-part', 'immutable?', 

821 'impersonate-box', 'impersonate-channel', 

822 'impersonate-continuation-mark-key', 'impersonate-hash', 

823 'impersonate-hash-set', 'impersonate-procedure', 

824 'impersonate-procedure*', 'impersonate-prompt-tag', 

825 'impersonate-struct', 'impersonate-vector', 'impersonator-contract?', 

826 'impersonator-ephemeron', 'impersonator-of?', 

827 'impersonator-prop:application-mark', 'impersonator-prop:blame', 

828 'impersonator-prop:contracted', 

829 'impersonator-property-accessor-procedure?', 'impersonator-property?', 

830 'impersonator?', 'implementation?', 'implementation?/c', 'in-bytes', 

831 'in-bytes-lines', 'in-combinations', 'in-cycle', 'in-dict', 

832 'in-dict-keys', 'in-dict-pairs', 'in-dict-values', 'in-directory', 

833 'in-hash', 'in-hash-keys', 'in-hash-pairs', 'in-hash-values', 

834 'in-immutable-hash', 'in-immutable-hash-keys', 

835 'in-immutable-hash-pairs', 'in-immutable-hash-values', 

836 'in-immutable-set', 'in-indexed', 'in-input-port-bytes', 

837 'in-input-port-chars', 'in-lines', 'in-list', 'in-mlist', 

838 'in-mutable-hash', 'in-mutable-hash-keys', 'in-mutable-hash-pairs', 

839 'in-mutable-hash-values', 'in-mutable-set', 'in-naturals', 

840 'in-parallel', 'in-permutations', 'in-port', 'in-producer', 'in-range', 

841 'in-sequences', 'in-set', 'in-slice', 'in-stream', 'in-string', 

842 'in-syntax', 'in-value', 'in-values*-sequence', 'in-values-sequence', 

843 'in-vector', 'in-weak-hash', 'in-weak-hash-keys', 'in-weak-hash-pairs', 

844 'in-weak-hash-values', 'in-weak-set', 'inexact->exact', 

845 'inexact-real?', 'inexact?', 'infinite?', 'input-port-append', 

846 'input-port?', 'inspector?', 'instanceof/c', 'integer->char', 

847 'integer->integer-bytes', 'integer-bytes->integer', 'integer-in', 

848 'integer-length', 'integer-sqrt', 'integer-sqrt/remainder', 'integer?', 

849 'interface->method-names', 'interface-extension?', 'interface?', 

850 'internal-definition-context-binding-identifiers', 

851 'internal-definition-context-introduce', 

852 'internal-definition-context-seal', 'internal-definition-context?', 

853 'is-a?', 'is-a?/c', 'keyword->string', 'keyword-apply', 'keyword<?', 

854 'keyword?', 'keywords-match', 'kill-thread', 'last', 'last-pair', 

855 'lcm', 'length', 'liberal-define-context?', 'link-exists?', 'list', 

856 'list*', 'list*of', 'list->bytes', 'list->mutable-set', 

857 'list->mutable-seteq', 'list->mutable-seteqv', 'list->set', 

858 'list->seteq', 'list->seteqv', 'list->string', 'list->vector', 

859 'list->weak-set', 'list->weak-seteq', 'list->weak-seteqv', 

860 'list-contract?', 'list-prefix?', 'list-ref', 'list-set', 'list-tail', 

861 'list-update', 'list/c', 'list?', 'listen-port-number?', 'listof', 

862 'load', 'load-extension', 'load-on-demand-enabled', 'load-relative', 

863 'load-relative-extension', 'load/cd', 'load/use-compiled', 

864 'local-expand', 'local-expand/capture-lifts', 

865 'local-transformer-expand', 'local-transformer-expand/capture-lifts', 

866 'locale-string-encoding', 'log', 'log-all-levels', 'log-level-evt', 

867 'log-level?', 'log-max-level', 'log-message', 'log-receiver?', 

868 'logger-name', 'logger?', 'magnitude', 'make-arity-at-least', 

869 'make-base-empty-namespace', 'make-base-namespace', 'make-bytes', 

870 'make-channel', 'make-chaperone-contract', 

871 'make-continuation-mark-key', 'make-continuation-prompt-tag', 

872 'make-contract', 'make-custodian', 'make-custodian-box', 

873 'make-custom-hash', 'make-custom-hash-types', 'make-custom-set', 

874 'make-custom-set-types', 'make-date', 'make-date*', 

875 'make-derived-parameter', 'make-directory', 'make-directory*', 

876 'make-do-sequence', 'make-empty-namespace', 

877 'make-environment-variables', 'make-ephemeron', 'make-exn', 

878 'make-exn:break', 'make-exn:break:hang-up', 'make-exn:break:terminate', 

879 'make-exn:fail', 'make-exn:fail:contract', 

880 'make-exn:fail:contract:arity', 'make-exn:fail:contract:blame', 

881 'make-exn:fail:contract:continuation', 

882 'make-exn:fail:contract:divide-by-zero', 

883 'make-exn:fail:contract:non-fixnum-result', 

884 'make-exn:fail:contract:variable', 'make-exn:fail:filesystem', 

885 'make-exn:fail:filesystem:errno', 'make-exn:fail:filesystem:exists', 

886 'make-exn:fail:filesystem:missing-module', 

887 'make-exn:fail:filesystem:version', 'make-exn:fail:network', 

888 'make-exn:fail:network:errno', 'make-exn:fail:object', 

889 'make-exn:fail:out-of-memory', 'make-exn:fail:read', 

890 'make-exn:fail:read:eof', 'make-exn:fail:read:non-char', 

891 'make-exn:fail:syntax', 'make-exn:fail:syntax:missing-module', 

892 'make-exn:fail:syntax:unbound', 'make-exn:fail:unsupported', 

893 'make-exn:fail:user', 'make-file-or-directory-link', 

894 'make-flat-contract', 'make-fsemaphore', 'make-generic', 

895 'make-handle-get-preference-locked', 'make-hash', 

896 'make-hash-placeholder', 'make-hasheq', 'make-hasheq-placeholder', 

897 'make-hasheqv', 'make-hasheqv-placeholder', 

898 'make-immutable-custom-hash', 'make-immutable-hash', 

899 'make-immutable-hasheq', 'make-immutable-hasheqv', 

900 'make-impersonator-property', 'make-input-port', 

901 'make-input-port/read-to-peek', 'make-inspector', 

902 'make-keyword-procedure', 'make-known-char-range-list', 

903 'make-limited-input-port', 'make-list', 'make-lock-file-name', 

904 'make-log-receiver', 'make-logger', 'make-mixin-contract', 

905 'make-mutable-custom-set', 'make-none/c', 'make-object', 

906 'make-output-port', 'make-parameter', 'make-parent-directory*', 

907 'make-phantom-bytes', 'make-pipe', 'make-pipe-with-specials', 

908 'make-placeholder', 'make-plumber', 'make-polar', 'make-prefab-struct', 

909 'make-primitive-class', 'make-proj-contract', 

910 'make-pseudo-random-generator', 'make-reader-graph', 'make-readtable', 

911 'make-rectangular', 'make-rename-transformer', 

912 'make-resolved-module-path', 'make-security-guard', 'make-semaphore', 

913 'make-set!-transformer', 'make-shared-bytes', 'make-sibling-inspector', 

914 'make-special-comment', 'make-srcloc', 'make-string', 

915 'make-struct-field-accessor', 'make-struct-field-mutator', 

916 'make-struct-type', 'make-struct-type-property', 

917 'make-syntax-delta-introducer', 'make-syntax-introducer', 

918 'make-temporary-file', 'make-tentative-pretty-print-output-port', 

919 'make-thread-cell', 'make-thread-group', 'make-vector', 

920 'make-weak-box', 'make-weak-custom-hash', 'make-weak-custom-set', 

921 'make-weak-hash', 'make-weak-hasheq', 'make-weak-hasheqv', 

922 'make-will-executor', 'map', 'match-equality-test', 

923 'matches-arity-exactly?', 'max', 'mcar', 'mcdr', 'mcons', 'member', 

924 'member-name-key-hash-code', 'member-name-key=?', 'member-name-key?', 

925 'memf', 'memq', 'memv', 'merge-input', 'method-in-interface?', 'min', 

926 'mixin-contract', 'module->exports', 'module->imports', 

927 'module->language-info', 'module->namespace', 

928 'module-compiled-cross-phase-persistent?', 'module-compiled-exports', 

929 'module-compiled-imports', 'module-compiled-language-info', 

930 'module-compiled-name', 'module-compiled-submodules', 

931 'module-declared?', 'module-path-index-join', 

932 'module-path-index-resolve', 'module-path-index-split', 

933 'module-path-index-submodule', 'module-path-index?', 'module-path?', 

934 'module-predefined?', 'module-provide-protected?', 'modulo', 'mpair?', 

935 'mutable-set', 'mutable-seteq', 'mutable-seteqv', 'n->th', 

936 'nack-guard-evt', 'namespace-anchor->empty-namespace', 

937 'namespace-anchor->namespace', 'namespace-anchor?', 

938 'namespace-attach-module', 'namespace-attach-module-declaration', 

939 'namespace-base-phase', 'namespace-mapped-symbols', 

940 'namespace-module-identifier', 'namespace-module-registry', 

941 'namespace-require', 'namespace-require/constant', 

942 'namespace-require/copy', 'namespace-require/expansion-time', 

943 'namespace-set-variable-value!', 'namespace-symbol->identifier', 

944 'namespace-syntax-introduce', 'namespace-undefine-variable!', 

945 'namespace-unprotect-module', 'namespace-variable-value', 'namespace?', 

946 'nan?', 'natural-number/c', 'negate', 'negative?', 'never-evt', 

947 'new-∀/c', 'new-∃/c', 'newline', 'ninth', 'non-empty-listof', 

948 'non-empty-string?', 'none/c', 'normal-case-path', 'normalize-arity', 

949 'normalize-path', 'normalized-arity?', 'not', 'not/c', 'null', 'null?', 

950 'number->string', 'number?', 'numerator', 'object%', 'object->vector', 

951 'object-info', 'object-interface', 'object-method-arity-includes?', 

952 'object-name', 'object-or-false=?', 'object=?', 'object?', 'odd?', 

953 'one-of/c', 'open-input-bytes', 'open-input-file', 

954 'open-input-output-file', 'open-input-string', 'open-output-bytes', 

955 'open-output-file', 'open-output-nowhere', 'open-output-string', 

956 'or/c', 'order-of-magnitude', 'ormap', 'other-execute-bit', 

957 'other-read-bit', 'other-write-bit', 'output-port?', 'pair?', 

958 'parameter-procedure=?', 'parameter/c', 'parameter?', 

959 'parameterization?', 'parse-command-line', 'partition', 'path->bytes', 

960 'path->complete-path', 'path->directory-path', 'path->string', 

961 'path-add-suffix', 'path-convention-type', 'path-element->bytes', 

962 'path-element->string', 'path-element?', 'path-for-some-system?', 

963 'path-list-string->path-list', 'path-only', 'path-replace-suffix', 

964 'path-string?', 'path<?', 'path?', 'pathlist-closure', 'peek-byte', 

965 'peek-byte-or-special', 'peek-bytes', 'peek-bytes!', 'peek-bytes!-evt', 

966 'peek-bytes-avail!', 'peek-bytes-avail!*', 'peek-bytes-avail!-evt', 

967 'peek-bytes-avail!/enable-break', 'peek-bytes-evt', 'peek-char', 

968 'peek-char-or-special', 'peek-string', 'peek-string!', 

969 'peek-string!-evt', 'peek-string-evt', 'peeking-input-port', 

970 'permutations', 'phantom-bytes?', 'pi', 'pi.f', 'pipe-content-length', 

971 'place-break', 'place-channel', 'place-channel-get', 

972 'place-channel-put', 'place-channel-put/get', 'place-channel?', 

973 'place-dead-evt', 'place-enabled?', 'place-kill', 'place-location?', 

974 'place-message-allowed?', 'place-sleep', 'place-wait', 'place?', 

975 'placeholder-get', 'placeholder-set!', 'placeholder?', 

976 'plumber-add-flush!', 'plumber-flush-all', 

977 'plumber-flush-handle-remove!', 'plumber-flush-handle?', 'plumber?', 

978 'poll-guard-evt', 'port->bytes', 'port->bytes-lines', 'port->lines', 

979 'port->list', 'port->string', 'port-closed-evt', 'port-closed?', 

980 'port-commit-peeked', 'port-count-lines!', 'port-count-lines-enabled', 

981 'port-counts-lines?', 'port-display-handler', 'port-file-identity', 

982 'port-file-unlock', 'port-next-location', 'port-number?', 

983 'port-print-handler', 'port-progress-evt', 

984 'port-provides-progress-evts?', 'port-read-handler', 

985 'port-try-file-lock?', 'port-write-handler', 'port-writes-atomic?', 

986 'port-writes-special?', 'port?', 'positive?', 'predicate/c', 

987 'prefab-key->struct-type', 'prefab-key?', 'prefab-struct-key', 

988 'preferences-lock-file-mode', 'pregexp', 'pregexp?', 'pretty-display', 

989 'pretty-format', 'pretty-print', 'pretty-print-.-symbol-without-bars', 

990 'pretty-print-abbreviate-read-macros', 'pretty-print-columns', 

991 'pretty-print-current-style-table', 'pretty-print-depth', 

992 'pretty-print-exact-as-decimal', 'pretty-print-extend-style-table', 

993 'pretty-print-handler', 'pretty-print-newline', 

994 'pretty-print-post-print-hook', 'pretty-print-pre-print-hook', 

995 'pretty-print-print-hook', 'pretty-print-print-line', 

996 'pretty-print-remap-stylable', 'pretty-print-show-inexactness', 

997 'pretty-print-size-hook', 'pretty-print-style-table?', 

998 'pretty-printing', 'pretty-write', 'primitive-closure?', 

999 'primitive-result-arity', 'primitive?', 'print', 'print-as-expression', 

1000 'print-boolean-long-form', 'print-box', 'print-graph', 

1001 'print-hash-table', 'print-mpair-curly-braces', 

1002 'print-pair-curly-braces', 'print-reader-abbreviations', 

1003 'print-struct', 'print-syntax-width', 'print-unreadable', 

1004 'print-vector-length', 'printable/c', 'printable<%>', 'printf', 

1005 'println', 'procedure->method', 'procedure-arity', 

1006 'procedure-arity-includes/c', 'procedure-arity-includes?', 

1007 'procedure-arity?', 'procedure-closure-contents-eq?', 

1008 'procedure-extract-target', 'procedure-keywords', 

1009 'procedure-reduce-arity', 'procedure-reduce-keyword-arity', 

1010 'procedure-rename', 'procedure-result-arity', 'procedure-specialize', 

1011 'procedure-struct-type?', 'procedure?', 'process', 'process*', 

1012 'process*/ports', 'process/ports', 'processor-count', 'progress-evt?', 

1013 'promise-forced?', 'promise-running?', 'promise/c', 'promise/name?', 

1014 'promise?', 'prop:arity-string', 'prop:arrow-contract', 

1015 'prop:arrow-contract-get-info', 'prop:arrow-contract?', 'prop:blame', 

1016 'prop:chaperone-contract', 'prop:checked-procedure', 'prop:contract', 

1017 'prop:contracted', 'prop:custom-print-quotable', 'prop:custom-write', 

1018 'prop:dict', 'prop:dict/contract', 'prop:equal+hash', 'prop:evt', 

1019 'prop:exn:missing-module', 'prop:exn:srclocs', 

1020 'prop:expansion-contexts', 'prop:flat-contract', 

1021 'prop:impersonator-of', 'prop:input-port', 

1022 'prop:liberal-define-context', 'prop:object-name', 

1023 'prop:opt-chaperone-contract', 'prop:opt-chaperone-contract-get-test', 

1024 'prop:opt-chaperone-contract?', 'prop:orc-contract', 

1025 'prop:orc-contract-get-subcontracts', 'prop:orc-contract?', 

1026 'prop:output-port', 'prop:place-location', 'prop:procedure', 

1027 'prop:recursive-contract', 'prop:recursive-contract-unroll', 

1028 'prop:recursive-contract?', 'prop:rename-transformer', 'prop:sequence', 

1029 'prop:set!-transformer', 'prop:stream', 'proper-subset?', 

1030 'pseudo-random-generator->vector', 'pseudo-random-generator-vector?', 

1031 'pseudo-random-generator?', 'put-preferences', 'putenv', 'quotient', 

1032 'quotient/remainder', 'radians->degrees', 'raise', 

1033 'raise-argument-error', 'raise-arguments-error', 'raise-arity-error', 

1034 'raise-blame-error', 'raise-contract-error', 'raise-mismatch-error', 

1035 'raise-not-cons-blame-error', 'raise-range-error', 

1036 'raise-result-error', 'raise-syntax-error', 'raise-type-error', 

1037 'raise-user-error', 'random', 'random-seed', 'range', 'rational?', 

1038 'rationalize', 'read', 'read-accept-bar-quote', 'read-accept-box', 

1039 'read-accept-compiled', 'read-accept-dot', 'read-accept-graph', 

1040 'read-accept-infix-dot', 'read-accept-lang', 'read-accept-quasiquote', 

1041 'read-accept-reader', 'read-byte', 'read-byte-or-special', 

1042 'read-bytes', 'read-bytes!', 'read-bytes!-evt', 'read-bytes-avail!', 

1043 'read-bytes-avail!*', 'read-bytes-avail!-evt', 

1044 'read-bytes-avail!/enable-break', 'read-bytes-evt', 'read-bytes-line', 

1045 'read-bytes-line-evt', 'read-case-sensitive', 'read-cdot', 'read-char', 

1046 'read-char-or-special', 'read-curly-brace-as-paren', 

1047 'read-curly-brace-with-tag', 'read-decimal-as-inexact', 

1048 'read-eval-print-loop', 'read-language', 'read-line', 'read-line-evt', 

1049 'read-on-demand-source', 'read-square-bracket-as-paren', 

1050 'read-square-bracket-with-tag', 'read-string', 'read-string!', 

1051 'read-string!-evt', 'read-string-evt', 'read-syntax', 

1052 'read-syntax/recursive', 'read/recursive', 'readtable-mapping', 

1053 'readtable?', 'real->decimal-string', 'real->double-flonum', 

1054 'real->floating-point-bytes', 'real->single-flonum', 'real-in', 

1055 'real-part', 'real?', 'reencode-input-port', 'reencode-output-port', 

1056 'regexp', 'regexp-match', 'regexp-match*', 'regexp-match-evt', 

1057 'regexp-match-exact?', 'regexp-match-peek', 

1058 'regexp-match-peek-immediate', 'regexp-match-peek-positions', 

1059 'regexp-match-peek-positions*', 

1060 'regexp-match-peek-positions-immediate', 

1061 'regexp-match-peek-positions-immediate/end', 

1062 'regexp-match-peek-positions/end', 'regexp-match-positions', 

1063 'regexp-match-positions*', 'regexp-match-positions/end', 

1064 'regexp-match/end', 'regexp-match?', 'regexp-max-lookbehind', 

1065 'regexp-quote', 'regexp-replace', 'regexp-replace*', 

1066 'regexp-replace-quote', 'regexp-replaces', 'regexp-split', 

1067 'regexp-try-match', 'regexp?', 'relative-path?', 'relocate-input-port', 

1068 'relocate-output-port', 'remainder', 'remf', 'remf*', 'remove', 

1069 'remove*', 'remove-duplicates', 'remq', 'remq*', 'remv', 'remv*', 

1070 'rename-contract', 'rename-file-or-directory', 

1071 'rename-transformer-target', 'rename-transformer?', 'replace-evt', 

1072 'reroot-path', 'resolve-path', 'resolved-module-path-name', 

1073 'resolved-module-path?', 'rest', 'reverse', 'round', 'second', 

1074 'seconds->date', 'security-guard?', 'semaphore-peek-evt', 

1075 'semaphore-peek-evt?', 'semaphore-post', 'semaphore-try-wait?', 

1076 'semaphore-wait', 'semaphore-wait/enable-break', 'semaphore?', 

1077 'sequence->list', 'sequence->stream', 'sequence-add-between', 

1078 'sequence-andmap', 'sequence-append', 'sequence-count', 

1079 'sequence-filter', 'sequence-fold', 'sequence-for-each', 

1080 'sequence-generate', 'sequence-generate*', 'sequence-length', 

1081 'sequence-map', 'sequence-ormap', 'sequence-ref', 'sequence-tail', 

1082 'sequence/c', 'sequence?', 'set', 'set!-transformer-procedure', 

1083 'set!-transformer?', 'set->list', 'set->stream', 'set-add', 'set-add!', 

1084 'set-box!', 'set-clear', 'set-clear!', 'set-copy', 'set-copy-clear', 

1085 'set-count', 'set-empty?', 'set-eq?', 'set-equal?', 'set-eqv?', 

1086 'set-first', 'set-for-each', 'set-implements/c', 'set-implements?', 

1087 'set-intersect', 'set-intersect!', 'set-map', 'set-mcar!', 'set-mcdr!', 

1088 'set-member?', 'set-mutable?', 'set-phantom-bytes!', 

1089 'set-port-next-location!', 'set-remove', 'set-remove!', 'set-rest', 

1090 'set-some-basic-contracts!', 'set-subtract', 'set-subtract!', 

1091 'set-symmetric-difference', 'set-symmetric-difference!', 'set-union', 

1092 'set-union!', 'set-weak?', 'set/c', 'set=?', 'set?', 'seteq', 'seteqv', 

1093 'seventh', 'sgn', 'shared-bytes', 'shell-execute', 'shrink-path-wrt', 

1094 'shuffle', 'simple-form-path', 'simplify-path', 'sin', 

1095 'single-flonum?', 'sinh', 'sixth', 'skip-projection-wrapper?', 'sleep', 

1096 'some-system-path->string', 'sort', 'special-comment-value', 

1097 'special-comment?', 'special-filter-input-port', 'split-at', 

1098 'split-at-right', 'split-common-prefix', 'split-path', 'splitf-at', 

1099 'splitf-at-right', 'sqr', 'sqrt', 'srcloc', 'srcloc->string', 

1100 'srcloc-column', 'srcloc-line', 'srcloc-position', 'srcloc-source', 

1101 'srcloc-span', 'srcloc?', 'stop-after', 'stop-before', 'stream->list', 

1102 'stream-add-between', 'stream-andmap', 'stream-append', 'stream-count', 

1103 'stream-empty?', 'stream-filter', 'stream-first', 'stream-fold', 

1104 'stream-for-each', 'stream-length', 'stream-map', 'stream-ormap', 

1105 'stream-ref', 'stream-rest', 'stream-tail', 'stream/c', 'stream?', 

1106 'string', 'string->bytes/latin-1', 'string->bytes/locale', 

1107 'string->bytes/utf-8', 'string->immutable-string', 'string->keyword', 

1108 'string->list', 'string->number', 'string->path', 

1109 'string->path-element', 'string->some-system-path', 'string->symbol', 

1110 'string->uninterned-symbol', 'string->unreadable-symbol', 

1111 'string-append', 'string-append*', 'string-ci<=?', 'string-ci<?', 

1112 'string-ci=?', 'string-ci>=?', 'string-ci>?', 'string-contains?', 

1113 'string-copy', 'string-copy!', 'string-downcase', 

1114 'string-environment-variable-name?', 'string-fill!', 'string-foldcase', 

1115 'string-join', 'string-len/c', 'string-length', 'string-locale-ci<?', 

1116 'string-locale-ci=?', 'string-locale-ci>?', 'string-locale-downcase', 

1117 'string-locale-upcase', 'string-locale<?', 'string-locale=?', 

1118 'string-locale>?', 'string-no-nuls?', 'string-normalize-nfc', 

1119 'string-normalize-nfd', 'string-normalize-nfkc', 

1120 'string-normalize-nfkd', 'string-normalize-spaces', 'string-port?', 

1121 'string-prefix?', 'string-ref', 'string-replace', 'string-set!', 

1122 'string-split', 'string-suffix?', 'string-titlecase', 'string-trim', 

1123 'string-upcase', 'string-utf-8-length', 'string<=?', 'string<?', 

1124 'string=?', 'string>=?', 'string>?', 'string?', 'struct->vector', 

1125 'struct-accessor-procedure?', 'struct-constructor-procedure?', 

1126 'struct-info', 'struct-mutator-procedure?', 

1127 'struct-predicate-procedure?', 'struct-type-info', 

1128 'struct-type-make-constructor', 'struct-type-make-predicate', 

1129 'struct-type-property-accessor-procedure?', 'struct-type-property/c', 

1130 'struct-type-property?', 'struct-type?', 'struct:arity-at-least', 

1131 'struct:arrow-contract-info', 'struct:date', 'struct:date*', 

1132 'struct:exn', 'struct:exn:break', 'struct:exn:break:hang-up', 

1133 'struct:exn:break:terminate', 'struct:exn:fail', 

1134 'struct:exn:fail:contract', 'struct:exn:fail:contract:arity', 

1135 'struct:exn:fail:contract:blame', 

1136 'struct:exn:fail:contract:continuation', 

1137 'struct:exn:fail:contract:divide-by-zero', 

1138 'struct:exn:fail:contract:non-fixnum-result', 

1139 'struct:exn:fail:contract:variable', 'struct:exn:fail:filesystem', 

1140 'struct:exn:fail:filesystem:errno', 

1141 'struct:exn:fail:filesystem:exists', 

1142 'struct:exn:fail:filesystem:missing-module', 

1143 'struct:exn:fail:filesystem:version', 'struct:exn:fail:network', 

1144 'struct:exn:fail:network:errno', 'struct:exn:fail:object', 

1145 'struct:exn:fail:out-of-memory', 'struct:exn:fail:read', 

1146 'struct:exn:fail:read:eof', 'struct:exn:fail:read:non-char', 

1147 'struct:exn:fail:syntax', 'struct:exn:fail:syntax:missing-module', 

1148 'struct:exn:fail:syntax:unbound', 'struct:exn:fail:unsupported', 

1149 'struct:exn:fail:user', 'struct:srcloc', 

1150 'struct:wrapped-extra-arg-arrow', 'struct?', 'sub1', 'subbytes', 

1151 'subclass?', 'subclass?/c', 'subprocess', 'subprocess-group-enabled', 

1152 'subprocess-kill', 'subprocess-pid', 'subprocess-status', 

1153 'subprocess-wait', 'subprocess?', 'subset?', 'substring', 'suggest/c', 

1154 'symbol->string', 'symbol-interned?', 'symbol-unreadable?', 'symbol<?', 

1155 'symbol=?', 'symbol?', 'symbols', 'sync', 'sync/enable-break', 

1156 'sync/timeout', 'sync/timeout/enable-break', 'syntax->datum', 

1157 'syntax->list', 'syntax-arm', 'syntax-column', 'syntax-debug-info', 

1158 'syntax-disarm', 'syntax-e', 'syntax-line', 

1159 'syntax-local-bind-syntaxes', 'syntax-local-certifier', 

1160 'syntax-local-context', 'syntax-local-expand-expression', 

1161 'syntax-local-get-shadower', 'syntax-local-identifier-as-binding', 

1162 'syntax-local-introduce', 'syntax-local-lift-context', 

1163 'syntax-local-lift-expression', 'syntax-local-lift-module', 

1164 'syntax-local-lift-module-end-declaration', 

1165 'syntax-local-lift-provide', 'syntax-local-lift-require', 

1166 'syntax-local-lift-values-expression', 

1167 'syntax-local-make-definition-context', 

1168 'syntax-local-make-delta-introducer', 

1169 'syntax-local-module-defined-identifiers', 

1170 'syntax-local-module-exports', 

1171 'syntax-local-module-required-identifiers', 'syntax-local-name', 

1172 'syntax-local-phase-level', 'syntax-local-submodules', 

1173 'syntax-local-transforming-module-provides?', 'syntax-local-value', 

1174 'syntax-local-value/immediate', 'syntax-original?', 'syntax-position', 

1175 'syntax-property', 'syntax-property-preserved?', 

1176 'syntax-property-symbol-keys', 'syntax-protect', 'syntax-rearm', 

1177 'syntax-recertify', 'syntax-shift-phase-level', 'syntax-source', 

1178 'syntax-source-module', 'syntax-span', 'syntax-taint', 

1179 'syntax-tainted?', 'syntax-track-origin', 

1180 'syntax-transforming-module-expression?', 

1181 'syntax-transforming-with-lifts?', 'syntax-transforming?', 'syntax/c', 

1182 'syntax?', 'system', 'system*', 'system*/exit-code', 

1183 'system-big-endian?', 'system-idle-evt', 'system-language+country', 

1184 'system-library-subpath', 'system-path-convention-type', 'system-type', 

1185 'system/exit-code', 'tail-marks-match?', 'take', 'take-common-prefix', 

1186 'take-right', 'takef', 'takef-right', 'tan', 'tanh', 

1187 'tcp-abandon-port', 'tcp-accept', 'tcp-accept-evt', 

1188 'tcp-accept-ready?', 'tcp-accept/enable-break', 'tcp-addresses', 

1189 'tcp-close', 'tcp-connect', 'tcp-connect/enable-break', 'tcp-listen', 

1190 'tcp-listener?', 'tcp-port?', 'tentative-pretty-print-port-cancel', 

1191 'tentative-pretty-print-port-transfer', 'tenth', 'terminal-port?', 

1192 'the-unsupplied-arg', 'third', 'thread', 'thread-cell-ref', 

1193 'thread-cell-set!', 'thread-cell-values?', 'thread-cell?', 

1194 'thread-dead-evt', 'thread-dead?', 'thread-group?', 'thread-receive', 

1195 'thread-receive-evt', 'thread-resume', 'thread-resume-evt', 

1196 'thread-rewind-receive', 'thread-running?', 'thread-send', 

1197 'thread-suspend', 'thread-suspend-evt', 'thread-try-receive', 

1198 'thread-wait', 'thread/suspend-to-kill', 'thread?', 'time-apply', 

1199 'touch', 'transplant-input-port', 'transplant-output-port', 'true', 

1200 'truncate', 'udp-addresses', 'udp-bind!', 'udp-bound?', 'udp-close', 

1201 'udp-connect!', 'udp-connected?', 'udp-multicast-interface', 

1202 'udp-multicast-join-group!', 'udp-multicast-leave-group!', 

1203 'udp-multicast-loopback?', 'udp-multicast-set-interface!', 

1204 'udp-multicast-set-loopback!', 'udp-multicast-set-ttl!', 

1205 'udp-multicast-ttl', 'udp-open-socket', 'udp-receive!', 

1206 'udp-receive!*', 'udp-receive!-evt', 'udp-receive!/enable-break', 

1207 'udp-receive-ready-evt', 'udp-send', 'udp-send*', 'udp-send-evt', 

1208 'udp-send-ready-evt', 'udp-send-to', 'udp-send-to*', 'udp-send-to-evt', 

1209 'udp-send-to/enable-break', 'udp-send/enable-break', 'udp?', 'unbox', 

1210 'uncaught-exception-handler', 'unit?', 'unspecified-dom', 

1211 'unsupplied-arg?', 'use-collection-link-paths', 

1212 'use-compiled-file-paths', 'use-user-specific-search-paths', 

1213 'user-execute-bit', 'user-read-bit', 'user-write-bit', 'value-blame', 

1214 'value-contract', 'values', 'variable-reference->empty-namespace', 

1215 'variable-reference->module-base-phase', 

1216 'variable-reference->module-declaration-inspector', 

1217 'variable-reference->module-path-index', 

1218 'variable-reference->module-source', 'variable-reference->namespace', 

1219 'variable-reference->phase', 

1220 'variable-reference->resolved-module-path', 

1221 'variable-reference-constant?', 'variable-reference?', 'vector', 

1222 'vector->immutable-vector', 'vector->list', 

1223 'vector->pseudo-random-generator', 'vector->pseudo-random-generator!', 

1224 'vector->values', 'vector-append', 'vector-argmax', 'vector-argmin', 

1225 'vector-copy', 'vector-copy!', 'vector-count', 'vector-drop', 

1226 'vector-drop-right', 'vector-fill!', 'vector-filter', 

1227 'vector-filter-not', 'vector-immutable', 'vector-immutable/c', 

1228 'vector-immutableof', 'vector-length', 'vector-map', 'vector-map!', 

1229 'vector-member', 'vector-memq', 'vector-memv', 'vector-ref', 

1230 'vector-set!', 'vector-set*!', 'vector-set-performance-stats!', 

1231 'vector-split-at', 'vector-split-at-right', 'vector-take', 

1232 'vector-take-right', 'vector/c', 'vector?', 'vectorof', 'version', 

1233 'void', 'void?', 'weak-box-value', 'weak-box?', 'weak-set', 

1234 'weak-seteq', 'weak-seteqv', 'will-execute', 'will-executor?', 

1235 'will-register', 'will-try-execute', 'with-input-from-bytes', 

1236 'with-input-from-file', 'with-input-from-string', 

1237 'with-output-to-bytes', 'with-output-to-file', 'with-output-to-string', 

1238 'would-be-future', 'wrap-evt', 'wrapped-extra-arg-arrow', 

1239 'wrapped-extra-arg-arrow-extra-neg-party-argument', 

1240 'wrapped-extra-arg-arrow-real-func', 'wrapped-extra-arg-arrow?', 

1241 'writable<%>', 'write', 'write-byte', 'write-bytes', 

1242 'write-bytes-avail', 'write-bytes-avail*', 'write-bytes-avail-evt', 

1243 'write-bytes-avail/enable-break', 'write-char', 'write-special', 

1244 'write-special-avail*', 'write-special-evt', 'write-string', 

1245 'write-to-file', 'writeln', 'xor', 'zero?', '~.a', '~.s', '~.v', '~a', 

1246 '~e', '~r', '~s', '~v' 

1247 ) 

1248 

1249 _opening_parenthesis = r'[([{]' 

1250 _closing_parenthesis = r'[)\]}]' 

1251 _delimiters = r'()[\]{}",\'`;\s' 

1252 _symbol = r'(?:\|[^|]*\||\\[\w\W]|[^|\\%s]+)+' % _delimiters 

1253 _exact_decimal_prefix = r'(?:#e)?(?:#d)?(?:#e)?' 

1254 _exponent = r'(?:[defls][-+]?\d+)' 

1255 _inexact_simple_no_hashes = r'(?:\d+(?:/\d+|\.\d*)?|\.\d+)' 

1256 _inexact_simple = (r'(?:%s|(?:\d+#+(?:\.#*|/\d+#*)?|\.\d+#+|' 

1257 r'\d+(?:\.\d*#+|/\d+#+)))' % _inexact_simple_no_hashes) 

1258 _inexact_normal_no_hashes = r'(?:%s%s?)' % (_inexact_simple_no_hashes, 

1259 _exponent) 

1260 _inexact_normal = r'(?:%s%s?)' % (_inexact_simple, _exponent) 

1261 _inexact_special = r'(?:(?:inf|nan)\.[0f])' 

1262 _inexact_real = r'(?:[-+]?%s|[-+]%s)' % (_inexact_normal, 

1263 _inexact_special) 

1264 _inexact_unsigned = r'(?:%s|%s)' % (_inexact_normal, _inexact_special) 

1265 

1266 tokens = { 

1267 'root': [ 

1268 (_closing_parenthesis, Error), 

1269 (r'(?!\Z)', Text, 'unquoted-datum') 

1270 ], 

1271 'datum': [ 

1272 (r'(?s)#;|#![ /]([^\\\n]|\\.)*', Comment), 

1273 (r';[^\n\r\x85\u2028\u2029]*', Comment.Single), 

1274 (r'#\|', Comment.Multiline, 'block-comment'), 

1275 

1276 # Whitespaces 

1277 (r'(?u)\s+', Text), 

1278 

1279 # Numbers: Keep in mind Racket reader hash prefixes, which 

1280 # can denote the base or the type. These don't map neatly 

1281 # onto Pygments token types; some judgment calls here. 

1282 

1283 # #d or no prefix 

1284 (r'(?i)%s[-+]?\d+(?=[%s])' % (_exact_decimal_prefix, _delimiters), 

1285 Number.Integer, '#pop'), 

1286 (r'(?i)%s[-+]?(\d+(\.\d*)?|\.\d+)([deflst][-+]?\d+)?(?=[%s])' % 

1287 (_exact_decimal_prefix, _delimiters), Number.Float, '#pop'), 

1288 (r'(?i)%s[-+]?(%s([-+]%s?i)?|[-+]%s?i)(?=[%s])' % 

1289 (_exact_decimal_prefix, _inexact_normal_no_hashes, 

1290 _inexact_normal_no_hashes, _inexact_normal_no_hashes, 

1291 _delimiters), Number, '#pop'), 

1292 

1293 # Inexact without explicit #i 

1294 (r'(?i)(#d)?(%s([-+]%s?i)?|[-+]%s?i|%s@%s)(?=[%s])' % 

1295 (_inexact_real, _inexact_unsigned, _inexact_unsigned, 

1296 _inexact_real, _inexact_real, _delimiters), Number.Float, 

1297 '#pop'), 

1298 

1299 # The remaining extflonums 

1300 (r'(?i)(([-+]?%st[-+]?\d+)|[-+](inf|nan)\.t)(?=[%s])' % 

1301 (_inexact_simple, _delimiters), Number.Float, '#pop'), 

1302 

1303 # #b 

1304 (r'(?iu)(#[ei])?#b%s' % _symbol, Number.Bin, '#pop'), 

1305 

1306 # #o 

1307 (r'(?iu)(#[ei])?#o%s' % _symbol, Number.Oct, '#pop'), 

1308 

1309 # #x 

1310 (r'(?iu)(#[ei])?#x%s' % _symbol, Number.Hex, '#pop'), 

1311 

1312 # #i is always inexact, i.e. float 

1313 (r'(?iu)(#d)?#i%s' % _symbol, Number.Float, '#pop'), 

1314 

1315 # Strings and characters 

1316 (r'#?"', String.Double, ('#pop', 'string')), 

1317 (r'#<<(.+)\n(^(?!\1$).*$\n)*^\1$', String.Heredoc, '#pop'), 

1318 (r'#\\(u[\da-fA-F]{1,4}|U[\da-fA-F]{1,8})', String.Char, '#pop'), 

1319 (r'(?is)#\\([0-7]{3}|[a-z]+|.)', String.Char, '#pop'), 

1320 (r'(?s)#[pr]x#?"(\\?.)*?"', String.Regex, '#pop'), 

1321 

1322 # Constants 

1323 (r'#(true|false|[tTfF])', Name.Constant, '#pop'), 

1324 

1325 # Keyword argument names (e.g. #:keyword) 

1326 (r'(?u)#:%s' % _symbol, Keyword.Declaration, '#pop'), 

1327 

1328 # Reader extensions 

1329 (r'(#lang |#!)(\S+)', 

1330 bygroups(Keyword.Namespace, Name.Namespace)), 

1331 (r'#reader', Keyword.Namespace, 'quoted-datum'), 

1332 

1333 # Other syntax 

1334 (r"(?i)\.(?=[%s])|#c[is]|#['`]|#,@?" % _delimiters, Operator), 

1335 (r"'|#[s&]|#hash(eqv?)?|#\d*(?=%s)" % _opening_parenthesis, 

1336 Operator, ('#pop', 'quoted-datum')) 

1337 ], 

1338 'datum*': [ 

1339 (r'`|,@?', Operator), 

1340 (_symbol, String.Symbol, '#pop'), 

1341 (r'[|\\]', Error), 

1342 default('#pop') 

1343 ], 

1344 'list': [ 

1345 (_closing_parenthesis, Punctuation, '#pop') 

1346 ], 

1347 'unquoted-datum': [ 

1348 include('datum'), 

1349 (r'quote(?=[%s])' % _delimiters, Keyword, 

1350 ('#pop', 'quoted-datum')), 

1351 (r'`', Operator, ('#pop', 'quasiquoted-datum')), 

1352 (r'quasiquote(?=[%s])' % _delimiters, Keyword, 

1353 ('#pop', 'quasiquoted-datum')), 

1354 (_opening_parenthesis, Punctuation, ('#pop', 'unquoted-list')), 

1355 (words(_keywords, prefix='(?u)', suffix='(?=[%s])' % _delimiters), 

1356 Keyword, '#pop'), 

1357 (words(_builtins, prefix='(?u)', suffix='(?=[%s])' % _delimiters), 

1358 Name.Builtin, '#pop'), 

1359 (_symbol, Name, '#pop'), 

1360 include('datum*') 

1361 ], 

1362 'unquoted-list': [ 

1363 include('list'), 

1364 (r'(?!\Z)', Text, 'unquoted-datum') 

1365 ], 

1366 'quasiquoted-datum': [ 

1367 include('datum'), 

1368 (r',@?', Operator, ('#pop', 'unquoted-datum')), 

1369 (r'unquote(-splicing)?(?=[%s])' % _delimiters, Keyword, 

1370 ('#pop', 'unquoted-datum')), 

1371 (_opening_parenthesis, Punctuation, ('#pop', 'quasiquoted-list')), 

1372 include('datum*') 

1373 ], 

1374 'quasiquoted-list': [ 

1375 include('list'), 

1376 (r'(?!\Z)', Text, 'quasiquoted-datum') 

1377 ], 

1378 'quoted-datum': [ 

1379 include('datum'), 

1380 (_opening_parenthesis, Punctuation, ('#pop', 'quoted-list')), 

1381 include('datum*') 

1382 ], 

1383 'quoted-list': [ 

1384 include('list'), 

1385 (r'(?!\Z)', Text, 'quoted-datum') 

1386 ], 

1387 'block-comment': [ 

1388 (r'#\|', Comment.Multiline, '#push'), 

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

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

1391 ], 

1392 'string': [ 

1393 (r'"', String.Double, '#pop'), 

1394 (r'(?s)\\([0-7]{1,3}|x[\da-fA-F]{1,2}|u[\da-fA-F]{1,4}|' 

1395 r'U[\da-fA-F]{1,8}|.)', String.Escape), 

1396 (r'[^\\"]+', String.Double) 

1397 ] 

1398 } 

1399 

1400 

1401class NewLispLexer(RegexLexer): 

1402 """ 

1403 For `newLISP. <http://www.newlisp.org/>`_ source code (version 10.3.0). 

1404 

1405 .. versionadded:: 1.5 

1406 """ 

1407 

1408 name = 'NewLisp' 

1409 aliases = ['newlisp'] 

1410 filenames = ['*.lsp', '*.nl', '*.kif'] 

1411 mimetypes = ['text/x-newlisp', 'application/x-newlisp'] 

1412 

1413 flags = re.IGNORECASE | re.MULTILINE | re.UNICODE 

1414 

1415 # list of built-in functions for newLISP version 10.3 

1416 builtins = ( 

1417 '^', '--', '-', ':', '!', '!=', '?', '@', '*', '/', '&', '%', '+', '++', 

1418 '<', '<<', '<=', '=', '>', '>=', '>>', '|', '~', '$', '$0', '$1', '$10', 

1419 '$11', '$12', '$13', '$14', '$15', '$2', '$3', '$4', '$5', '$6', '$7', 

1420 '$8', '$9', '$args', '$idx', '$it', '$main-args', 'abort', 'abs', 

1421 'acos', 'acosh', 'add', 'address', 'amb', 'and', 'append-file', 

1422 'append', 'apply', 'args', 'array-list', 'array?', 'array', 'asin', 

1423 'asinh', 'assoc', 'atan', 'atan2', 'atanh', 'atom?', 'base64-dec', 

1424 'base64-enc', 'bayes-query', 'bayes-train', 'begin', 

1425 'beta', 'betai', 'bind', 'binomial', 'bits', 'callback', 

1426 'case', 'catch', 'ceil', 'change-dir', 'char', 'chop', 'Class', 'clean', 

1427 'close', 'command-event', 'cond', 'cons', 'constant', 

1428 'context?', 'context', 'copy-file', 'copy', 'cos', 'cosh', 'count', 

1429 'cpymem', 'crc32', 'crit-chi2', 'crit-z', 'current-line', 'curry', 

1430 'date-list', 'date-parse', 'date-value', 'date', 'debug', 'dec', 

1431 'def-new', 'default', 'define-macro', 'define', 

1432 'delete-file', 'delete-url', 'delete', 'destroy', 'det', 'device', 

1433 'difference', 'directory?', 'directory', 'div', 'do-until', 'do-while', 

1434 'doargs', 'dolist', 'dostring', 'dotimes', 'dotree', 'dump', 'dup', 

1435 'empty?', 'encrypt', 'ends-with', 'env', 'erf', 'error-event', 

1436 'eval-string', 'eval', 'exec', 'exists', 'exit', 'exp', 'expand', 

1437 'explode', 'extend', 'factor', 'fft', 'file-info', 'file?', 'filter', 

1438 'find-all', 'find', 'first', 'flat', 'float?', 'float', 'floor', 'flt', 

1439 'fn', 'for-all', 'for', 'fork', 'format', 'fv', 'gammai', 'gammaln', 

1440 'gcd', 'get-char', 'get-float', 'get-int', 'get-long', 'get-string', 

1441 'get-url', 'global?', 'global', 'if-not', 'if', 'ifft', 'import', 'inc', 

1442 'index', 'inf?', 'int', 'integer?', 'integer', 'intersect', 'invert', 

1443 'irr', 'join', 'lambda-macro', 'lambda?', 'lambda', 'last-error', 

1444 'last', 'legal?', 'length', 'let', 'letex', 'letn', 

1445 'list?', 'list', 'load', 'local', 'log', 'lookup', 

1446 'lower-case', 'macro?', 'main-args', 'MAIN', 'make-dir', 'map', 'mat', 

1447 'match', 'max', 'member', 'min', 'mod', 'module', 'mul', 'multiply', 

1448 'NaN?', 'net-accept', 'net-close', 'net-connect', 'net-error', 

1449 'net-eval', 'net-interface', 'net-ipv', 'net-listen', 'net-local', 

1450 'net-lookup', 'net-packet', 'net-peek', 'net-peer', 'net-ping', 

1451 'net-receive-from', 'net-receive-udp', 'net-receive', 'net-select', 

1452 'net-send-to', 'net-send-udp', 'net-send', 'net-service', 

1453 'net-sessions', 'new', 'nil?', 'nil', 'normal', 'not', 'now', 'nper', 

1454 'npv', 'nth', 'null?', 'number?', 'open', 'or', 'ostype', 'pack', 

1455 'parse-date', 'parse', 'peek', 'pipe', 'pmt', 'pop-assoc', 'pop', 

1456 'post-url', 'pow', 'prefix', 'pretty-print', 'primitive?', 'print', 

1457 'println', 'prob-chi2', 'prob-z', 'process', 'prompt-event', 

1458 'protected?', 'push', 'put-url', 'pv', 'quote?', 'quote', 'rand', 

1459 'random', 'randomize', 'read', 'read-char', 'read-expr', 'read-file', 

1460 'read-key', 'read-line', 'read-utf8', 'reader-event', 

1461 'real-path', 'receive', 'ref-all', 'ref', 'regex-comp', 'regex', 

1462 'remove-dir', 'rename-file', 'replace', 'reset', 'rest', 'reverse', 

1463 'rotate', 'round', 'save', 'search', 'seed', 'seek', 'select', 'self', 

1464 'semaphore', 'send', 'sequence', 'series', 'set-locale', 'set-ref-all', 

1465 'set-ref', 'set', 'setf', 'setq', 'sgn', 'share', 'signal', 'silent', 

1466 'sin', 'sinh', 'sleep', 'slice', 'sort', 'source', 'spawn', 'sqrt', 

1467 'starts-with', 'string?', 'string', 'sub', 'swap', 'sym', 'symbol?', 

1468 'symbols', 'sync', 'sys-error', 'sys-info', 'tan', 'tanh', 'term', 

1469 'throw-error', 'throw', 'time-of-day', 'time', 'timer', 'title-case', 

1470 'trace-highlight', 'trace', 'transpose', 'Tree', 'trim', 'true?', 

1471 'true', 'unicode', 'unify', 'unique', 'unless', 'unpack', 'until', 

1472 'upper-case', 'utf8', 'utf8len', 'uuid', 'wait-pid', 'when', 'while', 

1473 'write', 'write-char', 'write-file', 'write-line', 

1474 'xfer-event', 'xml-error', 'xml-parse', 'xml-type-tags', 'zero?', 

1475 ) 

1476 

1477 # valid names 

1478 valid_name = r'([\w!$%&*+.,/<=>?@^~|-])+|(\[.*?\])+' 

1479 

1480 tokens = { 

1481 'root': [ 

1482 # shebang 

1483 (r'#!(.*?)$', Comment.Preproc), 

1484 # comments starting with semicolon 

1485 (r';.*$', Comment.Single), 

1486 # comments starting with # 

1487 (r'#.*$', Comment.Single), 

1488 

1489 # whitespace 

1490 (r'\s+', Text), 

1491 

1492 # strings, symbols and characters 

1493 (r'"(\\\\|\\[^\\]|[^"\\])*"', String), 

1494 

1495 # braces 

1496 (r'\{', String, "bracestring"), 

1497 

1498 # [text] ... [/text] delimited strings 

1499 (r'\[text\]*', String, "tagstring"), 

1500 

1501 # 'special' operators... 

1502 (r"('|:)", Operator), 

1503 

1504 # highlight the builtins 

1505 (words(builtins, suffix=r'\b'), 

1506 Keyword), 

1507 

1508 # the remaining functions 

1509 (r'(?<=\()' + valid_name, Name.Variable), 

1510 

1511 # the remaining variables 

1512 (valid_name, String.Symbol), 

1513 

1514 # parentheses 

1515 (r'(\(|\))', Punctuation), 

1516 ], 

1517 

1518 # braced strings... 

1519 'bracestring': [ 

1520 (r'\{', String, "#push"), 

1521 (r'\}', String, "#pop"), 

1522 ('[^{}]+', String), 

1523 ], 

1524 

1525 # tagged [text]...[/text] delimited strings... 

1526 'tagstring': [ 

1527 (r'(?s)(.*?)(\[/text\])', String, '#pop'), 

1528 ], 

1529 } 

1530 

1531 

1532class EmacsLispLexer(RegexLexer): 

1533 """ 

1534 An ELisp lexer, parsing a stream and outputting the tokens 

1535 needed to highlight elisp code. 

1536 

1537 .. versionadded:: 2.1 

1538 """ 

1539 name = 'EmacsLisp' 

1540 aliases = ['emacs', 'elisp', 'emacs-lisp'] 

1541 filenames = ['*.el'] 

1542 mimetypes = ['text/x-elisp', 'application/x-elisp'] 

1543 

1544 flags = re.MULTILINE 

1545 

1546 # couple of useful regexes 

1547 

1548 # characters that are not macro-characters and can be used to begin a symbol 

1549 nonmacro = r'\\.|[\w!$%&*+-/<=>?@^{}~|]' 

1550 constituent = nonmacro + '|[#.:]' 

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

1552 

1553 # symbol token, reverse-engineered from hyperspec 

1554 # Take a deep breath... 

1555 symbol = r'((?:%s)(?:%s)*)' % (nonmacro, constituent) 

1556 

1557 macros = { 

1558 'atomic-change-group', 'case', 'block', 'cl-block', 'cl-callf', 'cl-callf2', 

1559 'cl-case', 'cl-decf', 'cl-declaim', 'cl-declare', 

1560 'cl-define-compiler-macro', 'cl-defmacro', 'cl-defstruct', 

1561 'cl-defsubst', 'cl-deftype', 'cl-defun', 'cl-destructuring-bind', 

1562 'cl-do', 'cl-do*', 'cl-do-all-symbols', 'cl-do-symbols', 'cl-dolist', 

1563 'cl-dotimes', 'cl-ecase', 'cl-etypecase', 'eval-when', 'cl-eval-when', 'cl-flet', 

1564 'cl-flet*', 'cl-function', 'cl-incf', 'cl-labels', 'cl-letf', 

1565 'cl-letf*', 'cl-load-time-value', 'cl-locally', 'cl-loop', 

1566 'cl-macrolet', 'cl-multiple-value-bind', 'cl-multiple-value-setq', 

1567 'cl-progv', 'cl-psetf', 'cl-psetq', 'cl-pushnew', 'cl-remf', 

1568 'cl-return', 'cl-return-from', 'cl-rotatef', 'cl-shiftf', 

1569 'cl-symbol-macrolet', 'cl-tagbody', 'cl-the', 'cl-typecase', 

1570 'combine-after-change-calls', 'condition-case-unless-debug', 'decf', 

1571 'declaim', 'declare', 'declare-function', 'def-edebug-spec', 

1572 'defadvice', 'defclass', 'defcustom', 'defface', 'defgeneric', 

1573 'defgroup', 'define-advice', 'define-alternatives', 

1574 'define-compiler-macro', 'define-derived-mode', 'define-generic-mode', 

1575 'define-global-minor-mode', 'define-globalized-minor-mode', 

1576 'define-minor-mode', 'define-modify-macro', 

1577 'define-obsolete-face-alias', 'define-obsolete-function-alias', 

1578 'define-obsolete-variable-alias', 'define-setf-expander', 

1579 'define-skeleton', 'defmacro', 'defmethod', 'defsetf', 'defstruct', 

1580 'defsubst', 'deftheme', 'deftype', 'defun', 'defvar-local', 

1581 'delay-mode-hooks', 'destructuring-bind', 'do', 'do*', 

1582 'do-all-symbols', 'do-symbols', 'dolist', 'dont-compile', 'dotimes', 

1583 'dotimes-with-progress-reporter', 'ecase', 'ert-deftest', 'etypecase', 

1584 'eval-and-compile', 'eval-when-compile', 'flet', 'ignore-errors', 

1585 'incf', 'labels', 'lambda', 'letrec', 'lexical-let', 'lexical-let*', 

1586 'loop', 'multiple-value-bind', 'multiple-value-setq', 'noreturn', 

1587 'oref', 'oref-default', 'oset', 'oset-default', 'pcase', 

1588 'pcase-defmacro', 'pcase-dolist', 'pcase-exhaustive', 'pcase-let', 

1589 'pcase-let*', 'pop', 'psetf', 'psetq', 'push', 'pushnew', 'remf', 

1590 'return', 'rotatef', 'rx', 'save-match-data', 'save-selected-window', 

1591 'save-window-excursion', 'setf', 'setq-local', 'shiftf', 

1592 'track-mouse', 'typecase', 'unless', 'use-package', 'when', 

1593 'while-no-input', 'with-case-table', 'with-category-table', 

1594 'with-coding-priority', 'with-current-buffer', 'with-demoted-errors', 

1595 'with-eval-after-load', 'with-file-modes', 'with-local-quit', 

1596 'with-output-to-string', 'with-output-to-temp-buffer', 

1597 'with-parsed-tramp-file-name', 'with-selected-frame', 

1598 'with-selected-window', 'with-silent-modifications', 'with-slots', 

1599 'with-syntax-table', 'with-temp-buffer', 'with-temp-file', 

1600 'with-temp-message', 'with-timeout', 'with-tramp-connection-property', 

1601 'with-tramp-file-property', 'with-tramp-progress-reporter', 

1602 'with-wrapper-hook', 'load-time-value', 'locally', 'macrolet', 'progv', 

1603 'return-from', 

1604 } 

1605 

1606 special_forms = { 

1607 'and', 'catch', 'cond', 'condition-case', 'defconst', 'defvar', 

1608 'function', 'if', 'interactive', 'let', 'let*', 'or', 'prog1', 

1609 'prog2', 'progn', 'quote', 'save-current-buffer', 'save-excursion', 

1610 'save-restriction', 'setq', 'setq-default', 'subr-arity', 

1611 'unwind-protect', 'while', 

1612 } 

1613 

1614 builtin_function = { 

1615 '%', '*', '+', '-', '/', '/=', '1+', '1-', '<', '<=', '=', '>', '>=', 

1616 'Snarf-documentation', 'abort-recursive-edit', 'abs', 

1617 'accept-process-output', 'access-file', 'accessible-keymaps', 'acos', 

1618 'active-minibuffer-window', 'add-face-text-property', 

1619 'add-name-to-file', 'add-text-properties', 'all-completions', 

1620 'append', 'apply', 'apropos-internal', 'aref', 'arrayp', 'aset', 

1621 'ash', 'asin', 'assoc', 'assoc-string', 'assq', 'atan', 'atom', 

1622 'autoload', 'autoload-do-load', 'backtrace', 'backtrace--locals', 

1623 'backtrace-debug', 'backtrace-eval', 'backtrace-frame', 

1624 'backward-char', 'backward-prefix-chars', 'barf-if-buffer-read-only', 

1625 'base64-decode-region', 'base64-decode-string', 

1626 'base64-encode-region', 'base64-encode-string', 'beginning-of-line', 

1627 'bidi-find-overridden-directionality', 'bidi-resolved-levels', 

1628 'bitmap-spec-p', 'bobp', 'bolp', 'bool-vector', 

1629 'bool-vector-count-consecutive', 'bool-vector-count-population', 

1630 'bool-vector-exclusive-or', 'bool-vector-intersection', 

1631 'bool-vector-not', 'bool-vector-p', 'bool-vector-set-difference', 

1632 'bool-vector-subsetp', 'bool-vector-union', 'boundp', 

1633 'buffer-base-buffer', 'buffer-chars-modified-tick', 

1634 'buffer-enable-undo', 'buffer-file-name', 'buffer-has-markers-at', 

1635 'buffer-list', 'buffer-live-p', 'buffer-local-value', 

1636 'buffer-local-variables', 'buffer-modified-p', 'buffer-modified-tick', 

1637 'buffer-name', 'buffer-size', 'buffer-string', 'buffer-substring', 

1638 'buffer-substring-no-properties', 'buffer-swap-text', 'bufferp', 

1639 'bury-buffer-internal', 'byte-code', 'byte-code-function-p', 

1640 'byte-to-position', 'byte-to-string', 'byteorder', 

1641 'call-interactively', 'call-last-kbd-macro', 'call-process', 

1642 'call-process-region', 'cancel-kbd-macro-events', 'capitalize', 

1643 'capitalize-region', 'capitalize-word', 'car', 'car-less-than-car', 

1644 'car-safe', 'case-table-p', 'category-docstring', 

1645 'category-set-mnemonics', 'category-table', 'category-table-p', 

1646 'ccl-execute', 'ccl-execute-on-string', 'ccl-program-p', 'cdr', 

1647 'cdr-safe', 'ceiling', 'char-after', 'char-before', 

1648 'char-category-set', 'char-charset', 'char-equal', 'char-or-string-p', 

1649 'char-resolve-modifiers', 'char-syntax', 'char-table-extra-slot', 

1650 'char-table-p', 'char-table-parent', 'char-table-range', 

1651 'char-table-subtype', 'char-to-string', 'char-width', 'characterp', 

1652 'charset-after', 'charset-id-internal', 'charset-plist', 

1653 'charset-priority-list', 'charsetp', 'check-coding-system', 

1654 'check-coding-systems-region', 'clear-buffer-auto-save-failure', 

1655 'clear-charset-maps', 'clear-face-cache', 'clear-font-cache', 

1656 'clear-image-cache', 'clear-string', 'clear-this-command-keys', 

1657 'close-font', 'clrhash', 'coding-system-aliases', 

1658 'coding-system-base', 'coding-system-eol-type', 'coding-system-p', 

1659 'coding-system-plist', 'coding-system-priority-list', 

1660 'coding-system-put', 'color-distance', 'color-gray-p', 

1661 'color-supported-p', 'combine-after-change-execute', 

1662 'command-error-default-function', 'command-remapping', 'commandp', 

1663 'compare-buffer-substrings', 'compare-strings', 

1664 'compare-window-configurations', 'completing-read', 

1665 'compose-region-internal', 'compose-string-internal', 

1666 'composition-get-gstring', 'compute-motion', 'concat', 'cons', 

1667 'consp', 'constrain-to-field', 'continue-process', 

1668 'controlling-tty-p', 'coordinates-in-window-p', 'copy-alist', 

1669 'copy-category-table', 'copy-file', 'copy-hash-table', 'copy-keymap', 

1670 'copy-marker', 'copy-sequence', 'copy-syntax-table', 'copysign', 

1671 'cos', 'current-active-maps', 'current-bidi-paragraph-direction', 

1672 'current-buffer', 'current-case-table', 'current-column', 

1673 'current-global-map', 'current-idle-time', 'current-indentation', 

1674 'current-input-mode', 'current-local-map', 'current-message', 

1675 'current-minor-mode-maps', 'current-time', 'current-time-string', 

1676 'current-time-zone', 'current-window-configuration', 

1677 'cygwin-convert-file-name-from-windows', 

1678 'cygwin-convert-file-name-to-windows', 'daemon-initialized', 

1679 'daemonp', 'dbus--init-bus', 'dbus-get-unique-name', 

1680 'dbus-message-internal', 'debug-timer-check', 'declare-equiv-charset', 

1681 'decode-big5-char', 'decode-char', 'decode-coding-region', 

1682 'decode-coding-string', 'decode-sjis-char', 'decode-time', 

1683 'default-boundp', 'default-file-modes', 'default-printer-name', 

1684 'default-toplevel-value', 'default-value', 'define-category', 

1685 'define-charset-alias', 'define-charset-internal', 

1686 'define-coding-system-alias', 'define-coding-system-internal', 

1687 'define-fringe-bitmap', 'define-hash-table-test', 'define-key', 

1688 'define-prefix-command', 'delete', 

1689 'delete-all-overlays', 'delete-and-extract-region', 'delete-char', 

1690 'delete-directory-internal', 'delete-field', 'delete-file', 

1691 'delete-frame', 'delete-other-windows-internal', 'delete-overlay', 

1692 'delete-process', 'delete-region', 'delete-terminal', 

1693 'delete-window-internal', 'delq', 'describe-buffer-bindings', 

1694 'describe-vector', 'destroy-fringe-bitmap', 'detect-coding-region', 

1695 'detect-coding-string', 'ding', 'directory-file-name', 

1696 'directory-files', 'directory-files-and-attributes', 'discard-input', 

1697 'display-supports-face-attributes-p', 'do-auto-save', 'documentation', 

1698 'documentation-property', 'downcase', 'downcase-region', 

1699 'downcase-word', 'draw-string', 'dump-colors', 'dump-emacs', 

1700 'dump-face', 'dump-frame-glyph-matrix', 'dump-glyph-matrix', 

1701 'dump-glyph-row', 'dump-redisplay-history', 'dump-tool-bar-row', 

1702 'elt', 'emacs-pid', 'encode-big5-char', 'encode-char', 

1703 'encode-coding-region', 'encode-coding-string', 'encode-sjis-char', 

1704 'encode-time', 'end-kbd-macro', 'end-of-line', 'eobp', 'eolp', 'eq', 

1705 'eql', 'equal', 'equal-including-properties', 'erase-buffer', 

1706 'error-message-string', 'eval', 'eval-buffer', 'eval-region', 

1707 'event-convert-list', 'execute-kbd-macro', 'exit-recursive-edit', 

1708 'exp', 'expand-file-name', 'expt', 'external-debugging-output', 

1709 'face-attribute-relative-p', 'face-attributes-as-vector', 'face-font', 

1710 'fboundp', 'fceiling', 'fetch-bytecode', 'ffloor', 

1711 'field-beginning', 'field-end', 'field-string', 

1712 'field-string-no-properties', 'file-accessible-directory-p', 

1713 'file-acl', 'file-attributes', 'file-attributes-lessp', 

1714 'file-directory-p', 'file-executable-p', 'file-exists-p', 

1715 'file-locked-p', 'file-modes', 'file-name-absolute-p', 

1716 'file-name-all-completions', 'file-name-as-directory', 

1717 'file-name-completion', 'file-name-directory', 

1718 'file-name-nondirectory', 'file-newer-than-file-p', 'file-readable-p', 

1719 'file-regular-p', 'file-selinux-context', 'file-symlink-p', 

1720 'file-system-info', 'file-system-info', 'file-writable-p', 

1721 'fillarray', 'find-charset-region', 'find-charset-string', 

1722 'find-coding-systems-region-internal', 'find-composition-internal', 

1723 'find-file-name-handler', 'find-font', 'find-operation-coding-system', 

1724 'float', 'float-time', 'floatp', 'floor', 'fmakunbound', 

1725 'following-char', 'font-at', 'font-drive-otf', 'font-face-attributes', 

1726 'font-family-list', 'font-get', 'font-get-glyphs', 

1727 'font-get-system-font', 'font-get-system-normal-font', 'font-info', 

1728 'font-match-p', 'font-otf-alternates', 'font-put', 

1729 'font-shape-gstring', 'font-spec', 'font-variation-glyphs', 

1730 'font-xlfd-name', 'fontp', 'fontset-font', 'fontset-info', 

1731 'fontset-list', 'fontset-list-all', 'force-mode-line-update', 

1732 'force-window-update', 'format', 'format-mode-line', 

1733 'format-network-address', 'format-time-string', 'forward-char', 

1734 'forward-comment', 'forward-line', 'forward-word', 

1735 'frame-border-width', 'frame-bottom-divider-width', 

1736 'frame-can-run-window-configuration-change-hook', 'frame-char-height', 

1737 'frame-char-width', 'frame-face-alist', 'frame-first-window', 

1738 'frame-focus', 'frame-font-cache', 'frame-fringe-width', 'frame-list', 

1739 'frame-live-p', 'frame-or-buffer-changed-p', 'frame-parameter', 

1740 'frame-parameters', 'frame-pixel-height', 'frame-pixel-width', 

1741 'frame-pointer-visible-p', 'frame-right-divider-width', 

1742 'frame-root-window', 'frame-scroll-bar-height', 

1743 'frame-scroll-bar-width', 'frame-selected-window', 'frame-terminal', 

1744 'frame-text-cols', 'frame-text-height', 'frame-text-lines', 

1745 'frame-text-width', 'frame-total-cols', 'frame-total-lines', 

1746 'frame-visible-p', 'framep', 'frexp', 'fringe-bitmaps-at-pos', 

1747 'fround', 'fset', 'ftruncate', 'funcall', 'funcall-interactively', 

1748 'function-equal', 'functionp', 'gap-position', 'gap-size', 

1749 'garbage-collect', 'gc-status', 'generate-new-buffer-name', 'get', 

1750 'get-buffer', 'get-buffer-create', 'get-buffer-process', 

1751 'get-buffer-window', 'get-byte', 'get-char-property', 

1752 'get-char-property-and-overlay', 'get-file-buffer', 'get-file-char', 

1753 'get-internal-run-time', 'get-load-suffixes', 'get-pos-property', 

1754 'get-process', 'get-screen-color', 'get-text-property', 

1755 'get-unicode-property-internal', 'get-unused-category', 

1756 'get-unused-iso-final-char', 'getenv-internal', 'gethash', 

1757 'gfile-add-watch', 'gfile-rm-watch', 'global-key-binding', 

1758 'gnutls-available-p', 'gnutls-boot', 'gnutls-bye', 'gnutls-deinit', 

1759 'gnutls-error-fatalp', 'gnutls-error-string', 'gnutls-errorp', 

1760 'gnutls-get-initstage', 'gnutls-peer-status', 

1761 'gnutls-peer-status-warning-describe', 'goto-char', 'gpm-mouse-start', 

1762 'gpm-mouse-stop', 'group-gid', 'group-real-gid', 

1763 'handle-save-session', 'handle-switch-frame', 'hash-table-count', 

1764 'hash-table-p', 'hash-table-rehash-size', 

1765 'hash-table-rehash-threshold', 'hash-table-size', 'hash-table-test', 

1766 'hash-table-weakness', 'iconify-frame', 'identity', 'image-flush', 

1767 'image-mask-p', 'image-metadata', 'image-size', 'imagemagick-types', 

1768 'imagep', 'indent-to', 'indirect-function', 'indirect-variable', 

1769 'init-image-library', 'inotify-add-watch', 'inotify-rm-watch', 

1770 'input-pending-p', 'insert', 'insert-and-inherit', 

1771 'insert-before-markers', 'insert-before-markers-and-inherit', 

1772 'insert-buffer-substring', 'insert-byte', 'insert-char', 

1773 'insert-file-contents', 'insert-startup-screen', 'int86', 

1774 'integer-or-marker-p', 'integerp', 'interactive-form', 'intern', 

1775 'intern-soft', 'internal--track-mouse', 'internal-char-font', 

1776 'internal-complete-buffer', 'internal-copy-lisp-face', 

1777 'internal-default-process-filter', 

1778 'internal-default-process-sentinel', 'internal-describe-syntax-value', 

1779 'internal-event-symbol-parse-modifiers', 

1780 'internal-face-x-get-resource', 'internal-get-lisp-face-attribute', 

1781 'internal-lisp-face-attribute-values', 'internal-lisp-face-empty-p', 

1782 'internal-lisp-face-equal-p', 'internal-lisp-face-p', 

1783 'internal-make-lisp-face', 'internal-make-var-non-special', 

1784 'internal-merge-in-global-face', 

1785 'internal-set-alternative-font-family-alist', 

1786 'internal-set-alternative-font-registry-alist', 

1787 'internal-set-font-selection-order', 

1788 'internal-set-lisp-face-attribute', 

1789 'internal-set-lisp-face-attribute-from-resource', 

1790 'internal-show-cursor', 'internal-show-cursor-p', 'interrupt-process', 

1791 'invisible-p', 'invocation-directory', 'invocation-name', 'isnan', 

1792 'iso-charset', 'key-binding', 'key-description', 

1793 'keyboard-coding-system', 'keymap-parent', 'keymap-prompt', 'keymapp', 

1794 'keywordp', 'kill-all-local-variables', 'kill-buffer', 'kill-emacs', 

1795 'kill-local-variable', 'kill-process', 'last-nonminibuffer-frame', 

1796 'lax-plist-get', 'lax-plist-put', 'ldexp', 'length', 

1797 'libxml-parse-html-region', 'libxml-parse-xml-region', 

1798 'line-beginning-position', 'line-end-position', 'line-pixel-height', 

1799 'list', 'list-fonts', 'list-system-processes', 'listp', 'load', 

1800 'load-average', 'local-key-binding', 'local-variable-if-set-p', 

1801 'local-variable-p', 'locale-info', 'locate-file-internal', 

1802 'lock-buffer', 'log', 'logand', 'logb', 'logior', 'lognot', 'logxor', 

1803 'looking-at', 'lookup-image', 'lookup-image-map', 'lookup-key', 

1804 'lower-frame', 'lsh', 'macroexpand', 'make-bool-vector', 

1805 'make-byte-code', 'make-category-set', 'make-category-table', 

1806 'make-char', 'make-char-table', 'make-directory-internal', 

1807 'make-frame-invisible', 'make-frame-visible', 'make-hash-table', 

1808 'make-indirect-buffer', 'make-keymap', 'make-list', 

1809 'make-local-variable', 'make-marker', 'make-network-process', 

1810 'make-overlay', 'make-serial-process', 'make-sparse-keymap', 

1811 'make-string', 'make-symbol', 'make-symbolic-link', 'make-temp-name', 

1812 'make-terminal-frame', 'make-variable-buffer-local', 

1813 'make-variable-frame-local', 'make-vector', 'makunbound', 

1814 'map-char-table', 'map-charset-chars', 'map-keymap', 

1815 'map-keymap-internal', 'mapatoms', 'mapc', 'mapcar', 'mapconcat', 

1816 'maphash', 'mark-marker', 'marker-buffer', 'marker-insertion-type', 

1817 'marker-position', 'markerp', 'match-beginning', 'match-data', 

1818 'match-end', 'matching-paren', 'max', 'max-char', 'md5', 'member', 

1819 'memory-info', 'memory-limit', 'memory-use-counts', 'memq', 'memql', 

1820 'menu-bar-menu-at-x-y', 'menu-or-popup-active-p', 

1821 'menu-or-popup-active-p', 'merge-face-attribute', 'message', 

1822 'message-box', 'message-or-box', 'min', 

1823 'minibuffer-completion-contents', 'minibuffer-contents', 

1824 'minibuffer-contents-no-properties', 'minibuffer-depth', 

1825 'minibuffer-prompt', 'minibuffer-prompt-end', 

1826 'minibuffer-selected-window', 'minibuffer-window', 'minibufferp', 

1827 'minor-mode-key-binding', 'mod', 'modify-category-entry', 

1828 'modify-frame-parameters', 'modify-syntax-entry', 

1829 'mouse-pixel-position', 'mouse-position', 'move-overlay', 

1830 'move-point-visually', 'move-to-column', 'move-to-window-line', 

1831 'msdos-downcase-filename', 'msdos-long-file-names', 'msdos-memget', 

1832 'msdos-memput', 'msdos-mouse-disable', 'msdos-mouse-enable', 

1833 'msdos-mouse-init', 'msdos-mouse-p', 'msdos-remember-default-colors', 

1834 'msdos-set-keyboard', 'msdos-set-mouse-buttons', 

1835 'multibyte-char-to-unibyte', 'multibyte-string-p', 'narrow-to-region', 

1836 'natnump', 'nconc', 'network-interface-info', 

1837 'network-interface-list', 'new-fontset', 'newline-cache-check', 

1838 'next-char-property-change', 'next-frame', 'next-overlay-change', 

1839 'next-property-change', 'next-read-file-uses-dialog-p', 

1840 'next-single-char-property-change', 'next-single-property-change', 

1841 'next-window', 'nlistp', 'nreverse', 'nth', 'nthcdr', 'null', 

1842 'number-or-marker-p', 'number-to-string', 'numberp', 

1843 'open-dribble-file', 'open-font', 'open-termscript', 

1844 'optimize-char-table', 'other-buffer', 'other-window-for-scrolling', 

1845 'overlay-buffer', 'overlay-end', 'overlay-get', 'overlay-lists', 

1846 'overlay-properties', 'overlay-put', 'overlay-recenter', 

1847 'overlay-start', 'overlayp', 'overlays-at', 'overlays-in', 

1848 'parse-partial-sexp', 'play-sound-internal', 'plist-get', 

1849 'plist-member', 'plist-put', 'point', 'point-marker', 'point-max', 

1850 'point-max-marker', 'point-min', 'point-min-marker', 

1851 'pos-visible-in-window-p', 'position-bytes', 'posix-looking-at', 

1852 'posix-search-backward', 'posix-search-forward', 'posix-string-match', 

1853 'posn-at-point', 'posn-at-x-y', 'preceding-char', 

1854 'prefix-numeric-value', 'previous-char-property-change', 

1855 'previous-frame', 'previous-overlay-change', 

1856 'previous-property-change', 'previous-single-char-property-change', 

1857 'previous-single-property-change', 'previous-window', 'prin1', 

1858 'prin1-to-string', 'princ', 'print', 'process-attributes', 

1859 'process-buffer', 'process-coding-system', 'process-command', 

1860 'process-connection', 'process-contact', 'process-datagram-address', 

1861 'process-exit-status', 'process-filter', 'process-filter-multibyte-p', 

1862 'process-id', 'process-inherit-coding-system-flag', 'process-list', 

1863 'process-mark', 'process-name', 'process-plist', 

1864 'process-query-on-exit-flag', 'process-running-child-p', 

1865 'process-send-eof', 'process-send-region', 'process-send-string', 

1866 'process-sentinel', 'process-status', 'process-tty-name', 

1867 'process-type', 'processp', 'profiler-cpu-log', 

1868 'profiler-cpu-running-p', 'profiler-cpu-start', 'profiler-cpu-stop', 

1869 'profiler-memory-log', 'profiler-memory-running-p', 

1870 'profiler-memory-start', 'profiler-memory-stop', 'propertize', 

1871 'purecopy', 'put', 'put-text-property', 

1872 'put-unicode-property-internal', 'puthash', 'query-font', 

1873 'query-fontset', 'quit-process', 'raise-frame', 'random', 'rassoc', 

1874 'rassq', 're-search-backward', 're-search-forward', 'read', 

1875 'read-buffer', 'read-char', 'read-char-exclusive', 

1876 'read-coding-system', 'read-command', 'read-event', 

1877 'read-from-minibuffer', 'read-from-string', 'read-function', 

1878 'read-key-sequence', 'read-key-sequence-vector', 

1879 'read-no-blanks-input', 'read-non-nil-coding-system', 'read-string', 

1880 'read-variable', 'recent-auto-save-p', 'recent-doskeys', 

1881 'recent-keys', 'recenter', 'recursion-depth', 'recursive-edit', 

1882 'redirect-debugging-output', 'redirect-frame-focus', 'redisplay', 

1883 'redraw-display', 'redraw-frame', 'regexp-quote', 'region-beginning', 

1884 'region-end', 'register-ccl-program', 'register-code-conversion-map', 

1885 'remhash', 'remove-list-of-text-properties', 'remove-text-properties', 

1886 'rename-buffer', 'rename-file', 'replace-match', 

1887 'reset-this-command-lengths', 'resize-mini-window-internal', 

1888 'restore-buffer-modified-p', 'resume-tty', 'reverse', 'round', 

1889 'run-hook-with-args', 'run-hook-with-args-until-failure', 

1890 'run-hook-with-args-until-success', 'run-hook-wrapped', 'run-hooks', 

1891 'run-window-configuration-change-hook', 'run-window-scroll-functions', 

1892 'safe-length', 'scan-lists', 'scan-sexps', 'scroll-down', 

1893 'scroll-left', 'scroll-other-window', 'scroll-right', 'scroll-up', 

1894 'search-backward', 'search-forward', 'secure-hash', 'select-frame', 

1895 'select-window', 'selected-frame', 'selected-window', 

1896 'self-insert-command', 'send-string-to-terminal', 'sequencep', 

1897 'serial-process-configure', 'set', 'set-buffer', 

1898 'set-buffer-auto-saved', 'set-buffer-major-mode', 

1899 'set-buffer-modified-p', 'set-buffer-multibyte', 'set-case-table', 

1900 'set-category-table', 'set-char-table-extra-slot', 

1901 'set-char-table-parent', 'set-char-table-range', 'set-charset-plist', 

1902 'set-charset-priority', 'set-coding-system-priority', 

1903 'set-cursor-size', 'set-default', 'set-default-file-modes', 

1904 'set-default-toplevel-value', 'set-file-acl', 'set-file-modes', 

1905 'set-file-selinux-context', 'set-file-times', 'set-fontset-font', 

1906 'set-frame-height', 'set-frame-position', 'set-frame-selected-window', 

1907 'set-frame-size', 'set-frame-width', 'set-fringe-bitmap-face', 

1908 'set-input-interrupt-mode', 'set-input-meta-mode', 'set-input-mode', 

1909 'set-keyboard-coding-system-internal', 'set-keymap-parent', 

1910 'set-marker', 'set-marker-insertion-type', 'set-match-data', 

1911 'set-message-beep', 'set-minibuffer-window', 

1912 'set-mouse-pixel-position', 'set-mouse-position', 

1913 'set-network-process-option', 'set-output-flow-control', 

1914 'set-process-buffer', 'set-process-coding-system', 

1915 'set-process-datagram-address', 'set-process-filter', 

1916 'set-process-filter-multibyte', 

1917 'set-process-inherit-coding-system-flag', 'set-process-plist', 

1918 'set-process-query-on-exit-flag', 'set-process-sentinel', 

1919 'set-process-window-size', 'set-quit-char', 

1920 'set-safe-terminal-coding-system-internal', 'set-screen-color', 

1921 'set-standard-case-table', 'set-syntax-table', 

1922 'set-terminal-coding-system-internal', 'set-terminal-local-value', 

1923 'set-terminal-parameter', 'set-text-properties', 'set-time-zone-rule', 

1924 'set-visited-file-modtime', 'set-window-buffer', 

1925 'set-window-combination-limit', 'set-window-configuration', 

1926 'set-window-dedicated-p', 'set-window-display-table', 

1927 'set-window-fringes', 'set-window-hscroll', 'set-window-margins', 

1928 'set-window-new-normal', 'set-window-new-pixel', 

1929 'set-window-new-total', 'set-window-next-buffers', 

1930 'set-window-parameter', 'set-window-point', 'set-window-prev-buffers', 

1931 'set-window-redisplay-end-trigger', 'set-window-scroll-bars', 

1932 'set-window-start', 'set-window-vscroll', 'setcar', 'setcdr', 

1933 'setplist', 'show-face-resources', 'signal', 'signal-process', 'sin', 

1934 'single-key-description', 'skip-chars-backward', 'skip-chars-forward', 

1935 'skip-syntax-backward', 'skip-syntax-forward', 'sleep-for', 'sort', 

1936 'sort-charsets', 'special-variable-p', 'split-char', 

1937 'split-window-internal', 'sqrt', 'standard-case-table', 

1938 'standard-category-table', 'standard-syntax-table', 'start-kbd-macro', 

1939 'start-process', 'stop-process', 'store-kbd-macro-event', 'string', 

1940 'string=', 'string<', 'string>', 'string-as-multibyte', 

1941 'string-as-unibyte', 'string-bytes', 'string-collate-equalp', 

1942 'string-collate-lessp', 'string-equal', 'string-greaterp', 

1943 'string-lessp', 'string-make-multibyte', 'string-make-unibyte', 

1944 'string-match', 'string-to-char', 'string-to-multibyte', 

1945 'string-to-number', 'string-to-syntax', 'string-to-unibyte', 

1946 'string-width', 'stringp', 'subr-name', 'subrp', 

1947 'subst-char-in-region', 'substitute-command-keys', 

1948 'substitute-in-file-name', 'substring', 'substring-no-properties', 

1949 'suspend-emacs', 'suspend-tty', 'suspicious-object', 'sxhash', 

1950 'symbol-function', 'symbol-name', 'symbol-plist', 'symbol-value', 

1951 'symbolp', 'syntax-table', 'syntax-table-p', 'system-groups', 

1952 'system-move-file-to-trash', 'system-name', 'system-users', 'tan', 

1953 'terminal-coding-system', 'terminal-list', 'terminal-live-p', 

1954 'terminal-local-value', 'terminal-name', 'terminal-parameter', 

1955 'terminal-parameters', 'terpri', 'test-completion', 

1956 'text-char-description', 'text-properties-at', 'text-property-any', 

1957 'text-property-not-all', 'this-command-keys', 

1958 'this-command-keys-vector', 'this-single-command-keys', 

1959 'this-single-command-raw-keys', 'time-add', 'time-less-p', 

1960 'time-subtract', 'tool-bar-get-system-style', 'tool-bar-height', 

1961 'tool-bar-pixel-width', 'top-level', 'trace-redisplay', 

1962 'trace-to-stderr', 'translate-region-internal', 'transpose-regions', 

1963 'truncate', 'try-completion', 'tty-display-color-cells', 

1964 'tty-display-color-p', 'tty-no-underline', 

1965 'tty-suppress-bold-inverse-default-colors', 'tty-top-frame', 

1966 'tty-type', 'type-of', 'undo-boundary', 'unencodable-char-position', 

1967 'unhandled-file-name-directory', 'unibyte-char-to-multibyte', 

1968 'unibyte-string', 'unicode-property-table-internal', 'unify-charset', 

1969 'unintern', 'unix-sync', 'unlock-buffer', 'upcase', 'upcase-initials', 

1970 'upcase-initials-region', 'upcase-region', 'upcase-word', 

1971 'use-global-map', 'use-local-map', 'user-full-name', 

1972 'user-login-name', 'user-real-login-name', 'user-real-uid', 

1973 'user-uid', 'variable-binding-locus', 'vconcat', 'vector', 

1974 'vector-or-char-table-p', 'vectorp', 'verify-visited-file-modtime', 

1975 'vertical-motion', 'visible-frame-list', 'visited-file-modtime', 

1976 'w16-get-clipboard-data', 'w16-selection-exists-p', 

1977 'w16-set-clipboard-data', 'w32-battery-status', 

1978 'w32-default-color-map', 'w32-define-rgb-color', 

1979 'w32-display-monitor-attributes-list', 'w32-frame-menu-bar-size', 

1980 'w32-frame-rect', 'w32-get-clipboard-data', 

1981 'w32-get-codepage-charset', 'w32-get-console-codepage', 

1982 'w32-get-console-output-codepage', 'w32-get-current-locale-id', 

1983 'w32-get-default-locale-id', 'w32-get-keyboard-layout', 

1984 'w32-get-locale-info', 'w32-get-valid-codepages', 

1985 'w32-get-valid-keyboard-layouts', 'w32-get-valid-locale-ids', 

1986 'w32-has-winsock', 'w32-long-file-name', 'w32-reconstruct-hot-key', 

1987 'w32-register-hot-key', 'w32-registered-hot-keys', 

1988 'w32-selection-exists-p', 'w32-send-sys-command', 

1989 'w32-set-clipboard-data', 'w32-set-console-codepage', 

1990 'w32-set-console-output-codepage', 'w32-set-current-locale', 

1991 'w32-set-keyboard-layout', 'w32-set-process-priority', 

1992 'w32-shell-execute', 'w32-short-file-name', 'w32-toggle-lock-key', 

1993 'w32-unload-winsock', 'w32-unregister-hot-key', 'w32-window-exists-p', 

1994 'w32notify-add-watch', 'w32notify-rm-watch', 

1995 'waiting-for-user-input-p', 'where-is-internal', 'widen', 

1996 'widget-apply', 'widget-get', 'widget-put', 

1997 'window-absolute-pixel-edges', 'window-at', 'window-body-height', 

1998 'window-body-width', 'window-bottom-divider-width', 'window-buffer', 

1999 'window-combination-limit', 'window-configuration-frame', 

2000 'window-configuration-p', 'window-dedicated-p', 

2001 'window-display-table', 'window-edges', 'window-end', 'window-frame', 

2002 'window-fringes', 'window-header-line-height', 'window-hscroll', 

2003 'window-inside-absolute-pixel-edges', 'window-inside-edges', 

2004 'window-inside-pixel-edges', 'window-left-child', 

2005 'window-left-column', 'window-line-height', 'window-list', 

2006 'window-list-1', 'window-live-p', 'window-margins', 

2007 'window-minibuffer-p', 'window-mode-line-height', 'window-new-normal', 

2008 'window-new-pixel', 'window-new-total', 'window-next-buffers', 

2009 'window-next-sibling', 'window-normal-size', 'window-old-point', 

2010 'window-parameter', 'window-parameters', 'window-parent', 

2011 'window-pixel-edges', 'window-pixel-height', 'window-pixel-left', 

2012 'window-pixel-top', 'window-pixel-width', 'window-point', 

2013 'window-prev-buffers', 'window-prev-sibling', 

2014 'window-redisplay-end-trigger', 'window-resize-apply', 

2015 'window-resize-apply-total', 'window-right-divider-width', 

2016 'window-scroll-bar-height', 'window-scroll-bar-width', 

2017 'window-scroll-bars', 'window-start', 'window-system', 

2018 'window-text-height', 'window-text-pixel-size', 'window-text-width', 

2019 'window-top-child', 'window-top-line', 'window-total-height', 

2020 'window-total-width', 'window-use-time', 'window-valid-p', 

2021 'window-vscroll', 'windowp', 'write-char', 'write-region', 

2022 'x-backspace-delete-keys-p', 'x-change-window-property', 

2023 'x-change-window-property', 'x-close-connection', 

2024 'x-close-connection', 'x-create-frame', 'x-create-frame', 

2025 'x-delete-window-property', 'x-delete-window-property', 

2026 'x-disown-selection-internal', 'x-display-backing-store', 

2027 'x-display-backing-store', 'x-display-color-cells', 

2028 'x-display-color-cells', 'x-display-grayscale-p', 

2029 'x-display-grayscale-p', 'x-display-list', 'x-display-list', 

2030 'x-display-mm-height', 'x-display-mm-height', 'x-display-mm-width', 

2031 'x-display-mm-width', 'x-display-monitor-attributes-list', 

2032 'x-display-pixel-height', 'x-display-pixel-height', 

2033 'x-display-pixel-width', 'x-display-pixel-width', 'x-display-planes', 

2034 'x-display-planes', 'x-display-save-under', 'x-display-save-under', 

2035 'x-display-screens', 'x-display-screens', 'x-display-visual-class', 

2036 'x-display-visual-class', 'x-family-fonts', 'x-file-dialog', 

2037 'x-file-dialog', 'x-file-dialog', 'x-focus-frame', 'x-frame-geometry', 

2038 'x-frame-geometry', 'x-get-atom-name', 'x-get-resource', 

2039 'x-get-selection-internal', 'x-hide-tip', 'x-hide-tip', 

2040 'x-list-fonts', 'x-load-color-file', 'x-menu-bar-open-internal', 

2041 'x-menu-bar-open-internal', 'x-open-connection', 'x-open-connection', 

2042 'x-own-selection-internal', 'x-parse-geometry', 'x-popup-dialog', 

2043 'x-popup-menu', 'x-register-dnd-atom', 'x-select-font', 

2044 'x-select-font', 'x-selection-exists-p', 'x-selection-owner-p', 

2045 'x-send-client-message', 'x-server-max-request-size', 

2046 'x-server-max-request-size', 'x-server-vendor', 'x-server-vendor', 

2047 'x-server-version', 'x-server-version', 'x-show-tip', 'x-show-tip', 

2048 'x-synchronize', 'x-synchronize', 'x-uses-old-gtk-dialog', 

2049 'x-window-property', 'x-window-property', 'x-wm-set-size-hint', 

2050 'xw-color-defined-p', 'xw-color-defined-p', 'xw-color-values', 

2051 'xw-color-values', 'xw-display-color-p', 'xw-display-color-p', 

2052 'yes-or-no-p', 'zlib-available-p', 'zlib-decompress-region', 

2053 'forward-point', 

2054 } 

2055 

2056 builtin_function_highlighted = { 

2057 'defvaralias', 'provide', 'require', 

2058 'with-no-warnings', 'define-widget', 'with-electric-help', 

2059 'throw', 'defalias', 'featurep' 

2060 } 

2061 

2062 lambda_list_keywords = { 

2063 '&allow-other-keys', '&aux', '&body', '&environment', '&key', '&optional', 

2064 '&rest', '&whole', 

2065 } 

2066 

2067 error_keywords = { 

2068 'cl-assert', 'cl-check-type', 'error', 'signal', 

2069 'user-error', 'warn', 

2070 } 

2071 

2072 def get_tokens_unprocessed(self, text): 

2073 stack = ['root'] 

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

2075 if token is Name.Variable: 

2076 if value in EmacsLispLexer.builtin_function: 

2077 yield index, Name.Function, value 

2078 continue 

2079 if value in EmacsLispLexer.special_forms: 

2080 yield index, Keyword, value 

2081 continue 

2082 if value in EmacsLispLexer.error_keywords: 

2083 yield index, Name.Exception, value 

2084 continue 

2085 if value in EmacsLispLexer.builtin_function_highlighted: 

2086 yield index, Name.Builtin, value 

2087 continue 

2088 if value in EmacsLispLexer.macros: 

2089 yield index, Name.Builtin, value 

2090 continue 

2091 if value in EmacsLispLexer.lambda_list_keywords: 

2092 yield index, Keyword.Pseudo, value 

2093 continue 

2094 yield index, token, value 

2095 

2096 tokens = { 

2097 'root': [ 

2098 default('body'), 

2099 ], 

2100 'body': [ 

2101 # whitespace 

2102 (r'\s+', Text), 

2103 

2104 # single-line comment 

2105 (r';.*$', Comment.Single), 

2106 

2107 # strings and characters 

2108 (r'"', String, 'string'), 

2109 (r'\?([^\\]|\\.)', String.Char), 

2110 # quoting 

2111 (r":" + symbol, Name.Builtin), 

2112 (r"::" + symbol, String.Symbol), 

2113 (r"'" + symbol, String.Symbol), 

2114 (r"'", Operator), 

2115 (r"`", Operator), 

2116 

2117 # decimal numbers 

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

2119 (r'[-+]?\d+/\d+' + terminated, Number), 

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

2121 terminated, Number.Float), 

2122 

2123 # vectors 

2124 (r'\[|\]', Punctuation), 

2125 

2126 # uninterned symbol 

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

2128 

2129 # read syntax for char tables 

2130 (r'#\^\^?', Operator), 

2131 

2132 # function shorthand 

2133 (r'#\'', Name.Function), 

2134 

2135 # binary rational 

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

2137 

2138 # octal rational 

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

2140 

2141 # hex rational 

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

2143 

2144 # radix rational 

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

2146 

2147 # reference 

2148 (r'#\d+=', Operator), 

2149 (r'#\d+#', Operator), 

2150 

2151 # special operators that should have been parsed already 

2152 (r'(,@|,|\.|:)', Operator), 

2153 

2154 # special constants 

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

2156 

2157 # functions and variables 

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

2159 (symbol, Name.Variable), 

2160 

2161 # parentheses 

2162 (r'#\(', Operator, 'body'), 

2163 (r'\(', Punctuation, 'body'), 

2164 (r'\)', Punctuation, '#pop'), 

2165 ], 

2166 'string': [ 

2167 (r'[^"\\`]+', String), 

2168 (r'`%s\'' % symbol, String.Symbol), 

2169 (r'`', String), 

2170 (r'\\.', String), 

2171 (r'\\\n', String), 

2172 (r'"', String, '#pop'), 

2173 ], 

2174 } 

2175 

2176 

2177class ShenLexer(RegexLexer): 

2178 """ 

2179 Lexer for `Shen <http://shenlanguage.org/>`_ source code. 

2180 

2181 .. versionadded:: 2.1 

2182 """ 

2183 name = 'Shen' 

2184 aliases = ['shen'] 

2185 filenames = ['*.shen'] 

2186 mimetypes = ['text/x-shen', 'application/x-shen'] 

2187 

2188 DECLARATIONS = ( 

2189 'datatype', 'define', 'defmacro', 'defprolog', 'defcc', 

2190 'synonyms', 'declare', 'package', 'type', 'function', 

2191 ) 

2192 

2193 SPECIAL_FORMS = ( 

2194 'lambda', 'get', 'let', 'if', 'cases', 'cond', 'put', 'time', 'freeze', 

2195 'value', 'load', '$', 'protect', 'or', 'and', 'not', 'do', 'output', 

2196 'prolog?', 'trap-error', 'error', 'make-string', '/.', 'set', '@p', 

2197 '@s', '@v', 

2198 ) 

2199 

2200 BUILTINS = ( 

2201 '==', '=', '*', '+', '-', '/', '<', '>', '>=', '<=', '<-address', 

2202 '<-vector', 'abort', 'absvector', 'absvector?', 'address->', 'adjoin', 

2203 'append', 'arity', 'assoc', 'bind', 'boolean?', 'bound?', 'call', 'cd', 

2204 'close', 'cn', 'compile', 'concat', 'cons', 'cons?', 'cut', 'destroy', 

2205 'difference', 'element?', 'empty?', 'enable-type-theory', 

2206 'error-to-string', 'eval', 'eval-kl', 'exception', 'explode', 'external', 

2207 'fail', 'fail-if', 'file', 'findall', 'fix', 'fst', 'fwhen', 'gensym', 

2208 'get-time', 'hash', 'hd', 'hdstr', 'hdv', 'head', 'identical', 

2209 'implementation', 'in', 'include', 'include-all-but', 'inferences', 

2210 'input', 'input+', 'integer?', 'intern', 'intersection', 'is', 'kill', 

2211 'language', 'length', 'limit', 'lineread', 'loaded', 'macro', 'macroexpand', 

2212 'map', 'mapcan', 'maxinferences', 'mode', 'n->string', 'nl', 'nth', 'null', 

2213 'number?', 'occurrences', 'occurs-check', 'open', 'os', 'out', 'port', 

2214 'porters', 'pos', 'pr', 'preclude', 'preclude-all-but', 'print', 'profile', 

2215 'profile-results', 'ps', 'quit', 'read', 'read+', 'read-byte', 'read-file', 

2216 'read-file-as-bytelist', 'read-file-as-string', 'read-from-string', 

2217 'release', 'remove', 'return', 'reverse', 'run', 'save', 'set', 

2218 'simple-error', 'snd', 'specialise', 'spy', 'step', 'stinput', 'stoutput', 

2219 'str', 'string->n', 'string->symbol', 'string?', 'subst', 'symbol?', 

2220 'systemf', 'tail', 'tc', 'tc?', 'thaw', 'tl', 'tlstr', 'tlv', 'track', 

2221 'tuple?', 'undefmacro', 'unify', 'unify!', 'union', 'unprofile', 

2222 'unspecialise', 'untrack', 'variable?', 'vector', 'vector->', 'vector?', 

2223 'verified', 'version', 'warn', 'when', 'write-byte', 'write-to-file', 

2224 'y-or-n?', 

2225 ) 

2226 

2227 BUILTINS_ANYWHERE = ('where', 'skip', '>>', '_', '!', '<e>', '<!>') 

2228 

2229 MAPPINGS = {s: Keyword for s in DECLARATIONS} 

2230 MAPPINGS.update((s, Name.Builtin) for s in BUILTINS) 

2231 MAPPINGS.update((s, Keyword) for s in SPECIAL_FORMS) 

2232 

2233 valid_symbol_chars = r'[\w!$%*+,<=>?/.\'@&#:-]' 

2234 valid_name = '%s+' % valid_symbol_chars 

2235 symbol_name = r'[a-z!$%%*+,<=>?/.\'@&#_-]%s*' % valid_symbol_chars 

2236 variable = r'[A-Z]%s*' % valid_symbol_chars 

2237 

2238 tokens = { 

2239 'string': [ 

2240 (r'"', String, '#pop'), 

2241 (r'c#\d{1,3};', String.Escape), 

2242 (r'~[ARS%]', String.Interpol), 

2243 (r'(?s).', String), 

2244 ], 

2245 

2246 'root': [ 

2247 (r'(?s)\\\*.*?\*\\', Comment.Multiline), # \* ... *\ 

2248 (r'\\\\.*', Comment.Single), # \\ ... 

2249 (r'\s+', Text), 

2250 (r'_{5,}', Punctuation), 

2251 (r'={5,}', Punctuation), 

2252 (r'(;|:=|\||--?>|<--?)', Punctuation), 

2253 (r'(:-|:|\{|\})', Literal), 

2254 (r'[+-]*\d*\.\d+(e[+-]?\d+)?', Number.Float), 

2255 (r'[+-]*\d+', Number.Integer), 

2256 (r'"', String, 'string'), 

2257 (variable, Name.Variable), 

2258 (r'(true|false|<>|\[\])', Keyword.Pseudo), 

2259 (symbol_name, Literal), 

2260 (r'(\[|\]|\(|\))', Punctuation), 

2261 ], 

2262 } 

2263 

2264 def get_tokens_unprocessed(self, text): 

2265 tokens = RegexLexer.get_tokens_unprocessed(self, text) 

2266 tokens = self._process_symbols(tokens) 

2267 tokens = self._process_declarations(tokens) 

2268 return tokens 

2269 

2270 def _relevant(self, token): 

2271 return token not in (Text, Comment.Single, Comment.Multiline) 

2272 

2273 def _process_declarations(self, tokens): 

2274 opening_paren = False 

2275 for index, token, value in tokens: 

2276 yield index, token, value 

2277 if self._relevant(token): 

2278 if opening_paren and token == Keyword and value in self.DECLARATIONS: 

2279 declaration = value 

2280 yield from self._process_declaration(declaration, tokens) 

2281 opening_paren = value == '(' and token == Punctuation 

2282 

2283 def _process_symbols(self, tokens): 

2284 opening_paren = False 

2285 for index, token, value in tokens: 

2286 if opening_paren and token in (Literal, Name.Variable): 

2287 token = self.MAPPINGS.get(value, Name.Function) 

2288 elif token == Literal and value in self.BUILTINS_ANYWHERE: 

2289 token = Name.Builtin 

2290 opening_paren = value == '(' and token == Punctuation 

2291 yield index, token, value 

2292 

2293 def _process_declaration(self, declaration, tokens): 

2294 for index, token, value in tokens: 

2295 if self._relevant(token): 

2296 break 

2297 yield index, token, value 

2298 

2299 if declaration == 'datatype': 

2300 prev_was_colon = False 

2301 token = Keyword.Type if token == Literal else token 

2302 yield index, token, value 

2303 for index, token, value in tokens: 

2304 if prev_was_colon and token == Literal: 

2305 token = Keyword.Type 

2306 yield index, token, value 

2307 if self._relevant(token): 

2308 prev_was_colon = token == Literal and value == ':' 

2309 elif declaration == 'package': 

2310 token = Name.Namespace if token == Literal else token 

2311 yield index, token, value 

2312 elif declaration == 'define': 

2313 token = Name.Function if token == Literal else token 

2314 yield index, token, value 

2315 for index, token, value in tokens: 

2316 if self._relevant(token): 

2317 break 

2318 yield index, token, value 

2319 if value == '{' and token == Literal: 

2320 yield index, Punctuation, value 

2321 for index, token, value in self._process_signature(tokens): 

2322 yield index, token, value 

2323 else: 

2324 yield index, token, value 

2325 else: 

2326 token = Name.Function if token == Literal else token 

2327 yield index, token, value 

2328 

2329 return 

2330 

2331 def _process_signature(self, tokens): 

2332 for index, token, value in tokens: 

2333 if token == Literal and value == '}': 

2334 yield index, Punctuation, value 

2335 return 

2336 elif token in (Literal, Name.Function): 

2337 token = Name.Variable if value.istitle() else Keyword.Type 

2338 yield index, token, value 

2339 

2340 

2341class CPSALexer(SchemeLexer): 

2342 """ 

2343 A CPSA lexer based on the CPSA language as of version 2.2.12 

2344 

2345 .. versionadded:: 2.1 

2346 """ 

2347 name = 'CPSA' 

2348 aliases = ['cpsa'] 

2349 filenames = ['*.cpsa'] 

2350 mimetypes = [] 

2351 

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

2353 # syntax file. 

2354 _keywords = ( 

2355 'herald', 'vars', 'defmacro', 'include', 'defprotocol', 'defrole', 

2356 'defskeleton', 'defstrand', 'deflistener', 'non-orig', 'uniq-orig', 

2357 'pen-non-orig', 'precedes', 'trace', 'send', 'recv', 'name', 'text', 

2358 'skey', 'akey', 'data', 'mesg', 

2359 ) 

2360 _builtins = ( 

2361 'cat', 'enc', 'hash', 'privk', 'pubk', 'invk', 'ltk', 'gen', 'exp', 

2362 ) 

2363 

2364 # valid names for identifiers 

2365 # well, names can only not consist fully of numbers 

2366 # but this should be good enough for now 

2367 valid_name = r'[\w!$%&*+,/:<=>?@^~|-]+' 

2368 

2369 tokens = { 

2370 'root': [ 

2371 # the comments - always starting with semicolon 

2372 # and going to the end of the line 

2373 (r';.*$', Comment.Single), 

2374 

2375 # whitespaces - usually not relevant 

2376 (r'\s+', Text), 

2377 

2378 # numbers 

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

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

2381 # support for uncommon kinds of numbers - 

2382 # have to figure out what the characters mean 

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

2384 

2385 # strings, symbols and characters 

2386 (r'"(\\\\|\\[^\\]|[^"\\])*"', String), 

2387 (r"'" + valid_name, String.Symbol), 

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

2389 

2390 # constants 

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

2392 

2393 # special operators 

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

2395 

2396 # highlight the keywords 

2397 (words(_keywords, suffix=r'\b'), Keyword), 

2398 

2399 # first variable in a quoted string like 

2400 # '(this is syntactic sugar) 

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

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

2403 

2404 # highlight the builtins 

2405 (words(_builtins, prefix=r'(?<=\()', suffix=r'\b'), Name.Builtin), 

2406 

2407 # the remaining functions 

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

2409 # find the remaining variables 

2410 (valid_name, Name.Variable), 

2411 

2412 # the famous parentheses! 

2413 (r'(\(|\))', Punctuation), 

2414 (r'(\[|\])', Punctuation), 

2415 ], 

2416 } 

2417 

2418 

2419class XtlangLexer(RegexLexer): 

2420 """An xtlang lexer for the `Extempore programming environment 

2421 <http://extempore.moso.com.au>`_. 

2422 

2423 This is a mixture of Scheme and xtlang, really. Keyword lists are 

2424 taken from the Extempore Emacs mode 

2425 (https://github.com/extemporelang/extempore-emacs-mode) 

2426 

2427 .. versionadded:: 2.2 

2428 """ 

2429 name = 'xtlang' 

2430 aliases = ['extempore'] 

2431 filenames = ['*.xtm'] 

2432 mimetypes = [] 

2433 

2434 common_keywords = ( 

2435 'lambda', 'define', 'if', 'else', 'cond', 'and', 

2436 'or', 'let', 'begin', 'set!', 'map', 'for-each', 

2437 ) 

2438 scheme_keywords = ( 

2439 'do', 'delay', 'quasiquote', 'unquote', 'unquote-splicing', 'eval', 

2440 'case', 'let*', 'letrec', 'quote', 

2441 ) 

2442 xtlang_bind_keywords = ( 

2443 'bind-func', 'bind-val', 'bind-lib', 'bind-type', 'bind-alias', 

2444 'bind-poly', 'bind-dylib', 'bind-lib-func', 'bind-lib-val', 

2445 ) 

2446 xtlang_keywords = ( 

2447 'letz', 'memzone', 'cast', 'convert', 'dotimes', 'doloop', 

2448 ) 

2449 common_functions = ( 

2450 '*', '+', '-', '/', '<', '<=', '=', '>', '>=', '%', 'abs', 'acos', 

2451 'angle', 'append', 'apply', 'asin', 'assoc', 'assq', 'assv', 

2452 'atan', 'boolean?', 'caaaar', 'caaadr', 'caaar', 'caadar', 

2453 'caaddr', 'caadr', 'caar', 'cadaar', 'cadadr', 'cadar', 

2454 'caddar', 'cadddr', 'caddr', 'cadr', 'car', 'cdaaar', 

2455 'cdaadr', 'cdaar', 'cdadar', 'cdaddr', 'cdadr', 'cdar', 

2456 'cddaar', 'cddadr', 'cddar', 'cdddar', 'cddddr', 'cdddr', 

2457 'cddr', 'cdr', 'ceiling', 'cons', 'cos', 'floor', 'length', 

2458 'list', 'log', 'max', 'member', 'min', 'modulo', 'not', 

2459 'reverse', 'round', 'sin', 'sqrt', 'substring', 'tan', 

2460 'println', 'random', 'null?', 'callback', 'now', 

2461 ) 

2462 scheme_functions = ( 

2463 'call-with-current-continuation', 'call-with-input-file', 

2464 'call-with-output-file', 'call-with-values', 'call/cc', 

2465 'char->integer', 'char-alphabetic?', 'char-ci<=?', 'char-ci<?', 

2466 'char-ci=?', 'char-ci>=?', 'char-ci>?', 'char-downcase', 

2467 'char-lower-case?', 'char-numeric?', 'char-ready?', 

2468 'char-upcase', 'char-upper-case?', 'char-whitespace?', 

2469 'char<=?', 'char<?', 'char=?', 'char>=?', 'char>?', 'char?', 

2470 'close-input-port', 'close-output-port', 'complex?', 

2471 'current-input-port', 'current-output-port', 'denominator', 

2472 'display', 'dynamic-wind', 'eof-object?', 'eq?', 'equal?', 

2473 'eqv?', 'even?', 'exact->inexact', 'exact?', 'exp', 'expt', 

2474 'force', 'gcd', 'imag-part', 'inexact->exact', 'inexact?', 

2475 'input-port?', 'integer->char', 'integer?', 

2476 'interaction-environment', 'lcm', 'list->string', 

2477 'list->vector', 'list-ref', 'list-tail', 'list?', 'load', 

2478 'magnitude', 'make-polar', 'make-rectangular', 'make-string', 

2479 'make-vector', 'memq', 'memv', 'negative?', 'newline', 

2480 'null-environment', 'number->string', 'number?', 

2481 'numerator', 'odd?', 'open-input-file', 'open-output-file', 

2482 'output-port?', 'pair?', 'peek-char', 'port?', 'positive?', 

2483 'procedure?', 'quotient', 'rational?', 'rationalize', 'read', 

2484 'read-char', 'real-part', 'real?', 

2485 'remainder', 'scheme-report-environment', 'set-car!', 'set-cdr!', 

2486 'string', 'string->list', 'string->number', 'string->symbol', 

2487 'string-append', 'string-ci<=?', 'string-ci<?', 'string-ci=?', 

2488 'string-ci>=?', 'string-ci>?', 'string-copy', 'string-fill!', 

2489 'string-length', 'string-ref', 'string-set!', 'string<=?', 

2490 'string<?', 'string=?', 'string>=?', 'string>?', 'string?', 

2491 'symbol->string', 'symbol?', 'transcript-off', 'transcript-on', 

2492 'truncate', 'values', 'vector', 'vector->list', 'vector-fill!', 

2493 'vector-length', 'vector?', 

2494 'with-input-from-file', 'with-output-to-file', 'write', 

2495 'write-char', 'zero?', 

2496 ) 

2497 xtlang_functions = ( 

2498 'toString', 'afill!', 'pfill!', 'tfill!', 'tbind', 'vfill!', 

2499 'array-fill!', 'pointer-fill!', 'tuple-fill!', 'vector-fill!', 'free', 

2500 'array', 'tuple', 'list', '~', 'cset!', 'cref', '&', 'bor', 

2501 'ang-names', '<<', '>>', 'nil', 'printf', 'sprintf', 'null', 'now', 

2502 'pset!', 'pref-ptr', 'vset!', 'vref', 'aset!', 'aref', 'aref-ptr', 

2503 'tset!', 'tref', 'tref-ptr', 'salloc', 'halloc', 'zalloc', 'alloc', 

2504 'schedule', 'exp', 'log', 'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 

2505 'sqrt', 'expt', 'floor', 'ceiling', 'truncate', 'round', 

2506 'llvm_printf', 'push_zone', 'pop_zone', 'memzone', 'callback', 

2507 'llvm_sprintf', 'make-array', 'array-set!', 'array-ref', 

2508 'array-ref-ptr', 'pointer-set!', 'pointer-ref', 'pointer-ref-ptr', 

2509 'stack-alloc', 'heap-alloc', 'zone-alloc', 'make-tuple', 'tuple-set!', 

2510 'tuple-ref', 'tuple-ref-ptr', 'closure-set!', 'closure-ref', 'pref', 

2511 'pdref', 'impc_null', 'bitcast', 'void', 'ifret', 'ret->', 'clrun->', 

2512 'make-env-zone', 'make-env', '<>', 'dtof', 'ftod', 'i1tof', 

2513 'i1tod', 'i1toi8', 'i1toi32', 'i1toi64', 'i8tof', 'i8tod', 

2514 'i8toi1', 'i8toi32', 'i8toi64', 'i32tof', 'i32tod', 'i32toi1', 

2515 'i32toi8', 'i32toi64', 'i64tof', 'i64tod', 'i64toi1', 

2516 'i64toi8', 'i64toi32', 

2517 ) 

2518 

2519 # valid names for Scheme identifiers (names cannot consist fully 

2520 # of numbers, but this should be good enough for now) 

2521 valid_scheme_name = r'[\w!$%&*+,/:<=>?@^~|-]+' 

2522 

2523 # valid characters in xtlang names & types 

2524 valid_xtlang_name = r'[\w.!-]+' 

2525 valid_xtlang_type = r'[]{}[\w<>,*/|!-]+' 

2526 

2527 tokens = { 

2528 # keep track of when we're exiting the xtlang form 

2529 'xtlang': [ 

2530 (r'\(', Punctuation, '#push'), 

2531 (r'\)', Punctuation, '#pop'), 

2532 

2533 (r'(?<=bind-func\s)' + valid_xtlang_name, Name.Function), 

2534 (r'(?<=bind-val\s)' + valid_xtlang_name, Name.Function), 

2535 (r'(?<=bind-type\s)' + valid_xtlang_name, Name.Function), 

2536 (r'(?<=bind-alias\s)' + valid_xtlang_name, Name.Function), 

2537 (r'(?<=bind-poly\s)' + valid_xtlang_name, Name.Function), 

2538 (r'(?<=bind-lib\s)' + valid_xtlang_name, Name.Function), 

2539 (r'(?<=bind-dylib\s)' + valid_xtlang_name, Name.Function), 

2540 (r'(?<=bind-lib-func\s)' + valid_xtlang_name, Name.Function), 

2541 (r'(?<=bind-lib-val\s)' + valid_xtlang_name, Name.Function), 

2542 

2543 # type annotations 

2544 (r':' + valid_xtlang_type, Keyword.Type), 

2545 

2546 # types 

2547 (r'(<' + valid_xtlang_type + r'>|\|' + valid_xtlang_type + r'\||/' + 

2548 valid_xtlang_type + r'/|' + valid_xtlang_type + r'\*)\**', 

2549 Keyword.Type), 

2550 

2551 # keywords 

2552 (words(xtlang_keywords, prefix=r'(?<=\()'), Keyword), 

2553 

2554 # builtins 

2555 (words(xtlang_functions, prefix=r'(?<=\()'), Name.Function), 

2556 

2557 include('common'), 

2558 

2559 # variables 

2560 (valid_xtlang_name, Name.Variable), 

2561 ], 

2562 'scheme': [ 

2563 # quoted symbols 

2564 (r"'" + valid_scheme_name, String.Symbol), 

2565 

2566 # char literals 

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

2568 

2569 # special operators 

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

2571 

2572 # keywords 

2573 (words(scheme_keywords, prefix=r'(?<=\()'), Keyword), 

2574 

2575 # builtins 

2576 (words(scheme_functions, prefix=r'(?<=\()'), Name.Function), 

2577 

2578 include('common'), 

2579 

2580 # variables 

2581 (valid_scheme_name, Name.Variable), 

2582 ], 

2583 # common to both xtlang and Scheme 

2584 'common': [ 

2585 # comments 

2586 (r';.*$', Comment.Single), 

2587 

2588 # whitespaces - usually not relevant 

2589 (r'\s+', Text), 

2590 

2591 # numbers 

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

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

2594 

2595 # binary/oct/hex literals 

2596 (r'(#b|#o|#x)[\d.]+', Number), 

2597 

2598 # strings 

2599 (r'"(\\\\|\\[^\\]|[^"\\])*"', String), 

2600 

2601 # true/false constants 

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

2603 

2604 # keywords 

2605 (words(common_keywords, prefix=r'(?<=\()'), Keyword), 

2606 

2607 # builtins 

2608 (words(common_functions, prefix=r'(?<=\()'), Name.Function), 

2609 

2610 # the famous parentheses! 

2611 (r'(\(|\))', Punctuation), 

2612 ], 

2613 'root': [ 

2614 # go into xtlang mode 

2615 (words(xtlang_bind_keywords, prefix=r'(?<=\()', suffix=r'\b'), 

2616 Keyword, 'xtlang'), 

2617 

2618 include('scheme') 

2619 ], 

2620 } 

2621 

2622 

2623class FennelLexer(RegexLexer): 

2624 """A lexer for the `Fennel programming language <https://fennel-lang.org>`_. 

2625 

2626 Fennel compiles to Lua, so all the Lua builtins are recognized as well 

2627 as the special forms that are particular to the Fennel compiler. 

2628 

2629 .. versionadded:: 2.3 

2630 """ 

2631 name = 'Fennel' 

2632 aliases = ['fennel', 'fnl'] 

2633 filenames = ['*.fnl'] 

2634 

2635 # these two lists are taken from fennel-mode.el: 

2636 # https://gitlab.com/technomancy/fennel-mode 

2637 # this list is current as of Fennel version 0.6.0. 

2638 special_forms = ( 

2639 'require-macros', 'eval-compiler', 'doc', 'lua', 'hashfn', 

2640 'macro', 'macros', 'import-macros', 'pick-args', 'pick-values', 

2641 'macroexpand', 'macrodebug', 'do', 'values', 'if', 'when', 

2642 'each', 'for', 'fn', 'lambda', 'λ', 'partial', 'while', 

2643 'set', 'global', 'var', 'local', 'let', 'tset', 'set-forcibly!', 

2644 'doto', 'match', 'or', 'and', 'true', 'false', 'nil', 'not', 

2645 'not=', '.', '+', '..', '^', '-', '*', '%', '/', '>', 

2646 '<', '>=', '<=', '=', '...', ':', '->', '->>', '-?>', 

2647 '-?>>', 'rshift', 'lshift', 'bor', 'band', 'bnot', 'bxor', 

2648 'with-open', 'length' 

2649 ) 

2650 

2651 # Might be nicer to use the list from _lua_builtins.py but it's unclear how? 

2652 builtins = ( 

2653 '_G', '_VERSION', 'arg', 'assert', 'bit32', 'collectgarbage', 

2654 'coroutine', 'debug', 'dofile', 'error', 'getfenv', 

2655 'getmetatable', 'io', 'ipairs', 'load', 'loadfile', 'loadstring', 

2656 'math', 'next', 'os', 'package', 'pairs', 'pcall', 'print', 

2657 'rawequal', 'rawget', 'rawlen', 'rawset', 'require', 'select', 

2658 'setfenv', 'setmetatable', 'string', 'table', 'tonumber', 

2659 'tostring', 'type', 'unpack', 'xpcall' 

2660 ) 

2661 

2662 # based on the scheme definition, but disallowing leading digits and 

2663 # commas, and @ is not allowed. 

2664 valid_name = r'[a-zA-Z_!$%&*+/:<=>?^~|-][\w!$%&*+/:<=>?^~|\.-]*' 

2665 

2666 tokens = { 

2667 'root': [ 

2668 # the only comment form is a semicolon; goes to the end of the line 

2669 (r';.*$', Comment.Single), 

2670 

2671 (r'[,\s]+', Text), 

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

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

2674 

2675 (r'"(\\\\|\\[^\\]|[^"\\])*"', String), 

2676 

2677 # these are technically strings, but it's worth visually 

2678 # distinguishing them because their intent is different 

2679 # from regular strings. 

2680 (r':' + valid_name, String.Symbol), 

2681 

2682 # special forms are keywords 

2683 (words(special_forms, suffix=' '), Keyword), 

2684 # lua standard library are builtins 

2685 (words(builtins, suffix=' '), Name.Builtin), 

2686 # special-case the vararg symbol 

2687 (r'\.\.\.', Name.Variable), 

2688 # regular identifiers 

2689 (valid_name, Name.Variable), 

2690 

2691 # all your normal paired delimiters for your programming enjoyment 

2692 (r'(\(|\))', Punctuation), 

2693 (r'(\[|\])', Punctuation), 

2694 (r'(\{|\})', Punctuation), 

2695 

2696 # the # symbol is shorthand for a lambda function 

2697 (r'#', Punctuation), 

2698 ] 

2699 }