├── .gitignore ├── Lisplogo.png ├── screenshot.png ├── .vscodeignore ├── CHANGELOG.md ├── .eslintrc.json ├── src ├── test │ ├── suite │ │ ├── extension.test.ts │ │ └── index.ts │ └── runTest.ts └── extension.ts ├── .vscode └── launch.json ├── tsconfig.json ├── language-configuration.json ├── vsc-extension-quickstart.md ├── README.md ├── package.json └── syntaxes └── commonlisp.tmLanguage /.gitignore: -------------------------------------------------------------------------------- 1 | out 2 | node_modules 3 | .vscode-test/ 4 | *.vsix 5 | -------------------------------------------------------------------------------- /Lisplogo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ailisp/commonlisp-vscode/master/Lisplogo.png -------------------------------------------------------------------------------- /screenshot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ailisp/commonlisp-vscode/master/screenshot.png -------------------------------------------------------------------------------- /.vscodeignore: -------------------------------------------------------------------------------- 1 | .vscode/** 2 | .vscode-test/** 3 | out/test/** 4 | src/** 5 | .gitignore 6 | vsc-extension-quickstart.md 7 | **/tsconfig.json 8 | **/.eslintrc.json 9 | **/*.map 10 | **/*.ts 11 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Change Log 2 | 3 | All notable changes to the "commonlisp-vscode" extension will be documented in this file. 4 | 5 | Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file. 6 | 7 | ## [Unreleased] 8 | 9 | - Initial release -------------------------------------------------------------------------------- /.eslintrc.json: -------------------------------------------------------------------------------- 1 | { 2 | "root": true, 3 | "parser": "@typescript-eslint/parser", 4 | "parserOptions": { 5 | "ecmaVersion": 6, 6 | "sourceType": "module" 7 | }, 8 | "plugins": [ 9 | "@typescript-eslint" 10 | ], 11 | "rules": { 12 | "@typescript-eslint/class-name-casing": "warn", 13 | "@typescript-eslint/semi": "warn", 14 | "curly": "warn", 15 | "eqeqeq": "warn", 16 | "no-throw-literal": "warn", 17 | "semi": "off" 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/test/suite/extension.test.ts: -------------------------------------------------------------------------------- 1 | import * as assert from 'assert'; 2 | 3 | // You can import and use all API from the 'vscode' module 4 | // as well as import your extension to test it 5 | import * as vscode from 'vscode'; 6 | // import * as myExtension from '../extension'; 7 | 8 | suite('Extension Test Suite', () => { 9 | vscode.window.showInformationMessage('Start all tests.'); 10 | 11 | test('Sample test', () => { 12 | assert.equal(-1, [1, 2, 3].indexOf(5)); 13 | assert.equal(-1, [1, 2, 3].indexOf(0)); 14 | }); 15 | }); 16 | -------------------------------------------------------------------------------- /.vscode/launch.json: -------------------------------------------------------------------------------- 1 | // A launch configuration that launches the extension inside a new window 2 | // Use IntelliSense to learn about possible attributes. 3 | // Hover to view descriptions of existing attributes. 4 | // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 5 | { 6 | "version": "0.2.0", 7 | "configurations": [ 8 | { 9 | "name": "Extension", 10 | "type": "extensionHost", 11 | "request": "launch", 12 | "runtimeExecutable": "${execPath}", 13 | "args": [ 14 | "--extensionDevelopmentPath=${workspaceFolder}" 15 | ] 16 | } 17 | ] 18 | } -------------------------------------------------------------------------------- /tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | "module": "commonjs", 4 | "target": "es6", 5 | "outDir": "out", 6 | "lib": [ 7 | "es6" 8 | ], 9 | "sourceMap": true, 10 | "rootDir": "src", 11 | "strict": true /* enable all strict type-checking options */ 12 | /* Additional Checks */ 13 | // "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */ 14 | // "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */ 15 | // "noUnusedParameters": true, /* Report errors on unused parameters. */ 16 | }, 17 | "exclude": [ 18 | "node_modules", 19 | ".vscode-test" 20 | ] 21 | } 22 | -------------------------------------------------------------------------------- /src/test/runTest.ts: -------------------------------------------------------------------------------- 1 | import * as path from 'path'; 2 | 3 | import { runTests } from 'vscode-test'; 4 | 5 | async function main() { 6 | try { 7 | // The folder containing the Extension Manifest package.json 8 | // Passed to `--extensionDevelopmentPath` 9 | const extensionDevelopmentPath = path.resolve(__dirname, '../../'); 10 | 11 | // The path to test runner 12 | // Passed to --extensionTestsPath 13 | const extensionTestsPath = path.resolve(__dirname, './suite/index'); 14 | 15 | // Download VS Code, unzip it and run the integration test 16 | await runTests({ extensionDevelopmentPath, extensionTestsPath }); 17 | } catch (err) { 18 | console.error('Failed to run tests'); 19 | process.exit(1); 20 | } 21 | } 22 | 23 | main(); 24 | -------------------------------------------------------------------------------- /src/test/suite/index.ts: -------------------------------------------------------------------------------- 1 | import * as path from 'path'; 2 | import * as Mocha from 'mocha'; 3 | import * as glob from 'glob'; 4 | 5 | export function run(): Promise { 6 | // Create the mocha test 7 | const mocha = new Mocha({ 8 | ui: 'tdd', 9 | color: true 10 | }); 11 | 12 | const testsRoot = path.resolve(__dirname, '..'); 13 | 14 | return new Promise((c, e) => { 15 | glob('**/**.test.js', { cwd: testsRoot }, (err, files) => { 16 | if (err) { 17 | return e(err); 18 | } 19 | 20 | // Add files to the test suite 21 | files.forEach(f => mocha.addFile(path.resolve(testsRoot, f))); 22 | 23 | try { 24 | // Run the mocha test 25 | mocha.run(failures => { 26 | if (failures > 0) { 27 | e(new Error(`${failures} tests failed.`)); 28 | } else { 29 | c(); 30 | } 31 | }); 32 | } catch (err) { 33 | console.error(err); 34 | e(err); 35 | } 36 | }); 37 | }); 38 | } 39 | -------------------------------------------------------------------------------- /language-configuration.json: -------------------------------------------------------------------------------- 1 | { 2 | "comments": { 3 | // symbol used for single line comment. Remove this entry if your language does not support line comments 4 | "lineComment": ";;", 5 | // symbols used for start and end a block comment. Remove this entry if your language does not support block comments 6 | "blockComment": [ 7 | "|#", 8 | "#|" 9 | ] 10 | }, 11 | // symbols used as brackets 12 | "brackets": [ 13 | [ 14 | "{", 15 | "}" 16 | ], 17 | [ 18 | "[", 19 | "]" 20 | ], 21 | [ 22 | "(", 23 | ")" 24 | ] 25 | ], 26 | // symbols that are auto closed when typing 27 | "autoClosingPairs": [ 28 | [ 29 | "{", 30 | "}" 31 | ], 32 | [ 33 | "[", 34 | "]" 35 | ], 36 | [ 37 | "(", 38 | ")" 39 | ], 40 | [ 41 | "\"", 42 | "\"" 43 | ], 44 | [ 45 | "|", 46 | "|" 47 | ] 48 | ], 49 | // symbols that can be used to surround a selection 50 | "surroundingPairs": [ 51 | [ 52 | "{", 53 | "}" 54 | ], 55 | [ 56 | "[", 57 | "]" 58 | ], 59 | [ 60 | "(", 61 | ")" 62 | ], 63 | [ 64 | "\"", 65 | "\"" 66 | ], 67 | [ 68 | "|", 69 | "|" 70 | ] 71 | ], 72 | } -------------------------------------------------------------------------------- /vsc-extension-quickstart.md: -------------------------------------------------------------------------------- 1 | # Welcome to your VS Code Extension 2 | 3 | ## What's in the folder 4 | 5 | * This folder contains all of the files necessary for your extension. 6 | * `package.json` - this is the manifest file in which you declare your language support and define the location of the grammar file that has been copied into your extension. 7 | * `syntaxes/commonlisp.tmLanguage.json` - this is the Text mate grammar file that is used for tokenization. 8 | * `language-configuration.json` - this is the language configuration, defining the tokens that are used for comments and brackets. 9 | 10 | ## Get up and running straight away 11 | 12 | * Make sure the language configuration settings in `language-configuration.json` are accurate. 13 | * Press `F5` to open a new window with your extension loaded. 14 | * Create a new file with a file name suffix matching your language. 15 | * Verify that syntax highlighting works and that the language configuration settings are working. 16 | 17 | ## Make changes 18 | 19 | * You can relaunch the extension from the debug toolbar after making changes to the files listed above. 20 | * You can also reload (`Ctrl+R` or `Cmd+R` on Mac) the VS Code window with your extension to load your changes. 21 | 22 | ## Add more language features 23 | 24 | * To add features such as intellisense, hovers and validators check out the VS Code extenders documentation at https://code.visualstudio.com/docs 25 | 26 | ## Install your extension 27 | 28 | * To start using your extension with Visual Studio Code copy it into the `/.vscode/extensions` folder and restart Code. 29 | * To share your extension with the world, read on https://code.visualstudio.com/docs about publishing an extension. 30 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # commonlisp-vscode 2 | 3 | Common Lisp Editing Extension for vscode 4 | 5 | ## Update 6 | **cl-lsp is updated with a cleaner REPL! Please update by do `git pull` in `~/.roswell/local-projects/ailisp/cl-lsp`** 7 | 8 | ![Screenshot](/screenshot.png) 9 | 10 | ## Features 11 | - Common Lisp syntax highlight, Auto indenting/formating, folding. 12 | - (Optional) Structural editing and navigation provided by [strict-paredit-vscode](https://github.com/ailisp/strict-paredit-vscode). 13 | - Autocompletion, documentation on hover, go to definition, compile & load file, REPL backed by [cl-lsp](https://github.com/ailisp/cl-lsp) language server. 14 | 15 | ## Requirements 16 | 17 | - Install [roswell](https://github.com/roswell/roswell) and have `~/.roswell/bin` in `PATH` 18 | - Install [cl-lsp](https://github.com/ailisp/cl-lsp), above two is required because original package doesn't have readline support in prepl. 19 | - `ros install ailisp/linedit` 20 | - `ros install ailisp/prepl` 21 | - `ros install ailisp/cl-lsp` 22 | - (Recommend) Install [strict-paredit-vscode](https://github.com/ailisp/strict-paredit-vscode): `ext install ailisp.strict-paredit`, which provides best parens edit experience close to Emacs. 23 | - (Recommend) Use sbcl instead of sbcl_bin in roswell, to get go to definition with symbols in `common-lisp` package: 24 | - `ros install sbcl` 25 | - `ros use sbcl` 26 | 27 | ## Known Issues 28 | 29 | - No debugger, but planned to come soon. 30 | 31 | ## Credits 32 | [cl-lsp](https://github.com/cxxxr/cl-lsp) provides a complete common lisp language server protocol and a mostly working LSP client for vscode. I forked cl-lsp to fix some issues on it and this repo is fix to its vscode plugin to support recent version of vscode and adding a few improvements: auto indenting on newline and run REPL. 33 | 34 | ## Release Notes 35 | 36 | Users appreciate release notes as you update your extension. 37 | 38 | ### 0.3.2 39 | - Fix path issue that requires cl-lsp in path, was not fixed properly in 0.3.1 40 | 41 | ### 0.3.1 42 | - Use absolute path as default cl-lsp path 43 | 44 | ### 0.3.0 45 | - avoid lsp server error mixed with REPL, record error in log 46 | 47 | ### 0.2.0 48 | 49 | - support readline editing (arrow key works, history, etc.) in repl 50 | - default keybinding to eval (Ctrl+Enter) and to start REPL (Ctrl+Shift+Enter) 51 | 52 | ### 0.1.1 53 | 54 | - Support open multiple commonlisp-vscode in multiple vscode window 55 | 56 | ### 0.1.0 57 | 58 | - REPL doesn't show lsp messages, is a clean PREPL now 59 | 60 | ### 0.0.4 61 | 62 | - LSP and REPL use same lisp process, so evaluate in file is available to REPL now 63 | 64 | ### 0.0.3 65 | 66 | - Fix auto indenting on newline, close to edit lisp file in emacs 67 | 68 | ### 0.0.2 69 | 70 | - Fix on lsp side to recognize lisp symbols on hover 71 | - Add option to set lsp path 72 | 73 | ### 0.0.1 74 | 75 | Initial release of commonlisp-vscode, support all features mentioned in readme 76 | 77 | **Enjoy!** 78 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "commonlisp-vscode", 3 | "displayName": "Common Lisp", 4 | "description": "Common Lisp Editing Extension for vscode", 5 | "version": "0.3.2", 6 | "publisher": "ailisp", 7 | "icon": "Lisplogo.png", 8 | "repository": { 9 | "type": "git", 10 | "url": "https://github.com/ailisp/commonlisp-vscode" 11 | }, 12 | "engines": { 13 | "vscode": "^1.30.0" 14 | }, 15 | "categories": [ 16 | "Programming Languages" 17 | ], 18 | "activationEvents": [ 19 | "onLanguage:commonlisp" 20 | ], 21 | "main": "./out/extension.js", 22 | "contributes": { 23 | "languages": [ 24 | { 25 | "id": "commonlisp", 26 | "aliases": [ 27 | "Common Lisp", 28 | "commonlisp" 29 | ], 30 | "extensions": [ 31 | ".lisp", 32 | ".cl", 33 | ".lsp", 34 | ".asdf", 35 | ".asd", 36 | ".ros" 37 | ], 38 | "configuration": "./language-configuration.json" 39 | } 40 | ], 41 | "grammars": [ 42 | { 43 | "language": "commonlisp", 44 | "scopeName": "source.commonlisp", 45 | "path": "./syntaxes/commonlisp.tmLanguage" 46 | } 47 | ], 48 | "commands": [ 49 | { 50 | "command": "lisp.replStart", 51 | "title": "Lisp: REPL - start" 52 | }, 53 | { 54 | "command": "lisp.compileAndLoadFile", 55 | "title": "Lisp: Compile And Load File" 56 | }, 57 | { 58 | "command": "lisp.eval", 59 | "title": "Lisp: Evaluate", 60 | "when": "editorTextFocus" 61 | }, 62 | { 63 | "command": "lisp.interrupt", 64 | "title": "Lisp: Interrupt" 65 | }, 66 | { 67 | "command": "lisp.newlineAndFormat", 68 | "title": "Lisp: Newline and Format" 69 | } 70 | ], 71 | "keybindings": [ 72 | { 73 | "command": "lisp.newlineAndFormat", 74 | "key": "enter", 75 | "when": "editorLangId == commonlisp && editorTextFocus && !editorReadOnly" 76 | }, 77 | { 78 | "command": "lisp.eval", 79 | "key": "ctrl+enter", 80 | "when": "editorLangId == commonlisp && editorTextFocus" 81 | }, 82 | { 83 | "command": "lisp.replStart", 84 | "key": "ctrl+shift+enter", 85 | "when": "editorLangId == commonlisp && editorTextFocus" 86 | } 87 | ], 88 | "configuration": [ 89 | { 90 | "title": "Common Lisp", 91 | "type": "object", 92 | "properties": { 93 | "commonlisp.lsppath": { 94 | "type": "string", 95 | "description": "Language server path", 96 | "default": "~/.roswell/bin/cl-lsp", 97 | "scope": "window" 98 | } 99 | } 100 | } 101 | ] 102 | }, 103 | "scripts": { 104 | "vscode:prepublish": "npm run compile", 105 | "compile": "tsc -p ./", 106 | "lint": "eslint src --ext ts", 107 | "watch": "tsc -watch -p ./", 108 | "pretest": "npm run compile && npm run lint", 109 | "test": "node ./out/test/runTest.js" 110 | }, 111 | "devDependencies": { 112 | "@types/vscode": "^1.30.0", 113 | "@types/glob": "^7.1.1", 114 | "@types/mocha": "^7.0.2", 115 | "@types/node": "^13.11.0", 116 | "eslint": "^6.8.0", 117 | "@typescript-eslint/parser": "^2.26.0", 118 | "@typescript-eslint/eslint-plugin": "^2.26.0", 119 | "glob": "^7.1.6", 120 | "mocha": "^7.1.1", 121 | "typescript": "^3.8.3", 122 | "vscode-test": "^1.3.0" 123 | }, 124 | "dependencies": { 125 | "expand-home-dir": "0.0.3", 126 | "portfinder": "^1.0.26", 127 | "vscode-languageclient": "^6.1.3" 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /src/extension.ts: -------------------------------------------------------------------------------- 1 | import * as vscode from 'vscode'; 2 | import * as child_process from 'child_process'; 3 | import * as net from 'net'; 4 | import * as portfinder from 'portfinder'; 5 | import * as util from 'util'; 6 | 7 | import { 8 | workspace, Disposable, ExtensionContext, languages, 9 | window, commands, InputBoxOptions 10 | } from 'vscode'; 11 | import { 12 | LanguageClient, LanguageClientOptions, SettingMonitor, ServerOptions, 13 | TransportKind, TextDocumentIdentifier, TextDocumentPositionParams, 14 | StreamInfo 15 | } from 'vscode-languageclient'; 16 | import { homedir } from 'os'; 17 | 18 | let languageClient: LanguageClient; 19 | 20 | let repl: vscode.Terminal | null = null; 21 | 22 | let lspPort: number | null = null; 23 | 24 | function expandHomeDir(path: string): string { 25 | if (path.startsWith('~/')) { 26 | return homedir()+path.slice(1); 27 | } 28 | return path; 29 | } 30 | 31 | async function startLSP() { 32 | lspPort = await portfinder.getPortPromise({ 33 | port: 10003 34 | }); 35 | let lsppath = expandHomeDir(workspace.getConfiguration().get('commonlisp.lsppath')!); 36 | return vscode.window.createTerminal({ 37 | name: "Common Lisp REPL", 38 | shellPath: lsppath, 39 | shellArgs: ["tcp", lspPort.toString()], 40 | hideFromUser: true, 41 | }); 42 | } 43 | 44 | async function startRepl() { 45 | if (repl) { 46 | repl.show(); 47 | } else { 48 | let repl = await startLSP(); 49 | repl.show(); 50 | } 51 | } 52 | 53 | function getTextDocumentIdentifier() { 54 | if (vscode.window.activeTextEditor) { 55 | let document = vscode.window.activeTextEditor.document; 56 | let params: TextDocumentIdentifier = { 57 | uri: document.uri.toString() 58 | } 59 | return params; 60 | } else { 61 | return null; 62 | } 63 | } 64 | 65 | function compileAndLoadFile() { 66 | let params = getTextDocumentIdentifier(); 67 | if (params) { 68 | languageClient.sendNotification("lisp/compileAndLoadFile", params); 69 | } else { 70 | vscode.window.showErrorMessage('Need to open a file to compile and load'); 71 | } 72 | } 73 | 74 | function evaluate() { 75 | if (vscode.window.activeTextEditor) { 76 | let selection = vscode.window.activeTextEditor.selection; 77 | if (selection.isEmpty) { 78 | let params: TextDocumentPositionParams = { 79 | textDocument: getTextDocumentIdentifier()!, 80 | position: selection.active 81 | } 82 | languageClient.sendNotification("lisp/eval", params); 83 | } else { 84 | let params = { 85 | textDocument: getTextDocumentIdentifier(), 86 | range: selection 87 | } 88 | languageClient.sendNotification("lisp/rangeEval", params); 89 | } 90 | } else { 91 | vscode.window.showErrorMessage("Need an editor window to evaluate"); 92 | } 93 | } 94 | 95 | function interrupt() { 96 | languageClient.sendNotification("lisp/interrupt", {}); 97 | } 98 | 99 | async function newlineAndFormat() { 100 | let editor = vscode.window.activeTextEditor!; 101 | let document = editor.document; 102 | let position = editor.selection.active; 103 | await editor.edit(e => e.insert( 104 | position, 105 | "\n")); 106 | position = editor.selection.active; 107 | let edits = await languageClient.sendRequest("textDocument/onTypeFormatting", { 108 | textDocument: { "uri": "file://" + document.uri.fsPath }, 109 | position, 110 | ch: "\n", 111 | options: { 112 | tabSize: editor.options.tabSize, 113 | insertSpaces: editor.options.insertSpaces, 114 | } 115 | }); 116 | 117 | const workEdits = new vscode.WorkspaceEdit(); 118 | workEdits.set(document.uri, edits as vscode.TextEdit[]); // give the edits 119 | vscode.workspace.applyEdit(workEdits); // apply the edits 120 | } 121 | 122 | function retry(retries: number, fn: () => Promise): Promise { 123 | return fn().catch((err) => retries > 1 ? retry(retries - 1, fn) : Promise.reject(err)); 124 | } 125 | const pause = (duration: number) => new Promise(res => setTimeout(res, duration)); 126 | function backoff(retries: number, fn: () => Promise, delay = 500): Promise { 127 | return fn().catch(err => retries > 1 128 | ? pause(delay).then(() => backoff(retries - 1, fn, delay * 2)) 129 | : Promise.reject(err)); 130 | } 131 | 132 | export async function activate(context: ExtensionContext) { 133 | let serverOptions: ServerOptions; 134 | serverOptions = async () => { 135 | let client = new net.Socket(); 136 | repl = await startLSP(); 137 | return await backoff(5, () => { 138 | return new Promise((resolve, reject) => { 139 | setTimeout(() => { 140 | reject(new Error("Connection to lsp times out")) 141 | }, 1000); 142 | client.connect(lspPort!, "127.0.0.1"); 143 | client.once('connect', () => { 144 | resolve({ 145 | reader: client, 146 | writer: client, 147 | }); 148 | }); 149 | }) 150 | }); 151 | }; 152 | 153 | let clientOptions: LanguageClientOptions = { 154 | documentSelector: ["commonlisp"], 155 | synchronize: { 156 | configurationSection: 'commonlisp' 157 | } 158 | } 159 | 160 | languageClient = new LanguageClient("Common Lisp Language Server", serverOptions, clientOptions); 161 | languageClient.onReady().then(function (x) { 162 | languageClient.onNotification("lisp/evalBegin", function (f) { 163 | window.setStatusBarMessage("Eval..."); 164 | }) 165 | languageClient.onNotification("lisp/evalEnd", function (f) { 166 | window.setStatusBarMessage("Done"); 167 | }) 168 | }) 169 | 170 | context.subscriptions.push(languageClient.start()); 171 | 172 | context.subscriptions.push(commands.registerCommand("lisp.compileAndLoadFile", () => compileAndLoadFile())); 173 | context.subscriptions.push(commands.registerCommand("lisp.eval", () => evaluate())); 174 | context.subscriptions.push(commands.registerCommand("lisp.interrupt", () => interrupt())); 175 | context.subscriptions.push(commands.registerCommand("lisp.replStart", () => startRepl())); 176 | context.subscriptions.push(commands.registerCommand("lisp.newlineAndFormat", newlineAndFormat)); 177 | context.subscriptions.push(vscode.window.onDidCloseTerminal(async (terminal) => { 178 | if (terminal == repl) { 179 | repl = null; 180 | repl = await startLSP(); 181 | } 182 | })); 183 | } 184 | 185 | export function deactivate() { 186 | } 187 | -------------------------------------------------------------------------------- /syntaxes/commonlisp.tmLanguage: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | comment 6 | Bastien Dejean, june 2010 7 | fileTypes 8 | 9 | lisp 10 | lsp 11 | asd 12 | asdf 13 | cl 14 | ros 15 | 16 | firstLineMatch 17 | ^(?i:;+\s*-\*-\s*(mode:)?\s*lisp.*-\*-.*)$ 18 | foldingStartMarker 19 | ^\( 20 | foldingStopMarker 21 | ^\s*$ 22 | keyEquivalent 23 | ^~L 24 | name 25 | Common Lisp 26 | patterns 27 | 28 | 29 | include 30 | #atom 31 | 32 | 33 | include 34 | #list 35 | 36 | 37 | include 38 | #comment 39 | 40 | 41 | repository 42 | 43 | atom 44 | 45 | patterns 46 | 47 | 48 | include 49 | #number 50 | 51 | 52 | include 53 | #symbol 54 | 55 | 56 | include 57 | #misc 58 | 59 | 60 | 61 | comment 62 | 63 | patterns 64 | 65 | 66 | begin 67 | #\| 68 | beginCaptures 69 | 70 | 0 71 | 72 | name 73 | punctuation.definition.block-comment.begin.lisp 74 | 75 | 76 | end 77 | \|# 78 | endCaptures 79 | 80 | 0 81 | 82 | name 83 | punctuation.definition.block-comment.end.lisp 84 | 85 | 86 | name 87 | comment.block.lisp 88 | patterns 89 | 90 | 91 | include 92 | #comment 93 | 94 | 95 | include 96 | #link 97 | 98 | 99 | 100 | 101 | match 102 | ;.*$ 103 | name 104 | comment.line.lisp 105 | 106 | 107 | 108 | link 109 | 110 | patterns 111 | 112 | 113 | match 114 | (?x) 115 | ( (https?|s?ftp|ftps|file|smb|afp|nfs|(x-)?man|gopher|txmt)://|mailto:) 116 | [-:@a-zA-Z0-9_.,~%+/?=&#]+(?<![.,?:]) 117 | 118 | name 119 | markup.underline.link.lisp 120 | 121 | 122 | 123 | list 124 | 125 | begin 126 | \( 127 | beginCaptures 128 | 129 | 0 130 | 131 | name 132 | punctuation.definition.list.begin.lisp 133 | 134 | 135 | end 136 | \) 137 | endCaptures 138 | 139 | 0 140 | 141 | name 142 | punctuation.definition.list.end.lisp 143 | 144 | 145 | name 146 | meta.list.lisp 147 | patterns 148 | 149 | 150 | include 151 | $self 152 | 153 | 154 | 155 | misc 156 | 157 | patterns 158 | 159 | 160 | begin 161 | " 162 | beginCaptures 163 | 164 | 0 165 | 166 | name 167 | punctuation.definition.string.begin.lisp 168 | 169 | 170 | end 171 | " 172 | endCaptures 173 | 174 | 0 175 | 176 | name 177 | punctuation.definition.string.end.lisp 178 | 179 | 180 | name 181 | string.quoted.double.lisp 182 | patterns 183 | 184 | 185 | match 186 | \\. 187 | name 188 | constant.character.escape.lisp 189 | 190 | 191 | match 192 | (?i:~(([+-]?\d+|'.|[v#])?,?)*(:?@?|@?:?)[crdboxefgptiasw%&(){}\[\]$*?|^<_>/;~]) 193 | name 194 | constant.character.format-directive.lisp 195 | 196 | 197 | include 198 | #link 199 | 200 | 201 | 202 | 203 | begin 204 | \| 205 | beginCaptures 206 | 207 | 0 208 | 209 | name 210 | punctuation.definition.symbol.begin.lisp 211 | 212 | 213 | end 214 | \| 215 | endCaptures 216 | 217 | 0 218 | 219 | name 220 | punctuation.definition.symbol.end.lisp 221 | 222 | 223 | name 224 | constant.other.symbol.lisp 225 | patterns 226 | 227 | 228 | include 229 | #link 230 | 231 | 232 | 233 | 234 | match 235 | (?<=[()\s]|^)\#\\([A-Za-z_\-]+|.(?=[()\s])) 236 | name 237 | constant.character.lisp 238 | 239 | 240 | match 241 | (?x: 242 | (?<=[()\s]|^) 243 | \#\d*\* 244 | [01]* 245 | (?=[()\s]|$) 246 | ) 247 | name 248 | constant.other.bit-vector.lisp 249 | 250 | 251 | match 252 | (?x: 253 | (?<=[()\s]|^) 254 | ( :[^()\s]+ ) 255 | ) 256 | name 257 | keyword.other.keyword.lisp 258 | 259 | 260 | match 261 | (?x: 262 | (?<=[()\s]|^) 263 | ( [^()\s]+:{1,2}[^()\s]+ ) 264 | ) 265 | name 266 | variable.other.external-symbol.lisp 267 | 268 | 269 | match 270 | (?xi: 271 | (?<=[()\s]|^) 272 | ( \#p ) 273 | ) 274 | name 275 | keyword.other.pathname.lisp 276 | 277 | 278 | match 279 | (?x: 280 | (?<=[()\s]|^) 281 | ( \#' ) 282 | ) 283 | name 284 | keyword.other.function.abbreviation.lisp 285 | 286 | 287 | match 288 | (?x: 289 | (?<=[()\s]|^) 290 | ( \#[+-] ) 291 | ) 292 | name 293 | keyword.other.read-time.conditional.lisp 294 | 295 | 296 | match 297 | (?xi: 298 | (?<=[()\s]|^) 299 | ( \#\d+a ) 300 | ) 301 | name 302 | keyword.other.array.lisp 303 | 304 | 305 | match 306 | (?xi: 307 | (?<=[()\s]|^) 308 | ( \#s ) 309 | (?=\() 310 | ) 311 | name 312 | keyword.other.structure.lisp 313 | 314 | 315 | match 316 | (?xi: 317 | (?<=[()\s]|^) 318 | ( \#\d* ) 319 | (?=\() 320 | ) 321 | name 322 | keyword.other.vector.lisp 323 | 324 | 325 | match 326 | (?x: 327 | (?<=[()\s]|^) 328 | ( \#\. ) 329 | ) 330 | name 331 | keyword.other.read-time.evaluation.lisp 332 | 333 | 334 | match 335 | (?x: 336 | (?<=[()\s]|^) 337 | ( \#, ) 338 | ) 339 | name 340 | keyword.other.load-time.evaluation.lisp 341 | 342 | 343 | match 344 | (?x: 345 | (?<=[()\s]|^) 346 | ( \#: ) 347 | ) 348 | name 349 | keyword.other.uninterned-symbol.lisp 350 | 351 | 352 | match 353 | (?x: 354 | (?<=[()\s]|^) 355 | ( \#[!?{}\[\]] ) 356 | ) 357 | name 358 | keyword.other.definable.reader-macro.lisp 359 | 360 | 361 | match 362 | (?x: 363 | (?<=[()\s]|^) 364 | ( \#\d+[=#] ) 365 | ) 366 | name 367 | keyword.other.object-definition.lisp 368 | 369 | 370 | match 371 | (?x: 372 | (?<=[()\s]|^) 373 | ( ['`] | ,[@.]? ) 374 | ) 375 | name 376 | keyword.other.special.lisp 377 | 378 | 379 | match 380 | \#< 381 | name 382 | invalid.illegal.lisp 383 | 384 | 385 | 386 | number 387 | 388 | patterns 389 | 390 | 391 | match 392 | (?xi: 393 | 394 | (?<=[()\s]|^) 395 | [+-]? 396 | ( 397 | \d+ 398 | ( / 399 | \d+)? | 400 | \d+ 401 | ( \. 402 | \d*)? 403 | ( [esfdl] 404 | [+-]? \d+)? 405 | ) 406 | (?=[()\s]|$) 407 | ) 408 | name 409 | constant.numeric.lisp 410 | 411 | 412 | match 413 | (?xi: 414 | (?<=[()\s]|^) 415 | \#c 416 | \s* 417 | \( 418 | [^)]* 419 | \s+ 420 | [^)]* 421 | \) 422 | (?=[()\s]|$) 423 | ) 424 | name 425 | constant.numeric.complex.lisp 426 | 427 | 428 | match 429 | (?xi: 430 | (?<=[()\s]|^) 431 | \#x 432 | [+-]? 433 | [0-9a-f]+ 434 | ( / 435 | [0-9a-f]+)? 436 | (?=[()\s]|$) 437 | ) 438 | name 439 | constant.numeric.hexidecimal.lisp 440 | 441 | 442 | match 443 | (?xi: 444 | (?<=[()\s]|^) 445 | \#o 446 | [+-]? 447 | [0-7]+ 448 | ( / 449 | [0-7]+)? 450 | (?=[()\s]|$) 451 | 452 | ) 453 | name 454 | constant.numeric.octal.lisp 455 | 456 | 457 | match 458 | (?xi: 459 | (?<=[()\s]|^) 460 | \#b 461 | [+-]? 462 | [01]+ 463 | ( / 464 | [01]+)? 465 | (?=[()\s]|$) 466 | ) 467 | name 468 | constant.numeric.binary.lisp 469 | 470 | 471 | match 472 | (?xi: 473 | (?<=[()\s]|^) 474 | \# \d+ r 475 | [+-]? 476 | [0-9a-z]+ 477 | ( / 478 | [0-9a-z]+)? 479 | (?=[()\s]|$) 480 | ) 481 | name 482 | constant.numeric.general-base.lisp 483 | 484 | 485 | 486 | symbol 487 | 488 | patterns 489 | 490 | 491 | match 492 | (?xi: 493 | (?<=[()\s]|^) 494 | ( nil | t ) 495 | (?=[()\s]|$) 496 | ) 497 | name 498 | constant.language.lisp 499 | 500 | 501 | captures 502 | 503 | 1 504 | 505 | name 506 | storage.type.function.lisp 507 | 508 | 2 509 | 510 | name 511 | entity.name.function.lisp 512 | 513 | 514 | match 515 | (?xi: 516 | (?<=\(|\#') 517 | ( defun | defmacro | defmethod ) 518 | \s+ 519 | ( [^\s()]+ ) 520 | ) 521 | name 522 | meta.storage.type.function.lisp 523 | 524 | 525 | captures 526 | 527 | 1 528 | 529 | name 530 | storage.type.variable.lisp 531 | 532 | 2 533 | 534 | name 535 | variable.other.lisp 536 | 537 | 538 | match 539 | (?xi: 540 | (?<=\(|\#') 541 | ( defvar | defconstant | defparameter ) 542 | \s+ 543 | ( [^\s()]+ ) 544 | ) 545 | name 546 | meta.storage.type.variable.lisp 547 | 548 | 549 | captures 550 | 551 | 1 552 | 553 | name 554 | storage.type.class.lisp 555 | 556 | 2 557 | 558 | name 559 | entity.name.class.lisp 560 | 561 | 562 | match 563 | (?xi: 564 | (?<=\(|\#') 565 | ( defclass ) 566 | \s+ 567 | ( [^\s()]+ ) 568 | ) 569 | name 570 | meta.storage.type.class.lisp 571 | 572 | 573 | captures 574 | 575 | 1 576 | 577 | name 578 | storage.type.type.lisp 579 | 580 | 2 581 | 582 | name 583 | entity.name.type.lisp 584 | 585 | 586 | match 587 | (?xi: 588 | (?<=\(|\#') 589 | ( deftype ) 590 | \s+ 591 | ( [^\s()]+ ) 592 | ) 593 | name 594 | meta.storage.type.class.lisp 595 | 596 | 597 | captures 598 | 599 | 1 600 | 601 | name 602 | storage.type.structure.lisp 603 | 604 | 2 605 | 606 | name 607 | entity.name.structure.lisp 608 | 609 | 610 | match 611 | (?xi: 612 | (?<=\(|\#') 613 | ( defstruct ) 614 | \s+ 615 | ( [^\s()]+ ) 616 | ) 617 | name 618 | meta.storage.type.class.lisp 619 | 620 | 621 | match 622 | (?xi: 623 | (?<=\(|\#') 624 | ( defstruct ) 625 | (?=\s\() 626 | ) 627 | name 628 | storage.type.structure.lisp 629 | 630 | 631 | match 632 | (?xi: 633 | (?<=\(defstruct\s\() 634 | ( [^\s()]+ ) 635 | ) 636 | name 637 | entity.name.structure.structure.lisp 638 | 639 | 640 | match 641 | (?xi: 642 | (?<=\(|\#') 643 | ( defun ) 644 | (?=\s\(setf) 645 | ) 646 | name 647 | storage.type.function.lisp 648 | 649 | 650 | match 651 | (?xi: 652 | (?<=\(|\#') 653 | ( \* | \+ | - | / | 1\+ | 1- | do | ed | go | if | or | abs | and | ash | bit | car | cdr | cis | cos | do\* | dpb | elt | exp | gcd | get | lcm | ldb | let | log | map | max | min | mod | not | nth | pop | rem | set | sin | tan | the | acos | aref | asin | atan | byte | caar | cadr | case | cdar | cddr | char | cond | cons | cosh | decf | eval | expt | fill | find | flet | getf | incf | last | let\* | list | load | loop | mapc | mapl | prog | push | real | remf | rest | room | sbit | setf | setq | sinh | some | sort | sqrt | step | tanh | time | type | warn | when | abort | acons | acosh | apply | array | asinh | assoc | atanh | block | boole | break | caaar | caadr | cadar | caddr | catch | ccase | cdaar | cdadr | cddar | cdddr | class | count | debug | ecase | error | every | fifth | first | float | floor | ftype | isqrt | ldiff | list\* | merge | nconc | ninth | phase | prog\* | prog1 | prog2 | progn | progv | psetf | psetq | quote | ratio | round | schar | sixth | sleep | space | speed | subst | svref | tenth | third | throw | trace | union | adjoin | append | assert | bignum | caaaar | caaadr | caadar | caaddr | cadaar | cadadr | caddar | cadddr | cdaaar | cdaadr | cdadar | cdaddr | cddaar | cddadr | cdddar | cddddr | cerror | coerce | delete | dolist | eighth | export | ffloor | fixnum | fourth | fround | gensym | ignore | import | inline | intern | labels | lambda | length | logand | logeqv | logior | lognor | lognot | logxor | mapcan | mapcar | mapcon | member | method | notany | nsubst | nthcdr | number | nunion | random | rassoc | reduce | remove | return | rplaca | rplacd | safety | search | second | shadow | shiftf | signal | signum | string | sublis | subseq | sxhash | symbol | unless | values | vector | apropos | bit-and | bit-eqv | bit-ior | bit-nor | bit-not | bit-xor | boolean | butlast | ceiling | clrhash | compile | complex | declaim | declare | defsetf | dotimes | dribble | find-if | funcall | gentemp | gethash | inspect | integer | keyword | locally | lognand | logorc1 | logorc2 | logtest | maphash | maplist | nreconc | nsublis | package | pairlis | provide | pushnew | remhash | remprop | replace | require | restart | reverse | rotatef | seventh | special | tagbody | type-of | untrace | warning | assoc-if | bit-nand | bit-orc1 | bit-orc2 | char-int | class-of | continue | copy-seq | count-if | describe | fceiling | function | identity | imagpart | ldb-test | logandc1 | logandc2 | logcount | macrolet | map-into | mismatch | nbutlast | notevery | nreverse | optimize | position | proclaim | rational | realpart | sequence | standard | subst-if | truename | truncate | typecase | unexport | unintern | variable | base-char | bit-andc1 | bit-andc2 | byte-size | char-code | char-name | character | code-char | condition | conjugate | copy-list | copy-tree | ctypecase | delete-if | etypecase | eval-when | ftruncate | ignorable | make-list | member-if | name-char | notinline | nsubst-if | nth-value | numerator | otherwise | rassoc-if | remove-if | revappend | satisfies | structure | use-value | add-method | array-rank | bit-vector | cell-error | check-type | class-name | complement | constantly | copy-alist | defgeneric | defpackage | digit-char | do-symbols | find-class | float-sign | hash-table | in-package | long-float | make-array | makunbound | mask-field | namestring | slot-value | substitute | type-error | vector-pop | with-slots | base-string | call-method | char-upcase | concatenate | copy-symbol | declaration | denominator | disassemble | fdefinition | find-if-not | find-method | find-symbol | float-radix | fmakunbound | list-length | loop-finish | macroexpand | make-method | make-string | make-symbol | nsubstitute | parse-error | position-if | rationalize | return-from | scale-float | short-float | signed-byte | stable-sort | store-value | string-trim | symbol-name | use-package | values-list | vector-push | adjust-array | apropos-list | assoc-if-not | change-class | compile-file | count-if-not | decode-float | double-float | fill-pointer | find-package | find-restart | float-digits | handler-bind | handler-case | intersection | machine-type | make-package | package-name | random-state | restart-bind | restart-case | restart-name | simple-array | simple-error | single-float | slot-missing | slot-unbound | subst-if-not | symbol-plist | symbol-value | unbound-slot | byte-position | char-downcase | control-error | delete-if-not | deposit-field | documentation | extended-char | ignore-errors | macroexpand-1 | make-instance | make-sequence | member-if-not | nintersection | nsubst-if-not | package-error | parse-integer | program-error | rassoc-if-not | remove-if-not | remove-method | simple-string | simple-vector | software-type | standard-char | string-upcase | style-warning | substitute-if | unsigned-byte | unuse-package | built-in-class | compiler-macro | copy-structure | delete-package | do-all-symbols | dynamic-extent | get-properties | integer-length | invoke-restart | long-site-name | macro-function | make-condition | make-load-form | muffle-warning | no-next-method | nstring-upcase | nsubstitute-if | rename-package | row-major-aref | set-difference | simple-warning | standard-class | symbol-package | unwind-protect | with-accessors | array-dimension | cell-error-name | describe-object | float-precision | hash-table-size | hash-table-test | host-namestring | invoke-debugger | load-time-value | machine-version | make-hash-table | nset-difference | position-if-not | short-site-name | slot-makunbound | standard-method | standard-object | string-downcase | structure-class | symbol-function | symbol-macrolet | arithmetic-error | array-dimensions | array-total-size | call-next-method | compute-restarts | define-condition | division-by-zero | find-all-symbols | generic-function | get-decoded-time | hash-table-count | machine-instance | nstring-downcase | package-use-list | parse-namestring | set-exclusive-or | shadowing-import | simple-condition | software-version | string-left-trim | structure-object | type-error-datum | unbound-variable | allocate-instance | compilation-speed | compiled-function | delete-duplicates | enough-namestring | function-keywords | list-all-packages | make-random-state | method-qualifiers | nset-exclusive-or | package-nicknames | remove-duplicates | serious-condition | shared-initialize | simple-bit-vector | simple-type-error | storage-condition | string-capitalize | string-right-trim | substitute-if-not | array-displacement | array-element-type | destructuring-bind | get-setf-expansion | get-universal-time | method-combination | nstring-capitalize | nsubstitute-if-not | simple-base-string | undefined-function | vector-push-extend | define-modify-macro | define-symbol-macro | do-external-symbols | get-macro-character | initialize-instance | multiple-value-bind | multiple-value-call | multiple-value-list | multiple-value-setq | set-macro-character | with-simple-restart | define-setf-expander | integer-decode-float | invalid-method-error | multiple-value-prog1 | no-applicable-method | package-used-by-list | set-syntax-from-char | array-row-major-index | compile-file-pathname | decode-universal-time | define-compiler-macro | encode-universal-time | get-internal-run-time | package-error-package | reinitialize-instance | unbound-slot-instance | with-compilation-unit | with-package-iterator | floating-point-inexact | get-internal-real-time | hash-table-rehash-size | compiler-macro-function | ensure-generic-function | floating-point-overflow | make-instances-obsolete | with-condition-restarts | floating-point-underflow | lisp-implementation-type | method-combination-error | type-error-expected-type | with-hash-table-iterator | arithmetic-error-operands | define-method-combination | package-shadowing-symbols | standard-generic-function | arithmetic-error-operation | compute-applicable-methods | function-lambda-expression | upgraded-complex-part-type | hash-table-rehash-threshold | lisp-implementation-version | make-load-form-saving-slots | upgraded-array-element-type | get-dispatch-macro-character | invoke-restart-interactively | set-dispatch-macro-character | make-dispatch-macro-character | simple-condition-format-control | floating-point-invalid-operation | simple-condition-format-arguments | update-instance-for-different-class | update-instance-for-redefined-class ) 654 | (?=[()\s]) 655 | ) 656 | name 657 | entity.name.function.misc.lisp 658 | 659 | 660 | match 661 | (?xi: 662 | (?<=\(|\#') 663 | ( load | open | read | close | prin1 | princ | print | write | format | listen | pprint | stream | terpri | require | pathname | truename | directory | formatter | peek-char | read-byte | read-char | read-line | readtable | file-error | fresh-line | namestring | pprint-pop | pprint-tab | probe-file | write-byte | write-char | write-line | clear-input | delete-file | echo-stream | end-of-file | file-author | file-length | file-stream | pprint-fill | rename-file | unread-char | clear-output | compile-file | force-output | print-object | reader-error | stream-error | write-string | file-position | finish-output | make-pathname | pathname-host | pathname-name | pathname-type | pprint-indent | pprint-linear | read-sequence | string-stream | copy-readtable | pprint-newline | pprint-tabular | readtable-case | synonym-stream | two-way-stream | with-open-file | write-sequence | file-namestring | file-write-date | host-namestring | merge-pathnames | pathname-device | pprint-dispatch | prin1-to-string | princ-to-string | write-to-string | broadcast-stream | logical-pathname | make-echo-stream | parse-namestring | pathname-version | read-from-string | with-open-stream | enough-namestring | read-char-no-hang | file-string-length | pathname-directory | print-not-readable | translate-pathname | concatenated-stream | file-error-pathname | make-synonym-stream | make-two-way-stream | read-delimited-list | set-pprint-dispatch | stream-element-type | stream-error-stream | copy-pprint-dispatch | directory-namestring | pprint-logical-block | compile-file-pathname | make-broadcast-stream | synonym-stream-symbol | user-homedir-pathname | with-output-to-string | stream-external-format | with-input-from-string | print-unreadable-object | with-standard-io-syntax | broadcast-stream-streams | echo-stream-input-stream | ensure-directories-exist | get-output-stream-string | make-concatenated-stream | make-string-input-stream | echo-stream-output-stream | make-string-output-stream | print-not-readable-object | read-preserving-whitespace | translate-logical-pathname | concatenated-stream-streams | two-way-stream-input-stream | two-way-stream-output-stream | logical-pathname-translations | pprint-exit-if-list-exhausted | load-logical-pathname-translations ) 664 | (?=[()\s]) 665 | ) 666 | name 667 | entity.name.function.io.lisp 668 | 669 | 670 | match 671 | (?xi: 672 | (?<=\(|\#') 673 | ( < | = | > | /= | <= | >= | eq | eql | atom | endp | null | oddp | char< | char= | char> | consp | equal | evenp | listp | plusp | realp | tailp | typep | zerop | arrayp | boundp | char/= | char<= | char>= | equalp | floatp | minusp | fboundp | logbitp | numberp | streamp | string< | string= | string> | stringp | subsetp | symbolp | vectorp | complexp | integerp | keywordp | packagep | string/= | string<= | string>= | subtypep | y-or-n-p | constantp | functionp | pathnamep | rationalp | char-equal | char-lessp | characterp | readtablep | tree-equal | both-case-p | slot-boundp | yes-or-no-p | alpha-char-p | bit-vector-p | digit-char-p | hash-table-p | lower-case-p | string-equal | string-lessp | upper-case-p | alphanumericp | char-greaterp | next-method-p | open-stream-p | slot-exists-p | char-not-equal | char-not-lessp | graphic-char-p | input-stream-p | random-state-p | output-stream-p | simple-string-p | simple-vector-p | standard-char-p | string-greaterp | wild-pathname-p | pathname-match-p | string-not-equal | string-not-lessp | array-in-bounds-p | char-not-greaterp | adjustable-array-p | special-operator-p | compiled-function-p | simple-bit-vector-p | string-not-greaterp | interactive-stream-p | array-has-fill-pointer-p ) 674 | (?=[()\s]) 675 | ) 676 | name 677 | entity.name.function.predicate.lisp 678 | 679 | 680 | match 681 | (?xi: 682 | (?<=[()\s]|^) 683 | & ( optional | rest | key | whole | body | aux | environment | allow-other-keys ) 684 | (?=[()\s]|$) 685 | ) 686 | name 687 | storage.modifier.function.lisp 688 | 689 | 690 | match 691 | (?x: 692 | (?<=[()\s]|^) 693 | ([*+%]) 694 | [^\s()]* 695 | \1 696 | (?=[()\s]|$) 697 | ) 698 | name 699 | variable.other.special.lisp 700 | 701 | 702 | match 703 | (?xi: 704 | (?<=[()\s]|^) 705 | ( pi | boole-1 | boole-2 | boole-c1 | boole-c2 | boole-and | boole-clr | boole-eqv | boole-ior | boole-nor | boole-set | boole-xor | boole-nand | boole-orc1 | boole-orc2 | boole-andc1 | boole-andc2 | char-code-limit | array-rank-limit | long-float-epsilon | short-float-epsilon | call-arguments-limit | double-float-epsilon | lambda-list-keywords | most-negative-fixnum | most-positive-fixnum | single-float-epsilon | array-dimension-limit | multiple-values-limit | array-total-size-limit | lambda-parameters-limit | most-negative-long-float | most-positive-long-float | least-negative-long-float | least-positive-long-float | most-negative-short-float | most-positive-short-float | least-negative-short-float | least-positive-short-float | most-negative-double-float | most-negative-single-float | most-positive-double-float | most-positive-single-float | least-negative-double-float | least-negative-single-float | least-positive-double-float | least-positive-single-float | long-float-negative-epsilon | short-float-negative-epsilon | double-float-negative-epsilon | single-float-negative-epsilon | internal-time-units-per-second | least-negative-normalized-long-float | least-positive-normalized-long-float | least-negative-normalized-short-float | least-positive-normalized-short-float | least-negative-normalized-double-float | least-negative-normalized-single-float | least-positive-normalized-double-float | least-positive-normalized-single-float ) 706 | (?=[()\s]|$) 707 | ) 708 | name 709 | constant.language.other.lisp 710 | 711 | 712 | 713 | 714 | scopeName 715 | source.commonlisp 716 | uuid 717 | CECF0080-7B0C-46DD-BAC6-AE2FA80F81EC 718 | 719 | 720 | --------------------------------------------------------------------------------