198 lines
4.8 KiB
Plaintext
198 lines
4.8 KiB
Plaintext
(function (Prism) {
|
|
/**
|
|
* Functions to construct regular expressions
|
|
* e.g. (interactive ... or (interactive)
|
|
*
|
|
* @param {string} name
|
|
* @returns {RegExp}
|
|
*/
|
|
function simple_form(name) {
|
|
return RegExp(/(\()/.source + '(?:' + name + ')' + /(?=[\s\)])/.source);
|
|
}
|
|
/**
|
|
* booleans and numbers
|
|
*
|
|
* @param {string} pattern
|
|
* @returns {RegExp}
|
|
*/
|
|
function primitive(pattern) {
|
|
return RegExp(/([\s([])/.source + '(?:' + pattern + ')' + /(?=[\s)])/.source);
|
|
}
|
|
|
|
// Patterns in regular expressions
|
|
|
|
// Symbol name. See https://www.gnu.org/software/emacs/manual/html_node/elisp/Symbol-Type.html
|
|
// & and : are excluded as they are usually used for special purposes
|
|
var symbol = /(?!\d)[-+*/~!@$%^=<>{}\w]+/.source;
|
|
// symbol starting with & used in function arguments
|
|
var marker = '&' + symbol;
|
|
// Open parenthesis for look-behind
|
|
var par = '(\\()';
|
|
var endpar = '(?=\\))';
|
|
// End the pattern with look-ahead space
|
|
var space = '(?=\\s)';
|
|
var nestedPar = /(?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))*\))*\))*/.source;
|
|
|
|
var language = {
|
|
// Three or four semicolons are considered a heading.
|
|
// See https://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html
|
|
heading: {
|
|
pattern: /;;;.*/,
|
|
alias: ['comment', 'title']
|
|
},
|
|
comment: /;.*/,
|
|
string: {
|
|
pattern: /"(?:[^"\\]|\\.)*"/,
|
|
greedy: true,
|
|
inside: {
|
|
argument: /[-A-Z]+(?=[.,\s])/,
|
|
symbol: RegExp('`' + symbol + "'")
|
|
}
|
|
},
|
|
'quoted-symbol': {
|
|
pattern: RegExp("#?'" + symbol),
|
|
alias: ['variable', 'symbol']
|
|
},
|
|
'lisp-property': {
|
|
pattern: RegExp(':' + symbol),
|
|
alias: 'property'
|
|
},
|
|
splice: {
|
|
pattern: RegExp(',@?' + symbol),
|
|
alias: ['symbol', 'variable']
|
|
},
|
|
keyword: [
|
|
{
|
|
pattern: RegExp(
|
|
par +
|
|
'(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)' +
|
|
space
|
|
),
|
|
lookbehind: true
|
|
},
|
|
{
|
|
pattern: RegExp(
|
|
par + '(?:append|by|collect|concat|do|finally|for|in|return)' + space
|
|
),
|
|
lookbehind: true
|
|
},
|
|
],
|
|
declare: {
|
|
pattern: simple_form(/declare/.source),
|
|
lookbehind: true,
|
|
alias: 'keyword'
|
|
},
|
|
interactive: {
|
|
pattern: simple_form(/interactive/.source),
|
|
lookbehind: true,
|
|
alias: 'keyword'
|
|
},
|
|
boolean: {
|
|
pattern: primitive(/nil|t/.source),
|
|
lookbehind: true
|
|
},
|
|
number: {
|
|
pattern: primitive(/[-+]?\d+(?:\.\d*)?/.source),
|
|
lookbehind: true
|
|
},
|
|
defvar: {
|
|
pattern: RegExp(par + 'def(?:const|custom|group|var)\\s+' + symbol),
|
|
lookbehind: true,
|
|
inside: {
|
|
keyword: /^def[a-z]+/,
|
|
variable: RegExp(symbol)
|
|
}
|
|
},
|
|
defun: {
|
|
pattern: RegExp(par + /(?:cl-)?(?:defmacro|defun\*?)\s+/.source + symbol + /\s+\(/.source + nestedPar + /\)/.source),
|
|
lookbehind: true,
|
|
greedy: true,
|
|
inside: {
|
|
keyword: /^(?:cl-)?def\S+/,
|
|
// See below, this property needs to be defined later so that it can
|
|
// reference the language object.
|
|
arguments: null,
|
|
function: {
|
|
pattern: RegExp('(^\\s)' + symbol),
|
|
lookbehind: true
|
|
},
|
|
punctuation: /[()]/
|
|
}
|
|
},
|
|
lambda: {
|
|
pattern: RegExp(par + 'lambda\\s+\\(\\s*(?:&?' + symbol + '(?:\\s+&?' + symbol + ')*\\s*)?\\)'),
|
|
lookbehind: true,
|
|
greedy: true,
|
|
inside: {
|
|
keyword: /^lambda/,
|
|
// See below, this property needs to be defined later so that it can
|
|
// reference the language object.
|
|
arguments: null,
|
|
punctuation: /[()]/
|
|
}
|
|
},
|
|
car: {
|
|
pattern: RegExp(par + symbol),
|
|
lookbehind: true
|
|
},
|
|
punctuation: [
|
|
// open paren, brackets, and close paren
|
|
/(?:['`,]?\(|[)\[\]])/,
|
|
// cons
|
|
{
|
|
pattern: /(\s)\.(?=\s)/,
|
|
lookbehind: true
|
|
},
|
|
]
|
|
};
|
|
|
|
var arg = {
|
|
'lisp-marker': RegExp(marker),
|
|
'varform': {
|
|
pattern: RegExp(/\(/.source + symbol + /\s+(?=\S)/.source + nestedPar + /\)/.source),
|
|
inside: language
|
|
},
|
|
'argument': {
|
|
pattern: RegExp(/(^|[\s(])/.source + symbol),
|
|
lookbehind: true,
|
|
alias: 'variable'
|
|
},
|
|
rest: language
|
|
};
|
|
|
|
var forms = '\\S+(?:\\s+\\S+)*';
|
|
|
|
var arglist = {
|
|
pattern: RegExp(par + nestedPar + endpar),
|
|
lookbehind: true,
|
|
inside: {
|
|
'rest-vars': {
|
|
pattern: RegExp('&(?:body|rest)\\s+' + forms),
|
|
inside: arg
|
|
},
|
|
'other-marker-vars': {
|
|
pattern: RegExp('&(?:aux|optional)\\s+' + forms),
|
|
inside: arg
|
|
},
|
|
keys: {
|
|
pattern: RegExp('&key\\s+' + forms + '(?:\\s+&allow-other-keys)?'),
|
|
inside: arg
|
|
},
|
|
argument: {
|
|
pattern: RegExp(symbol),
|
|
alias: 'variable'
|
|
},
|
|
punctuation: /[()]/
|
|
}
|
|
};
|
|
|
|
language['lambda'].inside.arguments = arglist;
|
|
language['defun'].inside.arguments = Prism.util.clone(arglist);
|
|
language['defun'].inside.arguments.inside.sublist = arglist;
|
|
|
|
Prism.languages.lisp = language;
|
|
Prism.languages.elisp = language;
|
|
Prism.languages.emacs = language;
|
|
Prism.languages['emacs-lisp'] = language;
|
|
}(Prism));
|