mirror of https://github.com/sgoudham/carbon.git
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
639 lines
12 KiB
JavaScript
639 lines
12 KiB
JavaScript
/* eslint-disable */
|
|
const CodeMirror = require('codemirror')
|
|
|
|
CodeMirror.defineMode('nimrod', function(conf, parserConf) {
|
|
var ERRORCLASS = 'error'
|
|
|
|
function wordRegexp(words) {
|
|
return new RegExp('^((' + words.join(')|(') + '))\\b')
|
|
}
|
|
|
|
var ops = [
|
|
'=',
|
|
'+',
|
|
'-',
|
|
'*',
|
|
'/',
|
|
'<',
|
|
'>',
|
|
'@',
|
|
'$',
|
|
'~',
|
|
'&',
|
|
'%',
|
|
'|',
|
|
'?',
|
|
'^',
|
|
':',
|
|
'\\',
|
|
'[',
|
|
']',
|
|
'(',
|
|
')',
|
|
',',
|
|
'{',
|
|
'}',
|
|
'.\\.',
|
|
'.'
|
|
]
|
|
var operators = new RegExp(
|
|
ops
|
|
.map(function(op) {
|
|
return '\\' + op
|
|
})
|
|
.join('|')
|
|
)
|
|
var identifiers = new RegExp('^[_A-Za-z][_A-Za-z0-9]*')
|
|
|
|
var commonkeywords = [
|
|
'addr',
|
|
'asm',
|
|
'atomic',
|
|
'bind',
|
|
'block',
|
|
'break',
|
|
'case',
|
|
'cast',
|
|
'const',
|
|
'continue',
|
|
'converter',
|
|
'discard',
|
|
'distinct',
|
|
'do',
|
|
'elif',
|
|
'else',
|
|
'end',
|
|
'enum',
|
|
'except',
|
|
'export',
|
|
'finally',
|
|
'for',
|
|
'from',
|
|
'generic',
|
|
'if',
|
|
'import',
|
|
'include',
|
|
'interface',
|
|
'iterator',
|
|
'lambda',
|
|
'let',
|
|
'macro',
|
|
'method',
|
|
'mixin',
|
|
'nil',
|
|
'object',
|
|
'out',
|
|
'proc',
|
|
'ptr',
|
|
'raise',
|
|
'ref',
|
|
'return',
|
|
'shared',
|
|
'static',
|
|
'template',
|
|
'try',
|
|
'tuple',
|
|
'type',
|
|
'using',
|
|
'var',
|
|
'when',
|
|
'while',
|
|
'with',
|
|
'without',
|
|
'yield',
|
|
|
|
// keyword operators
|
|
'shl',
|
|
'shr',
|
|
'and',
|
|
'or',
|
|
'xor',
|
|
'not',
|
|
'div',
|
|
'mod',
|
|
'is',
|
|
'isnot',
|
|
'in',
|
|
'as',
|
|
'of'
|
|
]
|
|
|
|
var commonBuiltins = [
|
|
'int',
|
|
'int8',
|
|
'int16',
|
|
'int32',
|
|
'int64',
|
|
'uint',
|
|
'uint8',
|
|
'uint16',
|
|
'uint32',
|
|
'uint64',
|
|
'float',
|
|
'float32',
|
|
'float64',
|
|
'bool',
|
|
'char',
|
|
'string',
|
|
'cstring',
|
|
'pointer',
|
|
'range',
|
|
'array',
|
|
'openarray',
|
|
'seq',
|
|
'set',
|
|
'Byte',
|
|
'Natural',
|
|
'Positive',
|
|
'TObject',
|
|
'PObject',
|
|
'Conversion',
|
|
'TResult',
|
|
'TAddress',
|
|
'BiggestInt',
|
|
'BiggestFloat',
|
|
'cchar',
|
|
'cschar',
|
|
'cshort',
|
|
'cint',
|
|
'csize',
|
|
'cuchar',
|
|
'cushort',
|
|
'clong',
|
|
'clonglong',
|
|
'cfloat',
|
|
'cdouble',
|
|
'clongdouble',
|
|
'cuint',
|
|
'culong',
|
|
'culonglong',
|
|
'cchar',
|
|
'cstringArray',
|
|
'TEndian',
|
|
'PFloat32',
|
|
'PFloat64',
|
|
'PInt64',
|
|
'PInt32',
|
|
'TGC_Strategy',
|
|
'TFile',
|
|
'TFileMode',
|
|
'TFileHandle',
|
|
'isMainModule',
|
|
'CompileDate',
|
|
'CompileTime',
|
|
'NimrodVersion',
|
|
'NimrodMajor',
|
|
'NimrodMinor',
|
|
'NimrodPatch',
|
|
'cpuEndian',
|
|
'hostOS',
|
|
'hostCPU',
|
|
'inf',
|
|
'neginf',
|
|
'nan',
|
|
'QuitSuccess',
|
|
'QuitFailure',
|
|
'dbgLineHook',
|
|
'stdin',
|
|
'stdout',
|
|
'stderr',
|
|
'defined',
|
|
'new',
|
|
'high',
|
|
'low',
|
|
'sizeof',
|
|
'succ',
|
|
'pred',
|
|
'inc',
|
|
'dec',
|
|
'newSeq',
|
|
'len',
|
|
'incl',
|
|
'excl',
|
|
'card',
|
|
'ord',
|
|
'chr',
|
|
'ze',
|
|
'ze64',
|
|
'toU8',
|
|
'toU16',
|
|
'toU32',
|
|
'abs',
|
|
'min',
|
|
'max',
|
|
'add',
|
|
'repr',
|
|
'contains',
|
|
'toFloat',
|
|
'toBiggestFloat',
|
|
'toInt',
|
|
'toBiggestInt',
|
|
'addQuitProc',
|
|
'copy',
|
|
'setLen',
|
|
'newString',
|
|
'zeroMem',
|
|
'copyMem',
|
|
'moveMem',
|
|
'equalMem',
|
|
'alloc',
|
|
'alloc0',
|
|
'realloc',
|
|
'dealloc',
|
|
'setLen',
|
|
'assert',
|
|
'swap',
|
|
'getRefcount',
|
|
'getCurrentException',
|
|
'Msg',
|
|
'getOccupiedMem',
|
|
'getFreeMem',
|
|
'getTotalMem',
|
|
'isNil',
|
|
'seqToPtr',
|
|
'find',
|
|
'pop',
|
|
'GC_disable',
|
|
'GC_enable',
|
|
'GC_fullCollect',
|
|
'GC_setStrategy',
|
|
'GC_enableMarkAnd',
|
|
'Sweep',
|
|
'GC_disableMarkAnd',
|
|
'Sweep',
|
|
'GC_getStatistics',
|
|
'GC_ref',
|
|
'GC_ref',
|
|
'GC_ref',
|
|
'GC_unref',
|
|
'GC_unref',
|
|
'GC_unref',
|
|
'quit',
|
|
'OpenFile',
|
|
'OpenFile',
|
|
'CloseFile',
|
|
'EndOfFile',
|
|
'readChar',
|
|
'FlushFile',
|
|
'readFile',
|
|
'write',
|
|
'readLine',
|
|
'writeln',
|
|
'writeln',
|
|
'getFileSize',
|
|
'ReadBytes',
|
|
'ReadChars',
|
|
'readBuffer',
|
|
'writeBytes',
|
|
'writeChars',
|
|
'writeBuffer',
|
|
'setFilePos',
|
|
'getFilePos',
|
|
'fileHandle',
|
|
'countdown',
|
|
'countup',
|
|
'items',
|
|
'lines',
|
|
'true',
|
|
'false',
|
|
|
|
// exceptions
|
|
'E_Base',
|
|
'EAsynch',
|
|
'ESynch',
|
|
'ESystem',
|
|
'EIO',
|
|
'EOS',
|
|
'ERessourceExhausted',
|
|
'EArithmetic',
|
|
'EDivByZero',
|
|
'EOverflow',
|
|
'EAccessViolation',
|
|
'EAssertionFailed',
|
|
'EControlC',
|
|
'EInvalidValue',
|
|
'EOutOfMemory',
|
|
'EInvalidIndex',
|
|
'EInvalidField',
|
|
'EOutOfRange',
|
|
'EStackOverflow',
|
|
'ENoExceptionToReraise',
|
|
'EInvalidObjectAssignment',
|
|
'EInvalidObject',
|
|
'EInvalidLibrary',
|
|
'EInvalidKey',
|
|
'EInvalidObjectConversion',
|
|
'EFloatingPoint',
|
|
'EFloatInvalidOp',
|
|
'EFloatDivByZero',
|
|
'EFloatOverflow',
|
|
'EFloatInexact',
|
|
'EDeadThrea'
|
|
]
|
|
|
|
if (parserConf.extra_keywords != undefined)
|
|
commonkeywords = commonkeywords.concat(parserConf.extra_keywords)
|
|
|
|
if (parserConf.extra_builtins != undefined)
|
|
commonBuiltins = commonBuiltins.concat(parserConf.extra_builtins)
|
|
|
|
var keywords = wordRegexp(commonkeywords)
|
|
var builtins = wordRegexp(commonBuiltins)
|
|
|
|
var indentInfo = null
|
|
|
|
var stringPrefixes = new RegExp('^((\'{3}|"{3}|[\'"]))', 'i')
|
|
|
|
// tokenizers
|
|
function tokenBase(stream, state) {
|
|
// Handle scope changes
|
|
if (stream.sol()) {
|
|
var scopeOffset = state.scopes[0].offset
|
|
if (stream.eatSpace()) {
|
|
var lineOffset = stream.indentation()
|
|
if (lineOffset > scopeOffset) {
|
|
indentInfo = 'indent'
|
|
} else if (lineOffset < scopeOffset) {
|
|
indentInfo = 'dedent'
|
|
}
|
|
return null
|
|
} else {
|
|
if (scopeOffset > 0) {
|
|
dedent(stream, state)
|
|
}
|
|
}
|
|
}
|
|
|
|
if (stream.eatSpace()) return null
|
|
|
|
var ch = stream.peek()
|
|
|
|
// Handle Comments
|
|
if (ch === '#') {
|
|
stream.skipToEnd()
|
|
return 'comment'
|
|
}
|
|
|
|
// Handle Number Literals
|
|
if (stream.match(/^[0-9\.]/, false)) {
|
|
var floatLiteral = false
|
|
// Floats
|
|
if (stream.match(/^\d*\.\d+(e[\+\-]?\d+)?/i)) {
|
|
floatLiteral = true
|
|
}
|
|
if (stream.match(/^\d+\.\d*/)) {
|
|
floatLiteral = true
|
|
}
|
|
if (stream.match(/^\.\d+/)) {
|
|
floatLiteral = true
|
|
}
|
|
if (floatLiteral) {
|
|
// Float literals may be "imaginary"
|
|
stream.eat(/J/i)
|
|
return 'number'
|
|
}
|
|
// Integers
|
|
var intLiteral = false
|
|
// Hex
|
|
if (stream.match(/^0x[0-9a-f]+/i)) {
|
|
intLiteral = true
|
|
}
|
|
// Binary
|
|
if (stream.match(/^0b[01]+/i)) {
|
|
intLiteral = true
|
|
}
|
|
// Octal
|
|
if (stream.match(/^0o[0-7]+/i)) {
|
|
intLiteral = true
|
|
}
|
|
// Decimal
|
|
if (stream.match(/^[1-9]\d*(e[\+\-]?\d+)?/)) {
|
|
// Decimal literals may be "imaginary"
|
|
stream.eat(/J/i)
|
|
// TODO - Can you have imaginary longs?
|
|
intLiteral = true
|
|
}
|
|
// Zero by itself with no other piece of number.
|
|
if (stream.match(/^0(?![\dx])/i)) {
|
|
intLiteral = true
|
|
}
|
|
if (intLiteral) {
|
|
// Integer literals may be "long"
|
|
stream.eat(/L/i)
|
|
return 'number'
|
|
}
|
|
}
|
|
|
|
// Handle Strings
|
|
if (stream.match(stringPrefixes)) {
|
|
state.tokenize = tokenStringFactory(stream.current())
|
|
return state.tokenize(stream, state)
|
|
}
|
|
|
|
if (stream.match(operators)) return 'operator'
|
|
|
|
if (stream.match(keywords)) return 'keyword'
|
|
|
|
if (stream.match(builtins)) return 'builtin'
|
|
|
|
if (stream.match(identifiers)) {
|
|
if (
|
|
state.lastToken != null &&
|
|
state.lastToken.match(/proc|iterator|macro|template|class|converter/)
|
|
) {
|
|
return 'def'
|
|
}
|
|
|
|
return 'variable'
|
|
}
|
|
|
|
// Handle non-detected items
|
|
stream.next()
|
|
return ERRORCLASS
|
|
}
|
|
|
|
function tokenStringFactory(delimiter) {
|
|
var singleline = delimiter.length == 1
|
|
var OUTCLASS = 'string'
|
|
|
|
function tokenString(stream, state) {
|
|
while (!stream.eol()) {
|
|
stream.eatWhile(/[^'"\\]/)
|
|
if (stream.eat('\\')) {
|
|
stream.next()
|
|
if (singleline && stream.eol()) {
|
|
return OUTCLASS
|
|
}
|
|
} else if (stream.match(delimiter)) {
|
|
state.tokenize = tokenBase
|
|
return OUTCLASS
|
|
} else {
|
|
stream.eat(/['"]/)
|
|
}
|
|
}
|
|
if (singleline) {
|
|
if (parserConf.singleLineStringErrors) {
|
|
return ERRORCLASS
|
|
} else {
|
|
state.tokenize = tokenBase
|
|
}
|
|
}
|
|
return OUTCLASS
|
|
}
|
|
|
|
tokenString.isString = true
|
|
return tokenString
|
|
}
|
|
|
|
function indent(stream, state, type) {
|
|
type = type || 'nim'
|
|
var indentUnit = 0
|
|
if (type === 'nim') {
|
|
if (state.scopes[0].type !== 'nim') {
|
|
state.scopes[0].offset = stream.indentation()
|
|
return
|
|
}
|
|
for (var i = 0; i < state.scopes.length; ++i) {
|
|
if (state.scopes[i].type === 'nim') {
|
|
indentUnit = state.scopes[i].offset + conf.indentUnit
|
|
break
|
|
}
|
|
}
|
|
} else {
|
|
indentUnit = stream.column() + stream.current().length
|
|
}
|
|
|
|
state.scopes.unshift({
|
|
offset: indentUnit,
|
|
type: type
|
|
})
|
|
}
|
|
|
|
function dedent(stream, state, type) {
|
|
type = type || 'nim'
|
|
if (state.scopes.length == 1) return
|
|
if (state.scopes[0].type === 'nim') {
|
|
var _indent = stream.indentation()
|
|
var _indent_index = -1
|
|
for (var i = 0; i < state.scopes.length; ++i) {
|
|
if (_indent === state.scopes[i].offset) {
|
|
_indent_index = i
|
|
break
|
|
}
|
|
}
|
|
if (_indent_index === -1) {
|
|
return true
|
|
}
|
|
while (state.scopes[0].offset !== _indent) {
|
|
state.scopes.shift()
|
|
}
|
|
return false
|
|
} else {
|
|
if (type === 'nim') {
|
|
state.scopes[0].offset = stream.indentation()
|
|
return false
|
|
} else {
|
|
if (state.scopes[0].type != type) {
|
|
return true
|
|
}
|
|
state.scopes.shift()
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
function tokenLexer(stream, state) {
|
|
indentInfo = null
|
|
var style = state.tokenize(stream, state)
|
|
var current = stream.current()
|
|
|
|
// Handle '.' connected identifiers
|
|
if (current === '.') {
|
|
style = stream.match(identifiers, false) ? null : ERRORCLASS
|
|
if (style === null && state.lastStyle === 'meta') {
|
|
// Apply 'meta' style to '.' connected identifiers when
|
|
// appropriate.
|
|
style = 'meta'
|
|
}
|
|
return style
|
|
}
|
|
|
|
if ((style === 'variable' || style === 'builtin') && state.lastStyle === 'meta') {
|
|
style = 'meta'
|
|
}
|
|
|
|
// Handle scope changes.
|
|
if (current.match(/return|break|continue|raise/) || (current === 'discard' && stream.eol()))
|
|
state.dedent += 1
|
|
|
|
if (current === 'lambda' || current === 'proc') state.lambda = true
|
|
|
|
var delimiter_index = '[({'.indexOf(current)
|
|
|
|
if (delimiter_index !== -1) {
|
|
indent(stream, state, '])}'.slice(delimiter_index, delimiter_index + 1))
|
|
} else if (stream.eol() && current.match(/\=|\:|import|include|type|const|var|let/)) {
|
|
indent(stream, state)
|
|
}
|
|
|
|
if (indentInfo === 'dedent') {
|
|
if (dedent(stream, state)) {
|
|
return ERRORCLASS
|
|
}
|
|
}
|
|
|
|
delimiter_index = '])}'.indexOf(current)
|
|
if (delimiter_index !== -1) {
|
|
if (dedent(stream, state, current)) {
|
|
return ERRORCLASS
|
|
}
|
|
}
|
|
|
|
if (state.dedent > 0 && stream.eol() && state.scopes[0].type == 'nim') {
|
|
if (state.scopes.length > 1) state.scopes.shift()
|
|
state.dedent -= 1
|
|
}
|
|
|
|
return style
|
|
}
|
|
|
|
var external = {
|
|
startState: function(basecolumn) {
|
|
return {
|
|
tokenize: tokenBase,
|
|
scopes: [{ offset: basecolumn || 0, type: 'nim' }],
|
|
lastStyle: null,
|
|
lastToken: null,
|
|
lambda: false,
|
|
dedent: 0
|
|
}
|
|
},
|
|
|
|
token: function(stream, state) {
|
|
var style = tokenLexer(stream, state)
|
|
|
|
state.lastStyle = style
|
|
|
|
var current = stream.current()
|
|
if (current && style) state.lastToken = current
|
|
|
|
if (stream.eol() && state.lambda) state.lambda = false
|
|
|
|
return style
|
|
},
|
|
|
|
indent: function(state) {
|
|
if (state.tokenize != tokenBase) return state.tokenize.isString ? CodeMirror.Pass : 0
|
|
|
|
return state.scopes[0].offset
|
|
},
|
|
|
|
lineComment: '#',
|
|
fold: 'indent'
|
|
}
|
|
|
|
return external
|
|
})
|
|
|
|
CodeMirror.defineMIME('text/x-nimrod', 'nimrod')
|