Compare commits
No commits in common. "2fa432ea3fe023ae8b25e8af28cf5d2c63f175be" and "f31be80bb0d83d9f36b52620517480f621210da6" have entirely different histories.
2fa432ea3f
...
f31be80bb0
|
|
@ -9,7 +9,6 @@ import {
|
|||
checkTreeForErrors,
|
||||
getAllChildren,
|
||||
getAssignmentParts,
|
||||
getCompoundAssignmentParts,
|
||||
getBinaryParts,
|
||||
getDotGetParts,
|
||||
getFunctionCallParts,
|
||||
|
|
@ -18,7 +17,6 @@ import {
|
|||
getNamedArgParts,
|
||||
getPipeExprParts,
|
||||
getStringParts,
|
||||
getTryExprParts,
|
||||
} from '#compiler/utils'
|
||||
|
||||
const DEBUG = false
|
||||
|
|
@ -53,7 +51,6 @@ export class Compiler {
|
|||
instructions: ProgramItem[] = []
|
||||
fnLabelCount = 0
|
||||
ifLabelCount = 0
|
||||
tryLabelCount = 0
|
||||
bytecode: Bytecode
|
||||
pipeCounter = 0
|
||||
|
||||
|
|
@ -268,34 +265,6 @@ export class Compiler {
|
|||
return instructions
|
||||
}
|
||||
|
||||
case terms.CompoundAssign: {
|
||||
const { identifier, operator, right } = getCompoundAssignmentParts(node)
|
||||
const identifierName = input.slice(identifier.from, identifier.to)
|
||||
const instructions: ProgramItem[] = []
|
||||
|
||||
// will throw if undefined
|
||||
instructions.push(['LOAD', identifierName])
|
||||
|
||||
instructions.push(...this.#compileNode(right, input))
|
||||
|
||||
const opValue = input.slice(operator.from, operator.to)
|
||||
switch (opValue) {
|
||||
case '+=': instructions.push(['ADD']); break
|
||||
case '-=': instructions.push(['SUB']); break
|
||||
case '*=': instructions.push(['MUL']); break
|
||||
case '/=': instructions.push(['DIV']); break
|
||||
case '%=': instructions.push(['MOD']); break
|
||||
default:
|
||||
throw new CompilerError(`Unknown compound operator: ${opValue}`, operator.from, operator.to)
|
||||
}
|
||||
|
||||
// DUP and store (same as regular assignment)
|
||||
instructions.push(['DUP'])
|
||||
instructions.push(['STORE', identifierName])
|
||||
|
||||
return instructions
|
||||
}
|
||||
|
||||
case terms.ParenExpr: {
|
||||
const child = node.firstChild
|
||||
if (!child) return [] // I guess it is empty parentheses?
|
||||
|
|
@ -304,10 +273,7 @@ export class Compiler {
|
|||
}
|
||||
|
||||
case terms.FunctionDef: {
|
||||
const { paramNames, bodyNodes, catchVariable, catchBody, finallyBody } = getFunctionDefParts(
|
||||
node,
|
||||
input
|
||||
)
|
||||
const { paramNames, bodyNodes } = getFunctionDefParts(node, input)
|
||||
const instructions: ProgramItem[] = []
|
||||
const functionLabel: Label = `.func_${this.fnLabelCount++}`
|
||||
const afterLabel: Label = `.after_${functionLabel}`
|
||||
|
|
@ -315,27 +281,9 @@ export class Compiler {
|
|||
instructions.push(['JUMP', afterLabel])
|
||||
|
||||
instructions.push([`${functionLabel}:`])
|
||||
|
||||
const compileFunctionBody = () => {
|
||||
const bodyInstructions: ProgramItem[] = []
|
||||
bodyNodes.forEach((bodyNode, index) => {
|
||||
bodyInstructions.push(...this.#compileNode(bodyNode, input))
|
||||
if (index < bodyNodes.length - 1) {
|
||||
bodyInstructions.push(['POP'])
|
||||
}
|
||||
})
|
||||
return bodyInstructions
|
||||
}
|
||||
|
||||
if (catchVariable || finallyBody) {
|
||||
// If function has catch or finally, wrap body in try/catch/finally
|
||||
instructions.push(
|
||||
...this.#compileTryCatchFinally(compileFunctionBody, catchVariable, catchBody, finallyBody, input)
|
||||
)
|
||||
} else {
|
||||
instructions.push(...compileFunctionBody())
|
||||
}
|
||||
|
||||
bodyNodes.forEach((bodyNode) => {
|
||||
instructions.push(...this.#compileNode(bodyNode, input))
|
||||
})
|
||||
instructions.push(['RETURN'])
|
||||
|
||||
instructions.push([`${afterLabel}:`])
|
||||
|
|
@ -389,48 +337,10 @@ export class Compiler {
|
|||
}
|
||||
|
||||
case terms.ThenBlock:
|
||||
case terms.SingleLineThenBlock:
|
||||
case terms.TryBlock: {
|
||||
const children = getAllChildren(node)
|
||||
const instructions: ProgramItem[] = []
|
||||
|
||||
children.forEach((child, index) => {
|
||||
instructions.push(...this.#compileNode(child, input))
|
||||
// keep only the last expression's value
|
||||
if (index < children.length - 1) {
|
||||
instructions.push(['POP'])
|
||||
}
|
||||
})
|
||||
|
||||
return instructions
|
||||
}
|
||||
|
||||
case terms.TryExpr: {
|
||||
const { tryBlock, catchVariable, catchBody, finallyBody } = getTryExprParts(node, input)
|
||||
|
||||
return this.#compileTryCatchFinally(
|
||||
() => this.#compileNode(tryBlock, input),
|
||||
catchVariable,
|
||||
catchBody,
|
||||
finallyBody,
|
||||
input
|
||||
)
|
||||
}
|
||||
|
||||
case terms.Throw: {
|
||||
const children = getAllChildren(node)
|
||||
const [_throwKeyword, expression] = children
|
||||
if (!expression) {
|
||||
throw new CompilerError(
|
||||
`Throw expected expression, got ${children.length} children`,
|
||||
node.from,
|
||||
node.to
|
||||
)
|
||||
}
|
||||
|
||||
const instructions: ProgramItem[] = []
|
||||
instructions.push(...this.#compileNode(expression, input))
|
||||
instructions.push(['THROW'])
|
||||
case terms.SingleLineThenBlock: {
|
||||
const instructions = getAllChildren(node)
|
||||
.map((child) => this.#compileNode(child, input))
|
||||
.flat()
|
||||
|
||||
return instructions
|
||||
}
|
||||
|
|
@ -637,52 +547,4 @@ export class Compiler {
|
|||
)
|
||||
}
|
||||
}
|
||||
|
||||
#compileTryCatchFinally(
|
||||
compileTryBody: () => ProgramItem[],
|
||||
catchVariable: string | undefined,
|
||||
catchBody: SyntaxNode | undefined,
|
||||
finallyBody: SyntaxNode | undefined,
|
||||
input: string
|
||||
): ProgramItem[] {
|
||||
const instructions: ProgramItem[] = []
|
||||
this.tryLabelCount++
|
||||
const catchLabel: Label = `.catch_${this.tryLabelCount}`
|
||||
const finallyLabel: Label = finallyBody ? `.finally_${this.tryLabelCount}` : (null as any)
|
||||
const endLabel: Label = `.end_try_${this.tryLabelCount}`
|
||||
|
||||
instructions.push(['PUSH_TRY', catchLabel])
|
||||
instructions.push(...compileTryBody())
|
||||
instructions.push(['POP_TRY'])
|
||||
instructions.push(['JUMP', finallyBody ? finallyLabel : endLabel])
|
||||
|
||||
// catch block
|
||||
instructions.push([`${catchLabel}:`])
|
||||
if (catchBody && catchVariable) {
|
||||
instructions.push(['STORE', catchVariable])
|
||||
const catchInstructions = this.#compileNode(catchBody, input)
|
||||
instructions.push(...catchInstructions)
|
||||
instructions.push(['JUMP', finallyBody ? finallyLabel : endLabel])
|
||||
} else {
|
||||
// no catch block
|
||||
if (finallyBody) {
|
||||
instructions.push(['JUMP', finallyLabel])
|
||||
} else {
|
||||
instructions.push(['THROW'])
|
||||
}
|
||||
}
|
||||
|
||||
// finally block
|
||||
if (finallyBody) {
|
||||
instructions.push([`${finallyLabel}:`])
|
||||
const finallyInstructions = this.#compileNode(finallyBody, input)
|
||||
instructions.push(...finallyInstructions)
|
||||
// finally doesn't return a value
|
||||
instructions.push(['POP'])
|
||||
}
|
||||
|
||||
instructions.push([`${endLabel}:`])
|
||||
|
||||
return instructions
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,311 +0,0 @@
|
|||
import { describe } from 'bun:test'
|
||||
import { expect, test } from 'bun:test'
|
||||
|
||||
describe('exception handling', () => {
|
||||
test('try with catch - no error thrown', () => {
|
||||
expect(`
|
||||
try:
|
||||
42
|
||||
catch err:
|
||||
99
|
||||
end
|
||||
`).toEvaluateTo(42)
|
||||
})
|
||||
|
||||
test('try with catch - error thrown', () => {
|
||||
expect(`
|
||||
try:
|
||||
throw 'something went wrong'
|
||||
99
|
||||
catch err:
|
||||
err
|
||||
end
|
||||
`).toEvaluateTo('something went wrong')
|
||||
})
|
||||
|
||||
test('try with catch - catch variable binding', () => {
|
||||
expect(`
|
||||
try:
|
||||
throw 100
|
||||
catch my-error:
|
||||
my-error + 50
|
||||
end
|
||||
`).toEvaluateTo(150)
|
||||
})
|
||||
|
||||
test('try with finally - no error', () => {
|
||||
expect(`
|
||||
x = 0
|
||||
result = try:
|
||||
x = 10
|
||||
42
|
||||
finally:
|
||||
x = x + 5
|
||||
end
|
||||
x
|
||||
`).toEvaluateTo(15)
|
||||
})
|
||||
|
||||
test('try with finally - return value from try', () => {
|
||||
expect(`
|
||||
x = 0
|
||||
result = try:
|
||||
x = 10
|
||||
42
|
||||
finally:
|
||||
x = x + 5
|
||||
999
|
||||
end
|
||||
result
|
||||
`).toEvaluateTo(42)
|
||||
})
|
||||
|
||||
test('try with catch and finally - no error', () => {
|
||||
expect(`
|
||||
x = 0
|
||||
try:
|
||||
x = 10
|
||||
42
|
||||
catch err:
|
||||
x = 999
|
||||
0
|
||||
finally:
|
||||
x = x + 5
|
||||
end
|
||||
x
|
||||
`).toEvaluateTo(15)
|
||||
})
|
||||
|
||||
test('try with catch and finally - error thrown', () => {
|
||||
expect(`
|
||||
x = 0
|
||||
result = try:
|
||||
x = 10
|
||||
throw 'error'
|
||||
99
|
||||
catch err:
|
||||
x = 20
|
||||
err
|
||||
finally:
|
||||
x = x + 5
|
||||
end
|
||||
x
|
||||
`).toEvaluateTo(25)
|
||||
})
|
||||
|
||||
test('try with catch and finally - return value from catch', () => {
|
||||
expect(`
|
||||
result = try:
|
||||
throw 'oops'
|
||||
catch err:
|
||||
'caught'
|
||||
finally:
|
||||
'finally'
|
||||
end
|
||||
result
|
||||
`).toEvaluateTo('caught')
|
||||
})
|
||||
|
||||
test('throw statement with string', () => {
|
||||
expect(`
|
||||
try:
|
||||
throw 'error message'
|
||||
catch err:
|
||||
err
|
||||
end
|
||||
`).toEvaluateTo('error message')
|
||||
})
|
||||
|
||||
test('throw statement with number', () => {
|
||||
expect(`
|
||||
try:
|
||||
throw 404
|
||||
catch err:
|
||||
err
|
||||
end
|
||||
`).toEvaluateTo(404)
|
||||
})
|
||||
|
||||
test('throw statement with dict', () => {
|
||||
expect(`
|
||||
try:
|
||||
throw [code=500 message=failed]
|
||||
catch e:
|
||||
e
|
||||
end
|
||||
`).toEvaluateTo({ code: 500, message: 'failed' })
|
||||
})
|
||||
|
||||
test('uncaught exception fails', () => {
|
||||
expect(`throw 'uncaught error'`).toFailEvaluation()
|
||||
})
|
||||
|
||||
test('single-line try catch', () => {
|
||||
expect(`result = try: throw 'err' catch e: 'handled' end; result`).toEvaluateTo('handled')
|
||||
})
|
||||
|
||||
test('nested try blocks - inner catches', () => {
|
||||
expect(`
|
||||
try:
|
||||
result = try:
|
||||
throw 'inner error'
|
||||
catch err:
|
||||
err
|
||||
end
|
||||
result
|
||||
catch outer:
|
||||
'outer'
|
||||
end
|
||||
`).toEvaluateTo('inner error')
|
||||
})
|
||||
|
||||
test('nested try blocks - outer catches', () => {
|
||||
expect(`
|
||||
try:
|
||||
try:
|
||||
throw 'inner error'
|
||||
catch err:
|
||||
throw 'outer error'
|
||||
end
|
||||
catch outer:
|
||||
outer
|
||||
end
|
||||
`).toEvaluateTo('outer error')
|
||||
})
|
||||
|
||||
test('try as expression', () => {
|
||||
expect(`
|
||||
x = try: 10 catch err: 0 end
|
||||
y = try: throw 'err' catch err: 20 end
|
||||
x + y
|
||||
`).toEvaluateTo(30)
|
||||
})
|
||||
})
|
||||
|
||||
describe('function-level exception handling', () => {
|
||||
test('function with catch - no error', () => {
|
||||
expect(`
|
||||
read-file = do path:
|
||||
path
|
||||
catch e:
|
||||
'default'
|
||||
end
|
||||
|
||||
read-file test.txt
|
||||
`).toEvaluateTo('test.txt')
|
||||
})
|
||||
|
||||
test('function with catch - error thrown', () => {
|
||||
expect(`
|
||||
read-file = do path:
|
||||
throw 'file not found'
|
||||
catch e:
|
||||
'default'
|
||||
end
|
||||
|
||||
read-file test.txt
|
||||
`).toEvaluateTo('default')
|
||||
})
|
||||
|
||||
test('function with catch - error variable binding', () => {
|
||||
expect(`
|
||||
safe-call = do:
|
||||
throw 'operation failed'
|
||||
catch err:
|
||||
err
|
||||
end
|
||||
|
||||
safe-call
|
||||
`).toEvaluateTo('operation failed')
|
||||
})
|
||||
|
||||
test('function with finally - always runs', () => {
|
||||
expect(`
|
||||
counter = 0
|
||||
increment-task = do:
|
||||
result = 42
|
||||
result
|
||||
finally:
|
||||
counter = counter + 1
|
||||
end
|
||||
|
||||
x = increment-task
|
||||
y = increment-task
|
||||
counter
|
||||
`).toEvaluateTo(2)
|
||||
})
|
||||
|
||||
test('function with finally - return value from body', () => {
|
||||
expect(`
|
||||
get-value = do:
|
||||
100
|
||||
finally:
|
||||
999
|
||||
end
|
||||
|
||||
get-value
|
||||
`).toEvaluateTo(100)
|
||||
})
|
||||
|
||||
test('function with catch and finally', () => {
|
||||
expect(`
|
||||
cleanup-count = 0
|
||||
safe-op = do should-fail:
|
||||
if should-fail:
|
||||
throw 'failed'
|
||||
end
|
||||
'success'
|
||||
catch e:
|
||||
'caught'
|
||||
finally:
|
||||
cleanup-count = cleanup-count + 1
|
||||
end
|
||||
|
||||
result1 = safe-op false
|
||||
result2 = safe-op true
|
||||
cleanup-count
|
||||
`).toEvaluateTo(2)
|
||||
})
|
||||
|
||||
test('function with catch and finally - catch return value', () => {
|
||||
expect(`
|
||||
safe-fail = do:
|
||||
throw 'always fails'
|
||||
catch e:
|
||||
'error handled'
|
||||
finally:
|
||||
noop = 1
|
||||
end
|
||||
|
||||
safe-fail
|
||||
`).toEvaluateTo('error handled')
|
||||
})
|
||||
|
||||
test('function without catch/finally still works', () => {
|
||||
expect(`
|
||||
regular = do x:
|
||||
x + 10
|
||||
end
|
||||
|
||||
regular 5
|
||||
`).toEvaluateTo(15)
|
||||
})
|
||||
|
||||
test('nested functions with catch', () => {
|
||||
expect(`
|
||||
inner = do:
|
||||
throw 'inner error'
|
||||
catch e:
|
||||
'inner caught'
|
||||
end
|
||||
|
||||
outer = do:
|
||||
inner
|
||||
catch e:
|
||||
'outer caught'
|
||||
end
|
||||
|
||||
outer
|
||||
`).toEvaluateTo('inner caught')
|
||||
})
|
||||
})
|
||||
|
|
@ -1,292 +0,0 @@
|
|||
import { describe, test, expect } from 'bun:test'
|
||||
import { Compiler } from '#compiler/compiler'
|
||||
import { VM } from 'reefvm'
|
||||
|
||||
describe('Native Function Exceptions', () => {
|
||||
test('native function error caught by try/catch', async () => {
|
||||
const code = `
|
||||
result = try:
|
||||
failing-fn
|
||||
catch e:
|
||||
'caught: ' + e
|
||||
end
|
||||
|
||||
result
|
||||
`
|
||||
|
||||
const compiler = new Compiler(code)
|
||||
const vm = new VM(compiler.bytecode)
|
||||
|
||||
vm.set('failing-fn', () => {
|
||||
throw new Error('native function failed')
|
||||
})
|
||||
|
||||
const result = await vm.run()
|
||||
expect(result).toEqual({ type: 'string', value: 'caught: native function failed' })
|
||||
})
|
||||
|
||||
test('async native function error caught by try/catch', async () => {
|
||||
const code = `
|
||||
result = try:
|
||||
async-fail
|
||||
catch e:
|
||||
'async caught: ' + e
|
||||
end
|
||||
|
||||
result
|
||||
`
|
||||
|
||||
const compiler = new Compiler(code)
|
||||
const vm = new VM(compiler.bytecode)
|
||||
|
||||
vm.set('async-fail', async () => {
|
||||
await new Promise(resolve => setTimeout(resolve, 1))
|
||||
throw new Error('async error')
|
||||
})
|
||||
|
||||
const result = await vm.run()
|
||||
expect(result).toEqual({ type: 'string', value: 'async caught: async error' })
|
||||
})
|
||||
|
||||
test('native function with arguments throwing error', async () => {
|
||||
const code = `
|
||||
result = try:
|
||||
read-file missing.txt
|
||||
catch e:
|
||||
'default content'
|
||||
end
|
||||
|
||||
result
|
||||
`
|
||||
|
||||
const compiler = new Compiler(code)
|
||||
const vm = new VM(compiler.bytecode)
|
||||
|
||||
vm.set('read-file', (path: string) => {
|
||||
if (path === 'missing.txt') {
|
||||
throw new Error('file not found')
|
||||
}
|
||||
return 'file contents'
|
||||
})
|
||||
|
||||
const result = await vm.run()
|
||||
expect(result).toEqual({ type: 'string', value: 'default content' })
|
||||
})
|
||||
|
||||
test('native function error with finally block', async () => {
|
||||
const code = `
|
||||
cleanup-count = 0
|
||||
|
||||
result = try:
|
||||
failing-fn
|
||||
catch e:
|
||||
'error handled'
|
||||
finally:
|
||||
cleanup-count = cleanup-count + 1
|
||||
end
|
||||
|
||||
cleanup-count
|
||||
`
|
||||
|
||||
const compiler = new Compiler(code)
|
||||
const vm = new VM(compiler.bytecode)
|
||||
|
||||
vm.set('failing-fn', () => {
|
||||
throw new Error('native error')
|
||||
})
|
||||
|
||||
const result = await vm.run()
|
||||
expect(result).toEqual({ type: 'number', value: 1 })
|
||||
})
|
||||
|
||||
test('native function error without catch propagates', async () => {
|
||||
const code = `
|
||||
failing-fn
|
||||
`
|
||||
|
||||
const compiler = new Compiler(code)
|
||||
const vm = new VM(compiler.bytecode)
|
||||
|
||||
vm.set('failing-fn', () => {
|
||||
throw new Error('uncaught error')
|
||||
})
|
||||
|
||||
await expect(vm.run()).rejects.toThrow('uncaught error')
|
||||
})
|
||||
|
||||
test('native function in function-level catch', async () => {
|
||||
const code = `
|
||||
safe-read = do path:
|
||||
read-file path
|
||||
catch e:
|
||||
'default: ' + e
|
||||
end
|
||||
|
||||
result = safe-read missing.txt
|
||||
result
|
||||
`
|
||||
|
||||
const compiler = new Compiler(code)
|
||||
const vm = new VM(compiler.bytecode)
|
||||
|
||||
vm.set('read-file', (path: string) => {
|
||||
throw new Error('file not found: ' + path)
|
||||
})
|
||||
|
||||
const result = await vm.run()
|
||||
expect(result).toEqual({ type: 'string', value: 'default: file not found: missing.txt' })
|
||||
})
|
||||
|
||||
test('nested native function errors', async () => {
|
||||
const code = `
|
||||
result = try:
|
||||
try:
|
||||
inner-fail
|
||||
catch e:
|
||||
throw 'wrapped: ' + e
|
||||
end
|
||||
catch e:
|
||||
'outer caught: ' + e
|
||||
end
|
||||
|
||||
result
|
||||
`
|
||||
|
||||
const compiler = new Compiler(code)
|
||||
const vm = new VM(compiler.bytecode)
|
||||
|
||||
vm.set('inner-fail', () => {
|
||||
throw new Error('inner error')
|
||||
})
|
||||
|
||||
const result = await vm.run()
|
||||
expect(result).toEqual({ type: 'string', value: 'outer caught: wrapped: inner error' })
|
||||
})
|
||||
|
||||
test('native function error with multiple named args', async () => {
|
||||
const code = `
|
||||
result = try:
|
||||
process-file path=missing.txt mode=strict
|
||||
catch e:
|
||||
'error: ' + e
|
||||
end
|
||||
|
||||
result
|
||||
`
|
||||
|
||||
const compiler = new Compiler(code)
|
||||
const vm = new VM(compiler.bytecode)
|
||||
|
||||
vm.set('process-file', (path: string, mode: string = 'lenient') => {
|
||||
if (mode === 'strict' && path === 'missing.txt') {
|
||||
throw new Error('strict mode: file required')
|
||||
}
|
||||
return 'processed'
|
||||
})
|
||||
|
||||
const result = await vm.run()
|
||||
expect(result).toEqual({ type: 'string', value: 'error: strict mode: file required' })
|
||||
})
|
||||
|
||||
test('native function returning normally after other functions threw', async () => {
|
||||
const code = `
|
||||
result1 = try:
|
||||
failing-fn
|
||||
catch e:
|
||||
'caught'
|
||||
end
|
||||
|
||||
result2 = success-fn
|
||||
|
||||
result1 + ' then ' + result2
|
||||
`
|
||||
|
||||
const compiler = new Compiler(code)
|
||||
const vm = new VM(compiler.bytecode)
|
||||
|
||||
vm.set('failing-fn', () => {
|
||||
throw new Error('error')
|
||||
})
|
||||
|
||||
vm.set('success-fn', () => {
|
||||
return 'success'
|
||||
})
|
||||
|
||||
const result = await vm.run()
|
||||
expect(result).toEqual({ type: 'string', value: 'caught then success' })
|
||||
})
|
||||
|
||||
test('native function error message preserved', async () => {
|
||||
const code = `
|
||||
result = try:
|
||||
throw-custom-message
|
||||
catch e:
|
||||
e
|
||||
end
|
||||
|
||||
result
|
||||
`
|
||||
|
||||
const compiler = new Compiler(code)
|
||||
const vm = new VM(compiler.bytecode)
|
||||
|
||||
vm.set('throw-custom-message', () => {
|
||||
throw new Error('This is a very specific error message with details')
|
||||
})
|
||||
|
||||
const result = await vm.run()
|
||||
expect(result).toEqual({
|
||||
type: 'string',
|
||||
value: 'This is a very specific error message with details'
|
||||
})
|
||||
})
|
||||
|
||||
test('native function throwing non-Error value', async () => {
|
||||
const code = `
|
||||
result = try:
|
||||
throw-string
|
||||
catch e:
|
||||
'caught: ' + e
|
||||
end
|
||||
|
||||
result
|
||||
`
|
||||
|
||||
const compiler = new Compiler(code)
|
||||
const vm = new VM(compiler.bytecode)
|
||||
|
||||
vm.set('throw-string', () => {
|
||||
throw 'plain string error'
|
||||
})
|
||||
|
||||
const result = await vm.run()
|
||||
expect(result).toEqual({ type: 'string', value: 'caught: plain string error' })
|
||||
})
|
||||
|
||||
test('multiple native function calls with mixed success/failure', async () => {
|
||||
const code = `
|
||||
r1 = try: success-fn catch e: 'error' end
|
||||
r2 = try: failing-fn catch e: 'caught' end
|
||||
r3 = try: success-fn catch e: 'error' end
|
||||
|
||||
results = [r1 r2 r3]
|
||||
results
|
||||
`
|
||||
|
||||
const compiler = new Compiler(code)
|
||||
const vm = new VM(compiler.bytecode)
|
||||
|
||||
vm.set('success-fn', () => 'ok')
|
||||
vm.set('failing-fn', () => {
|
||||
throw new Error('failed')
|
||||
})
|
||||
|
||||
const result = await vm.run()
|
||||
expect(result.type).toBe('array')
|
||||
const arr = result.value as any[]
|
||||
expect(arr.length).toBe(3)
|
||||
expect(arr[0]).toEqual({ type: 'string', value: 'ok' })
|
||||
expect(arr[1]).toEqual({ type: 'string', value: 'caught' })
|
||||
expect(arr[2]).toEqual({ type: 'string', value: 'ok' })
|
||||
})
|
||||
})
|
||||
|
|
@ -65,34 +65,13 @@ export const getAssignmentParts = (node: SyntaxNode) => {
|
|||
return { identifier: left, right }
|
||||
}
|
||||
|
||||
export const getCompoundAssignmentParts = (node: SyntaxNode) => {
|
||||
const children = getAllChildren(node)
|
||||
const [left, operator, right] = children
|
||||
|
||||
if (!left || left.type.id !== terms.AssignableIdentifier) {
|
||||
throw new CompilerError(
|
||||
`CompoundAssign left child must be an AssignableIdentifier, got ${left ? left.type.name : 'none'}`,
|
||||
node.from,
|
||||
node.to
|
||||
)
|
||||
} else if (!operator || !right) {
|
||||
throw new CompilerError(
|
||||
`CompoundAssign expected 3 children, got ${children.length}`,
|
||||
node.from,
|
||||
node.to
|
||||
)
|
||||
}
|
||||
|
||||
return { identifier: left, operator, right }
|
||||
}
|
||||
|
||||
export const getFunctionDefParts = (node: SyntaxNode, input: string) => {
|
||||
const children = getAllChildren(node)
|
||||
const [fnKeyword, paramsNode, colon, ...rest] = children
|
||||
const [fnKeyword, paramsNode, colon, ...bodyNodes] = children
|
||||
|
||||
if (!fnKeyword || !paramsNode || !colon || !rest) {
|
||||
if (!fnKeyword || !paramsNode || !colon || !bodyNodes) {
|
||||
throw new CompilerError(
|
||||
`FunctionDef expected at least 4 children, got ${children.length}`,
|
||||
`FunctionDef expected 5 children, got ${children.length}`,
|
||||
node.from,
|
||||
node.to
|
||||
)
|
||||
|
|
@ -109,48 +88,8 @@ export const getFunctionDefParts = (node: SyntaxNode, input: string) => {
|
|||
return input.slice(param.from, param.to)
|
||||
})
|
||||
|
||||
// Separate body nodes from catch/finally/end
|
||||
const bodyNodes: SyntaxNode[] = []
|
||||
let catchExpr: SyntaxNode | undefined
|
||||
let catchVariable: string | undefined
|
||||
let catchBody: SyntaxNode | undefined
|
||||
let finallyExpr: SyntaxNode | undefined
|
||||
let finallyBody: SyntaxNode | undefined
|
||||
|
||||
for (const child of rest) {
|
||||
if (child.type.id === terms.CatchExpr) {
|
||||
catchExpr = child
|
||||
const catchChildren = getAllChildren(child)
|
||||
const [_catchKeyword, identifierNode, _colon, body] = catchChildren
|
||||
if (!identifierNode || !body) {
|
||||
throw new CompilerError(
|
||||
`CatchExpr expected identifier and body, got ${catchChildren.length} children`,
|
||||
child.from,
|
||||
child.to
|
||||
)
|
||||
}
|
||||
catchVariable = input.slice(identifierNode.from, identifierNode.to)
|
||||
catchBody = body
|
||||
} else if (child.type.id === terms.FinallyExpr) {
|
||||
finallyExpr = child
|
||||
const finallyChildren = getAllChildren(child)
|
||||
const [_finallyKeyword, _colon, body] = finallyChildren
|
||||
if (!body) {
|
||||
throw new CompilerError(
|
||||
`FinallyExpr expected body, got ${finallyChildren.length} children`,
|
||||
child.from,
|
||||
child.to
|
||||
)
|
||||
}
|
||||
finallyBody = body
|
||||
} else if (child.type.name === 'keyword' && input.slice(child.from, child.to) === 'end') {
|
||||
// Skip the end keyword
|
||||
} else {
|
||||
bodyNodes.push(child)
|
||||
}
|
||||
}
|
||||
|
||||
return { paramNames, bodyNodes, catchVariable, catchBody, finallyBody }
|
||||
const bodyWithoutEnd = bodyNodes.slice(0, -1)
|
||||
return { paramNames, bodyNodes: bodyWithoutEnd }
|
||||
}
|
||||
|
||||
export const getFunctionCallParts = (node: SyntaxNode, input: string) => {
|
||||
|
|
@ -265,12 +204,7 @@ export const getStringParts = (node: SyntaxNode, input: string) => {
|
|||
}
|
||||
})
|
||||
|
||||
// hasInterpolation means the string has interpolation ($var) or escape sequences (\n)
|
||||
// A simple string like 'hello' has one StringFragment but no interpolation
|
||||
const hasInterpolation = parts.some(
|
||||
(p) => p.type.id === terms.Interpolation || p.type.id === terms.EscapeSeq
|
||||
)
|
||||
return { parts, hasInterpolation }
|
||||
return { parts, hasInterpolation: parts.length > 0 }
|
||||
}
|
||||
|
||||
export const getDotGetParts = (node: SyntaxNode, input: string) => {
|
||||
|
|
@ -305,62 +239,3 @@ export const getDotGetParts = (node: SyntaxNode, input: string) => {
|
|||
|
||||
return { objectName, property }
|
||||
}
|
||||
|
||||
export const getTryExprParts = (node: SyntaxNode, input: string) => {
|
||||
const children = getAllChildren(node)
|
||||
|
||||
// First child is always 'try' keyword, second is colon, third is TryBlock or statement
|
||||
const [tryKeyword, _colon, tryBlock, ...rest] = children
|
||||
|
||||
if (!tryKeyword || !tryBlock) {
|
||||
throw new CompilerError(
|
||||
`TryExpr expected at least 3 children, got ${children.length}`,
|
||||
node.from,
|
||||
node.to
|
||||
)
|
||||
}
|
||||
|
||||
let catchExpr: SyntaxNode | undefined
|
||||
let catchVariable: string | undefined
|
||||
let catchBody: SyntaxNode | undefined
|
||||
let finallyExpr: SyntaxNode | undefined
|
||||
let finallyBody: SyntaxNode | undefined
|
||||
|
||||
rest.forEach((child) => {
|
||||
if (child.type.id === terms.CatchExpr) {
|
||||
catchExpr = child
|
||||
const catchChildren = getAllChildren(child)
|
||||
const [_catchKeyword, identifierNode, _colon, body] = catchChildren
|
||||
if (!identifierNode || !body) {
|
||||
throw new CompilerError(
|
||||
`CatchExpr expected identifier and body, got ${catchChildren.length} children`,
|
||||
child.from,
|
||||
child.to
|
||||
)
|
||||
}
|
||||
catchVariable = input.slice(identifierNode.from, identifierNode.to)
|
||||
catchBody = body
|
||||
} else if (child.type.id === terms.FinallyExpr) {
|
||||
finallyExpr = child
|
||||
const finallyChildren = getAllChildren(child)
|
||||
const [_finallyKeyword, _colon, body] = finallyChildren
|
||||
if (!body) {
|
||||
throw new CompilerError(
|
||||
`FinallyExpr expected body, got ${finallyChildren.length} children`,
|
||||
child.from,
|
||||
child.to
|
||||
)
|
||||
}
|
||||
finallyBody = body
|
||||
}
|
||||
})
|
||||
|
||||
return {
|
||||
tryBlock,
|
||||
catchExpr,
|
||||
catchVariable,
|
||||
catchBody,
|
||||
finallyExpr,
|
||||
finallyBody,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,14 +10,7 @@ const operators: Array<Operator> = [
|
|||
{ str: '!=', tokenName: 'Neq' },
|
||||
{ str: '==', tokenName: 'EqEq' },
|
||||
|
||||
// Compound assignment operators (must come before single-char operators)
|
||||
{ str: '+=', tokenName: 'PlusEq' },
|
||||
{ str: '-=', tokenName: 'MinusEq' },
|
||||
{ str: '*=', tokenName: 'StarEq' },
|
||||
{ str: '/=', tokenName: 'SlashEq' },
|
||||
{ str: '%=', tokenName: 'ModuloEq' },
|
||||
|
||||
// Single-char operators
|
||||
// // Single-char operators
|
||||
{ str: '*', tokenName: 'Star' },
|
||||
{ str: '=', tokenName: 'Eq' },
|
||||
{ str: '/', tokenName: 'Slash' },
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
@top Program { item* }
|
||||
|
||||
@external tokens operatorTokenizer from "./operatorTokenizer" { Star, Slash, Plus, Minus, And, Or, Eq, EqEq, Neq, Lt, Lte, Gt, Gte, Modulo, PlusEq, MinusEq, StarEq, SlashEq, ModuloEq }
|
||||
@external tokens operatorTokenizer from "./operatorTokenizer" { Star, Slash, Plus, Minus, And, Or, Eq, EqEq, Neq, Lt, Lte, Gt, Gte, Modulo }
|
||||
|
||||
@tokens {
|
||||
@precedence { Number Regex }
|
||||
|
|
@ -51,11 +51,8 @@ item {
|
|||
consumeToTerminator {
|
||||
PipeExpr |
|
||||
ambiguousFunctionCall |
|
||||
TryExpr |
|
||||
Throw |
|
||||
IfExpr |
|
||||
FunctionDef |
|
||||
CompoundAssign |
|
||||
Assign |
|
||||
BinOp |
|
||||
ConditionalOp |
|
||||
|
|
@ -100,11 +97,11 @@ FunctionDef {
|
|||
}
|
||||
|
||||
singleLineFunctionDef {
|
||||
Do Params colon consumeToTerminator CatchExpr? FinallyExpr? @specialize[@name=keyword]<Identifier, "end">
|
||||
Do Params colon consumeToTerminator @specialize[@name=keyword]<Identifier, "end">
|
||||
}
|
||||
|
||||
multilineFunctionDef {
|
||||
Do Params colon newlineOrSemicolon block CatchExpr? FinallyExpr? @specialize[@name=keyword]<Identifier, "end">
|
||||
Do Params colon newlineOrSemicolon block @specialize[@name=keyword]<Identifier, "end">
|
||||
}
|
||||
|
||||
IfExpr {
|
||||
|
|
@ -132,35 +129,7 @@ ThenBlock {
|
|||
}
|
||||
|
||||
SingleLineThenBlock {
|
||||
consumeToTerminator
|
||||
}
|
||||
|
||||
TryExpr {
|
||||
singleLineTry | multilineTry
|
||||
}
|
||||
|
||||
singleLineTry {
|
||||
@specialize[@name=keyword]<Identifier, "try"> colon consumeToTerminator CatchExpr? FinallyExpr? @specialize[@name=keyword]<Identifier, "end">
|
||||
}
|
||||
|
||||
multilineTry {
|
||||
@specialize[@name=keyword]<Identifier, "try"> colon newlineOrSemicolon TryBlock CatchExpr? FinallyExpr? @specialize[@name=keyword]<Identifier, "end">
|
||||
}
|
||||
|
||||
CatchExpr {
|
||||
@specialize[@name=keyword]<Identifier, "catch"> Identifier colon (newlineOrSemicolon TryBlock | consumeToTerminator)
|
||||
}
|
||||
|
||||
FinallyExpr {
|
||||
@specialize[@name=keyword]<Identifier, "finally"> colon (newlineOrSemicolon TryBlock | consumeToTerminator)
|
||||
}
|
||||
|
||||
TryBlock {
|
||||
block
|
||||
}
|
||||
|
||||
Throw {
|
||||
@specialize[@name=keyword]<Identifier, "throw"> (BinOp | ConditionalOp | expression)
|
||||
consumeToTerminator
|
||||
}
|
||||
|
||||
ConditionalOp {
|
||||
|
|
@ -182,10 +151,6 @@ Assign {
|
|||
(AssignableIdentifier | Array) Eq consumeToTerminator
|
||||
}
|
||||
|
||||
CompoundAssign {
|
||||
AssignableIdentifier (PlusEq | MinusEq | StarEq | SlashEq | ModuloEq) consumeToTerminator
|
||||
}
|
||||
|
||||
BinOp {
|
||||
expression !multiplicative Modulo expression |
|
||||
(expression | BinOp) !multiplicative Star (expression | BinOp) |
|
||||
|
|
|
|||
|
|
@ -14,51 +14,40 @@ export const
|
|||
Gt = 12,
|
||||
Gte = 13,
|
||||
Modulo = 14,
|
||||
PlusEq = 15,
|
||||
MinusEq = 16,
|
||||
StarEq = 17,
|
||||
SlashEq = 18,
|
||||
ModuloEq = 19,
|
||||
Identifier = 20,
|
||||
AssignableIdentifier = 21,
|
||||
Word = 22,
|
||||
IdentifierBeforeDot = 23,
|
||||
Do = 24,
|
||||
Program = 25,
|
||||
PipeExpr = 26,
|
||||
FunctionCall = 27,
|
||||
DotGet = 28,
|
||||
Number = 29,
|
||||
ParenExpr = 30,
|
||||
FunctionCallOrIdentifier = 31,
|
||||
BinOp = 32,
|
||||
String = 33,
|
||||
StringFragment = 34,
|
||||
Interpolation = 35,
|
||||
EscapeSeq = 36,
|
||||
Boolean = 37,
|
||||
Regex = 38,
|
||||
Dict = 39,
|
||||
NamedArg = 40,
|
||||
NamedArgPrefix = 41,
|
||||
FunctionDef = 42,
|
||||
Params = 43,
|
||||
colon = 44,
|
||||
CatchExpr = 45,
|
||||
keyword = 68,
|
||||
TryBlock = 47,
|
||||
FinallyExpr = 48,
|
||||
Underscore = 51,
|
||||
Array = 52,
|
||||
Null = 53,
|
||||
ConditionalOp = 54,
|
||||
PositionalArg = 55,
|
||||
TryExpr = 57,
|
||||
Throw = 59,
|
||||
IfExpr = 61,
|
||||
SingleLineThenBlock = 63,
|
||||
ThenBlock = 64,
|
||||
ElseIfExpr = 65,
|
||||
ElseExpr = 67,
|
||||
CompoundAssign = 69,
|
||||
Assign = 70
|
||||
Identifier = 15,
|
||||
AssignableIdentifier = 16,
|
||||
Word = 17,
|
||||
IdentifierBeforeDot = 18,
|
||||
Do = 19,
|
||||
Program = 20,
|
||||
PipeExpr = 21,
|
||||
FunctionCall = 22,
|
||||
DotGet = 23,
|
||||
Number = 24,
|
||||
ParenExpr = 25,
|
||||
FunctionCallOrIdentifier = 26,
|
||||
BinOp = 27,
|
||||
String = 28,
|
||||
StringFragment = 29,
|
||||
Interpolation = 30,
|
||||
EscapeSeq = 31,
|
||||
Boolean = 32,
|
||||
Regex = 33,
|
||||
Dict = 34,
|
||||
NamedArg = 35,
|
||||
NamedArgPrefix = 36,
|
||||
FunctionDef = 37,
|
||||
Params = 38,
|
||||
colon = 39,
|
||||
keyword = 54,
|
||||
Underscore = 41,
|
||||
Array = 42,
|
||||
Null = 43,
|
||||
ConditionalOp = 44,
|
||||
PositionalArg = 45,
|
||||
IfExpr = 47,
|
||||
SingleLineThenBlock = 49,
|
||||
ThenBlock = 50,
|
||||
ElseIfExpr = 51,
|
||||
ElseExpr = 53,
|
||||
Assign = 55
|
||||
|
|
|
|||
|
|
@ -4,24 +4,24 @@ import {operatorTokenizer} from "./operatorTokenizer"
|
|||
import {tokenizer, specializeKeyword} from "./tokenizer"
|
||||
import {trackScope} from "./scopeTracker"
|
||||
import {highlighting} from "./highlight"
|
||||
const spec_Identifier = {__proto__:null,catch:92, finally:98, end:100, null:106, try:116, throw:120, if:124, elseif:132, else:136}
|
||||
const spec_Identifier = {__proto__:null,end:80, null:86, if:96, elseif:104, else:108}
|
||||
export const parser = LRParser.deserialize({
|
||||
version: 14,
|
||||
states: "9[QYQbOOO#tQcO'#C{O$qOSO'#C}O%PQbO'#EfOOQ`'#DW'#DWOOQa'#DT'#DTO&SQbO'#DbO'eQcO'#EZOOQa'#EZ'#EZO(hQcO'#EZO)jQcO'#EYO)}QRO'#C|O+ZQcO'#EUO+kQcO'#EUO+uQbO'#CzO,mOpO'#CxOOQ`'#EV'#EVO,rQbO'#EUO,yQQO'#ElOOQ`'#Dg'#DgO-OQbO'#DiO-OQbO'#EnOOQ`'#Dk'#DkO-sQRO'#DsOOQ`'#EU'#EUO.XQQO'#ETOOQ`'#ET'#ETOOQ`'#Du'#DuQYQbOOO.aQbO'#DUOOQa'#EY'#EYOOQ`'#De'#DeOOQ`'#Ek'#EkOOQ`'#D|'#D|O.kQbO,59cO/_QbO'#DPO/gQWO'#DQOOOO'#E]'#E]OOOO'#Dv'#DvO/{OSO,59iOOQa,59i,59iOOQ`'#Dx'#DxO0ZQbO'#DXO0cQQO,5;QOOQ`'#Dw'#DwO0hQbO,59|O0oQQO,59oOOQa,59|,59|O0zQbO,59|O1UQbO,5:`O-OQbO,59hO-OQbO,59hO-OQbO,59hO-OQbO,5:OO-OQbO,5:OO-OQbO,5:OO1fQRO,59fO1mQRO,59fO2OQRO,59fO1yQQO,59fO2ZQQO,59fO2cObO,59dO2nQbO'#D}O2yQbO,59bO3bQbO,5;WO3uQcO,5:TO4kQcO,5:TO4{QcO,5:TO5qQRO,5;YO5xQRO,5;YO1UQbO,5:_OOQ`,5:o,5:oOOQ`-E7s-E7sOOQ`,59p,59pOOQ`-E7z-E7zOOOO,59k,59kOOOO,59l,59lOOOO-E7t-E7tOOQa1G/T1G/TOOQ`-E7v-E7vO6TQbO1G0lOOQ`-E7u-E7uO6hQQO1G/ZOOQa1G/h1G/hO6sQbO1G/hOOQO'#Dz'#DzO6hQQO1G/ZOOQa1G/Z1G/ZOOQ`'#D{'#D{O6sQbO1G/hOOQ`1G/z1G/zOOQa1G/S1G/SO7lQcO1G/SO7vQcO1G/SO8QQcO1G/SOOQa1G/j1G/jO9pQcO1G/jO9wQcO1G/jO:OQcO1G/jOOQa1G/Q1G/QOOQa1G/O1G/OO!aQbO'#C{O:VQbO'#CwOOQ`,5:i,5:iOOQ`-E7{-E7{O:dQbO1G0rO:oQbO1G0sO;]QbO1G0tOOQ`1G/y1G/yO;pQbO7+&WO:oQbO7+&YO;{QQO7+$uOOQa7+$u7+$uO<WQbO7+%SOOQa7+%S7+%SOOQO-E7x-E7xOOQ`-E7y-E7yO<bQbO'#DZO<gQQO'#D^OOQ`7+&^7+&^O<lQbO7+&^O<qQbO7+&^OOQ`'#Dy'#DyO<yQQO'#DyO=OQbO'#EgOOQ`'#D]'#D]O=rQbO7+&_OOQ`'#Dm'#DmO=}QbO7+&`O>SQbO7+&aOOQ`<<Ir<<IrO>pQbO<<IrO>uQbO<<IrO>}QbO<<ItOOQa<<Ha<<HaOOQa<<Hn<<HnO?YQQO,59uO?_QbO,59xOOQ`<<Ix<<IxO?rQbO<<IxOOQ`,5:e,5:eOOQ`-E7w-E7wOOQ`<<Iy<<IyO?wQbO<<IyO?|QbO<<IyOOQ`<<Iz<<IzOOQ`'#Dn'#DnO@UQbO<<I{OOQ`AN?^AN?^O@aQbOAN?^OOQ`AN?`AN?`O@fQbOAN?`O@kQbOAN?`O@sQbO1G/aOAWQbO1G/dOOQ`1G/d1G/dOOQ`AN?dAN?dOOQ`AN?eAN?eOAnQbOAN?eO-OQbO'#DoOOQ`'#EO'#EOOAsQbOAN?gOBOQQO'#DqOOQ`AN?gAN?gOBTQbOAN?gOOQ`G24xG24xOOQ`G24zG24zOBYQbOG24zOB_QbO7+${OOQ`7+${7+${OOQ`7+%O7+%OOOQ`G25PG25POBxQRO,5:ZOCPQRO,5:ZOOQ`-E7|-E7|OOQ`G25RG25ROC[QbOG25ROCaQQO,5:]OOQ`LD*fLD*fOOQ`<<Hg<<HgOCfQQO1G/uOOQ`LD*mLD*mOAWQbO1G/wO>SQbO7+%aOOQ`7+%c7+%cOOQ`<<H{<<H{",
|
||||
stateData: "Cn~O!uOS!vOS~OdPOegOfWOg_OhROmWOuWOvWO!VWO![bO!^dO!`eO!{^O#OQO#VTO#WUO#XjO~OdnOfWOg_OhROmWOuWOvWOymO!ToO!VWO!{^O#OQO#VTO#WUO!YoX#XoX#doX#^oX!OoX!RoX!SoX~OP!|XQ!|XR!|XS!|XT!|XU!|XW!|XX!|XY!|XZ!|X[!|X]!|X^!|X~P!aOruO#OxO#QsO#RtO~OdyO|{P~OdnOfWOg_OmWOuWOvWOymO!VWO!{^O#OQO#VTO#WUO#X|O~O#]!PO~P%XOP!}XQ!}XR!}XS!}XT!}XU!}XW!}XX!}XY!}XZ!}X[!}X]!}X^!}X#X!}X#d!}X!O!}X!R!}X!S!}X~OdnOfWOg_OhROmWOuWOvWOymO!ToO!VWO!{^O#OQO#VTO#WUO#^!}X~P&ZOV!RO~P&ZOP!|XQ!|XR!|XS!|XT!|XU!|XW!|XX!|XY!|XZ!|X[!|X]!|X^!|X~O#X!xX#d!xX!O!xX!R!xX!S!xX~P(oOP!TOQ!TOR!UOS!UOT!WOU!XOW!VOX!VOY!VOZ!VO[!VO]!VO^!SO~O#X!xX#d!xX!O!xX!R!xX!S!xX~OP!TOQ!TOR!UOS!UO~P*xOT!WOU!XO~P*xOdPOfWOg_OhROmWOuWOvWO!VWO!{^O#OQO#VTO#WUO~O!z!_O~O!Y!`O~P*xO|!bO~OdnOfWOg_OmWOuWOvWO!VWO!{^O#OQO#VTO#WUO~OV!RO_!hO`!hOa!hOb!hOc!hO~O#X!iO#d!iO~OhRO!T!kO~P-OOhROymO!ToO!Yka#Xka#dka#^ka!Oka!Rka!Ska~P-OOd!mO!{^O~O#O!nO#Q!nO#R!nO#S!nO#T!nO#U!nO~OruO#O!pO#QsO#RtO~OdyO|{X~O|!rO~O#]!uO~P%XOymO#X!wO#]!yO~O#X!zO#]!uO~P-OOegO![bO!^dO!`eO~P+uO#^#VO~P(oOP!TOQ!TOR!UOS!UO#^#VO~OT!WOU!XO#^#VO~O!Y!`O#^#VO~Od#WOm#WO!{^O~Od#XOg_O!{^O~O!Y!`O#Xja#dja#^ja!Oja!Rja!Sja~OegO![bO!^dO!`eO#X#^O~P+uO#X!]a#d!]a!O!]a!R!]a!S!]a~P)}O#X!]a#d!]a!O!]a!R!]a!S!]a~OP!TOQ!TOR!UOS!UO~P4YOT!WOU!XO~P4YOT!WOU!XOW!VOX!VOY!VOZ!VO[!VO]!VO~O|#_O~P5VOT!WOU!XO|#_O~OegO![bO!^dO!`eO#X#bO~P+uOymO#X!wO#]#dO~O#X!zO#]#fO~P-OO^!SORpiSpi#Xpi#dpi#^pi!Opi!Rpi!Spi~OPpiQpi~P6}OP!TOQ!TO~P6}OP!TOQ!TORpiSpi#Xpi#dpi#^pi!Opi!Rpi!Spi~OW!VOX!VOY!VOZ!VO[!VO]!VOT!Wi#X!Wi#d!Wi#^!Wi|!Wi!O!Wi!R!Wi!S!Wi~OU!XO~P8rOU!XO~P9UOU!Wi~P8rOhROymO!ToO~P-OO!O#iO!R#jO!S#kO~OegO![bO!^dO!`eO#X#nO!O#ZP!R#ZP!S#ZP~P+uOegO![bO!^dO!`eO#X#uO~P+uO!O#iO!R#jO!S#vO~OymO#X!wO#]#zO~O#X!zO#]#{O~P-OOd#|O~O|#}O~O!S$OO~O!R#jO!S$OO~O#X$QO~OegO![bO!^dO!`eO#X#nO!O#ZX!R#ZX!S#ZX!d#ZX!f#ZX~P+uO!O#iO!R#jO!S$SO~O!S$VO~OegO![bO!^dO!`eO#X#nO!S#ZP!d#ZP!f#ZP~P+uO!S$YO~O!R#jO!S$YO~O!O#iO!R#jO!S$[O~O|$_O~OegO![bO!^dO!`eO#X$`O~P+uO!S$bO~O!S$cO~O!R#jO!S$cO~O!S$iO!d$eO!f$hO~O!S$kO~O!S$lO~O!R#jO!S$lO~OegO![bO!^dO!`eO#X$nO~P+uOegO![bO!^dO!`eO#X#nO!S#ZP~P+uO!S$qO~O!S$uO!d$eO!f$hO~O|$wO~O!S$uO~O!S$xO~OegO![bO!^dO!`eO#X#nO!R#ZP!S#ZP~P+uO|$zO~P5VOT!WOU!XO|$zO~O!S${O~O#X$|O~O#X$}O~Omv~",
|
||||
goto: "4k#dPPPPPPPPPPPPPPPPPPPPPPPPPP#e#{$bP%b#{&h'XP(S(SPP'X(WP(k)]P)`P)l)uPPP*_P+[,RP,YP,YP,YP,m,p,yP,}P,Y,Y-T-Z-a-g-m-y.T._.h.oPPPP.u.y/nPP0X1pP2oPPPPPPPP2s3_2sPP3l3s3s4W4WrhOl!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}R!]^w`O^l!R!`!b!h!r#^#_#b#p#u#}$_$`$n$|$}tPO^l!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}znPUVdemr}!Q!S!T!U!V!W!X!v!{#X#Y#e$eR#X!`tVO^l!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}zWPUVdemr}!Q!S!T!U!V!W!X!v!{#X#Y#e$eQ!msQ#W!_R#Y!`r[Ol!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}Q!Z^Q!ddQ!}!TR#Q!U!qWOPUV^delmr}!Q!R!S!T!U!V!W!X!b!h!r!v!{#X#Y#^#_#b#e#p#u#}$_$`$e$n$|$}TuQwYpPVr#X#YQ!OUQ!t}X!w!O!t!x#crhOl!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}YoPVr#X#YQ!]^R!kmR{RQ#m#]Q#x#aQ$U#rR$^#yQ#r#^Q$p$`R$y$nQ#l#]Q#w#aQ$P#mQ$T#rQ$Z#xQ$]#yQ$d$UR$m$^|WPUV^demr}!Q!S!T!U!V!W!X!v!{#X#Y#e$esXOl!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}r]Ol!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}Q![^Q!edQ!geQ#R!XQ#T!WR$s$eZpPVr#X#YshOl!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}R#t#_Q$X#uQ%O$|R%P$}T$f$X$gQ$j$XR$v$gQlOR!jlQwQR!owQ}UR!s}QzRR!qz^#p#^#b#u$`$n$|$}R$R#pQ!x!OQ#c!tT#g!x#cQ!{!QQ#e!vT#h!{#eWrPV#X#YR!lrS!aa!^R#[!aQ$g$XR$t$gTkOlSiOlQ!|!RQ#]!bQ#`!hQ#a!r`#o#^#b#p#u$`$n$|$}Q#s#_Q$a#}R$o$_raOl!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}Q!^^R#Z!`tZO^l!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}YoPVr#X#YQ!QUQ!cdQ!feQ!kmQ!v}W!z!Q!v!{#eQ!}!SQ#O!TQ#P!UQ#R!VQ#S!WQ#U!XR$r$erYOl!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}znPUVdemr}!Q!S!T!U!V!W!X!v!{#X#Y#e$eR!Y^TvQw!RSOPV^lmr!R!b!h!r#X#Y#^#_#b#p#u#}$_$`$n$|$}U#q#^$`$nQ#y#bV$W#u$|$}ZqPVr#X#YscOl!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}sfOl!R!b!h!r#^#_#b#p#u#}$_$`$n$|$}",
|
||||
nodeNames: "⚠ Star Slash Plus Minus And Or Eq EqEq Neq Lt Lte Gt Gte Modulo PlusEq MinusEq StarEq SlashEq ModuloEq Identifier AssignableIdentifier Word IdentifierBeforeDot Do Program PipeExpr FunctionCall DotGet Number ParenExpr FunctionCallOrIdentifier BinOp String StringFragment Interpolation EscapeSeq Boolean Regex Dict NamedArg NamedArgPrefix FunctionDef Params colon CatchExpr keyword TryBlock FinallyExpr keyword keyword Underscore Array Null ConditionalOp PositionalArg operator TryExpr keyword Throw keyword IfExpr keyword SingleLineThenBlock ThenBlock ElseIfExpr keyword ElseExpr keyword CompoundAssign Assign",
|
||||
maxTerm: 112,
|
||||
states: "3[QYQbOOO#hQcO'#CvO$eOSO'#CxO$sQbO'#EVOOQ`'#DR'#DROOQa'#DO'#DOO%vQbO'#DWO'RQcO'#DzOOQa'#Dz'#DzO(UQcO'#DzO)WQcO'#DyO*PQRO'#CwO*dQcO'#DuO*{QcO'#DuO+^QbO'#CuO,UOpO'#CsOOQ`'#Dv'#DvO,ZQbO'#DuO,iQbO'#E]OOQ`'#D]'#D]O-^QRO'#DeOOQ`'#Du'#DuO-cQQO'#DtOOQ`'#Dt'#DtOOQ`'#Df'#DfQYQbOOO-kQbO'#DPOOQa'#Dy'#DyOOQ`'#DZ'#DZOOQ`'#E['#E[OOQ`'#Dm'#DmO-uQbO,59^O.cQbO'#CzO.kQWO'#C{OOOO'#D|'#D|OOOO'#Dg'#DgO/POSO,59dOOQa,59d,59dOOQ`'#Di'#DiO/_QbO'#DSO/gQQO,5:qOOQ`'#Dh'#DhO/lQbO,59rO/sQQO,59jOOQa,59r,59rO0OQbO,59rO0YQbO,5:PO,iQbO,59cO,iQbO,59cO,iQbO,59cO,iQbO,59tO,iQbO,59tO,iQbO,59tO0dQRO,59aO0kQRO,59aO0|QRO,59aO0wQQO,59aO1XQQO,59aO1aObO,59_O1lQbO'#DnO1wQbO,59]O2YQRO,5:wO2aQRO,5:wOOQ`,5:`,5:`OOQ`-E7d-E7dOOQ`,59k,59kOOQ`-E7k-E7kOOOO,59f,59fOOOO,59g,59gOOOO-E7e-E7eOOQa1G/O1G/OOOQ`-E7g-E7gO2lQbO1G0]OOQ`-E7f-E7fO2yQQO1G/UOOQa1G/^1G/^O3UQbO1G/^OOQO'#Dk'#DkO2yQQO1G/UOOQa1G/U1G/UOOQ`'#Dl'#DlO3UQbO1G/^OOQ`1G/k1G/kOOQa1G.}1G.}O3wQcO1G.}O4RQcO1G.}O4]QcO1G.}OOQa1G/`1G/`O5oQcO1G/`O5vQcO1G/`O5}QcO1G/`OOQa1G.{1G.{OOQa1G.y1G.yO!ZQbO'#CvO6UQbO'#CrOOQ`,5:Y,5:YOOQ`-E7l-E7lO6cQbO1G0cO6pQbO7+%wO6uQbO7+%xO7VQQO7+$pOOQa7+$p7+$pO7bQbO7+$xOOQa7+$x7+$xOOQO-E7i-E7iOOQ`-E7j-E7jOOQ`'#D_'#D_O7lQbO7+%}O7qQbO7+&OOOQ`<<Ic<<IcOOQ`'#Dj'#DjO8XQQO'#DjO8^QbO'#EXO8tQbO<<IdOOQa<<H[<<H[OOQa<<Hd<<HdOOQ`<<Ii<<IiOOQ`'#D`'#D`O8yQbO<<IjOOQ`,5:U,5:UOOQ`-E7h-E7hOOQ`AN?OAN?OO,iQbO'#DaOOQ`'#Do'#DoO9UQbOAN?UO9aQQO'#DcOOQ`AN?UAN?UO9fQbOAN?UO9kQRO,59{O9rQRO,59{OOQ`-E7m-E7mOOQ`G24pG24pO9}QbOG24pO:SQQO,59}O:XQQO1G/gOOQ`LD*[LD*[O6uQbO1G/iO7qQbO7+%ROOQ`7+%T7+%TOOQ`<<Hm<<Hm",
|
||||
stateData: ":a~O!fOS!gOS~O_PO`dOaWOb_OcROhWOpWOqWO{WO!QbO!l^O!oQO!vTO!wUO!xgO~O_kOaWOb_OcROhWOpWOqWOtjOylO{WO!l^O!oQO!vTO!wUO!OjX!xjX#RjX!}jXxjX~OP!mXQ!mXR!mXS!mXT!mXU!mXW!mXX!mXY!mXZ!mX[!mX]!mX^!mX~P!ZOmrO!ouO!qpO!rqO~O_vOwvP~O_kOaWOb_OhWOpWOqWOtjO{WO!l^O!oQO!vTO!wUO!xyO~O!||O~P${OP!nXQ!nXR!nXS!nXT!nXU!nXW!nXX!nXY!nXZ!nX[!nX]!nX^!nX!x!nX#R!nXx!nX~O_kOaWOb_OcROhWOpWOqWOtjOylO{WO!l^O!oQO!vTO!wUO!}!nX~P%}OV!OO~P%}OP!mXQ!mXR!mXS!mXT!mXU!mXW!mXX!mXY!mXZ!mX[!mX]!mX^!mX~O!x!iX#R!iXx!iX~P(]OT!TOU!UOW!SOX!SOY!SOZ!SO[!SO]!SO~OP!QOQ!QOR!ROS!RO^!PO~P)eOP!QOQ!QOR!ROS!RO!x!iX#R!iXx!iX~OT!TOU!UO!x!iX#R!iXx!iX~O_POaWOb_OcROhWOpWOqWO{WO!l^O!oQO!vTO!wUO~O!k![O~O!O!]O!x!iX#R!iXx!iX~O_kOaWOb_OhWOpWOqWO{WO!l^O!oQO!vTO!wUO~OV!OO~O!x!aO#R!aO~OcROy!cO~P,iOcROtjOylO!Ofa!xfa#Rfa!}faxfa~P,iO_!eO!l^O~O!o!fO!q!fO!r!fO!s!fO!t!fO!u!fO~OmrO!o!hO!qpO!rqO~O_vOwvX~Ow!jO~O!|!mO~P${OtjO!x!oO!|!qO~O!x!rO!|!mO~P,iO`dO!QbO~P+^O!}!}O~P(]OP!QOQ!QOR!ROS!RO!}!}O~OT!TOU!UO!}!}O~O!O!]O!}!}O~O_#OOh#OO!l^O~O_#POb_O!l^O~O!O!]O!xea#Rea!}eaxea~Ow#TO~P)eOT!TOU!UOw#TO~O`dO!QbO!x#VO~P+^OtjO!x!oO!|#XO~O!x!rO!|#ZO~P,iO^!PORkiSki!xki#Rki!}kixki~OPkiQki~P3`OP!QOQ!QO~P3`OP!QOQ!QORkiSki!xki#Rki!}kixki~OW!SOX!SOY!SOZ!SO[!SO]!SOT|i!x|i#R|i!}|iw|ix|i~OU!UO~P4wOU!UO~P5ZOU|i~P4wOcROtjOylO~P,iO`dO!QbO!x#`O~P+^Ox#aO~O`dO!QbO!x#bOx!{P~P+^OtjO!x!oO!|#fO~O!x!rO!|#gO~P,iOx#hO~O`dO!QbO!x#bOx!{P!U!{P!W!{P~P+^O!x#kO~O`dO!QbO!x#bOx!{X!U!{X!W!{X~P+^Ox#mO~Ox#rO!U#nO!W#qO~Ox#wO!U#nO!W#qO~Ow#yO~Ox#wO~Ow#zO~P)eOT!TOU!UOw#zO~Ox#{O~O!x#|O~O!x#}O~Ohq~",
|
||||
goto: "/r#RPPPPPPPPPPPPPPPPPPPPP#S#c#qP$i#c%g%|P&o&oPP%|&sP'W'qPPP'tP(i)UP)]P)i)l)uP)yP)]*P*V*]*c*i*r*|+W+a+hPPPP+n+r,WPP,j-wP.nPPPPPPPP.r.r/VPP/_/f/fdeOi!O!j#T#V#`#d#|#}R!Y^i`O^i!O!]!j#T#V#`#d#|#}fPO^i!O!j#T#V#`#d#|#}xkPUVbjoz}!P!Q!R!S!T!U!n!s#P#Q#Y#nR#P!]fVO^i!O!j#T#V#`#d#|#}xWPUVbjoz}!P!Q!R!S!T!U!n!s#P#Q#Y#nQ!epQ#O![R#Q!]d[Oi!O!j#T#V#`#d#|#}Q!W^Q!u!QR!x!R!aWOPUV^bijoz}!O!P!Q!R!S!T!U!j!n!s#P#Q#T#V#Y#`#d#n#|#}TrQtYmPVo#P#QQ{UQ!lzX!o{!l!p#WdeOi!O!j#T#V#`#d#|#}YlPVo#P#QQ!Y^R!cjRxRzWPUV^bjoz}!P!Q!R!S!T!U!n!s#P#Q#Y#neXOi!O!j#T#V#`#d#|#}d]Oi!O!j#T#V#`#d#|#}Q!X^Q!`bQ!y!UQ!{!TR#u#nZmPVo#P#QeeOi!O!j#T#V#`#d#|#}R#_#TQ#j#`Q$O#|R$P#}T#o#j#pQ#s#jR#x#pQiOR!biQtQR!gtQzUR!kzQwRR!iwW#d#V#`#|#}R#l#dQ!p{Q#W!lT#[!p#WQ!s}Q#Y!nT#]!s#YWoPV#P#QR!doS!^a!ZR#S!^Q#p#jR#v#pThOiSfOiQ!t!OQ#U!jQ#^#TZ#c#V#`#d#|#}daOi!O!j#T#V#`#d#|#}Q!Z^R#R!]fZO^i!O!j#T#V#`#d#|#}YlPVo#P#QQ}UQ!_bQ!cjQ!nzW!r}!n!s#YQ!u!PQ!v!QQ!w!RQ!y!SQ!z!TQ!|!UR#t#ndYOi!O!j#T#V#`#d#|#}xkPUVbjoz}!P!Q!R!S!T!U!n!s#P#Q#Y#nR!V^TsQtsSOPV^ijo!O!j#P#Q#T#V#`#d#|#}Q#e#VV#i#`#|#}ZnPVo#P#QecOi!O!j#T#V#`#d#|#}",
|
||||
nodeNames: "⚠ Star Slash Plus Minus And Or Eq EqEq Neq Lt Lte Gt Gte Modulo Identifier AssignableIdentifier Word IdentifierBeforeDot Do Program PipeExpr FunctionCall DotGet Number ParenExpr FunctionCallOrIdentifier BinOp String StringFragment Interpolation EscapeSeq Boolean Regex Dict NamedArg NamedArgPrefix FunctionDef Params colon keyword Underscore Array Null ConditionalOp PositionalArg operator IfExpr keyword SingleLineThenBlock ThenBlock ElseIfExpr keyword ElseExpr keyword Assign",
|
||||
maxTerm: 95,
|
||||
context: trackScope,
|
||||
nodeProps: [
|
||||
["closedBy", 44,"end"]
|
||||
["closedBy", 39,"end"]
|
||||
],
|
||||
propSources: [highlighting],
|
||||
skippedNodes: [0],
|
||||
repeatNodeCount: 10,
|
||||
tokenData: "AO~R|OX#{XY$jYZ%TZp#{pq$jqs#{st%ntu'Vuw#{wx'[xy'ayz'zz{#{{|(e|}#{}!O(e!O!P#{!P!Q+X!Q![)S![!]3t!]!^%T!^!}#{!}#O4_#O#P6T#P#Q6Y#Q#R#{#R#S6s#S#T#{#T#Y7^#Y#Z8l#Z#b7^#b#c<z#c#f7^#f#g=q#g#h7^#h#i>h#i#o7^#o#p#{#p#q@`#q;'S#{;'S;=`$d<%l~#{~O#{~~@yS$QUrSOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{S$gP;=`<%l#{^$qUrS!uYOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U%[UrS#XQOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{^%uZrS!vYOY%nYZ#{Zt%ntu&huw%nwx&hx#O%n#O#P&h#P;'S%n;'S;=`'P<%lO%nY&mS!vYOY&hZ;'S&h;'S;=`&y<%lO&hY&|P;=`<%l&h^'SP;=`<%l%n~'[O#Q~~'aO#O~U'hUrS!{QOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U(RUrS#^QOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U(jWrSOt#{uw#{x!Q#{!Q![)S![#O#{#P;'S#{;'S;=`$d<%lO#{U)ZYrSmQOt#{uw#{x!O#{!O!P)y!P!Q#{!Q![)S![#O#{#P;'S#{;'S;=`$d<%lO#{U*OWrSOt#{uw#{x!Q#{!Q![*h![#O#{#P;'S#{;'S;=`$d<%lO#{U*oWrSmQOt#{uw#{x!Q#{!Q![*h![#O#{#P;'S#{;'S;=`$d<%lO#{U+^WrSOt#{uw#{x!P#{!P!Q+v!Q#O#{#P;'S#{;'S;=`$d<%lO#{U+{^rSOY,wYZ#{Zt,wtu-zuw,wwx-zx!P,w!P!Q#{!Q!},w!}#O2m#O#P0Y#P;'S,w;'S;=`3n<%lO,wU-O^rSvQOY,wYZ#{Zt,wtu-zuw,wwx-zx!P,w!P!Q0o!Q!},w!}#O2m#O#P0Y#P;'S,w;'S;=`3n<%lO,wQ.PXvQOY-zZ!P-z!P!Q.l!Q!}-z!}#O/Z#O#P0Y#P;'S-z;'S;=`0i<%lO-zQ.oP!P!Q.rQ.wUvQ#Z#[.r#]#^.r#a#b.r#g#h.r#i#j.r#m#n.rQ/^VOY/ZZ#O/Z#O#P/s#P#Q-z#Q;'S/Z;'S;=`0S<%lO/ZQ/vSOY/ZZ;'S/Z;'S;=`0S<%lO/ZQ0VP;=`<%l/ZQ0]SOY-zZ;'S-z;'S;=`0i<%lO-zQ0lP;=`<%l-zU0tWrSOt#{uw#{x!P#{!P!Q1^!Q#O#{#P;'S#{;'S;=`$d<%lO#{U1ebrSvQOt#{uw#{x#O#{#P#Z#{#Z#[1^#[#]#{#]#^1^#^#a#{#a#b1^#b#g#{#g#h1^#h#i#{#i#j1^#j#m#{#m#n1^#n;'S#{;'S;=`$d<%lO#{U2r[rSOY2mYZ#{Zt2mtu/Zuw2mwx/Zx#O2m#O#P/s#P#Q,w#Q;'S2m;'S;=`3h<%lO2mU3kP;=`<%l2mU3qP;=`<%l,wU3{UrS|QOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U4fW#WQrSOt#{uw#{x!_#{!_!`5O!`#O#{#P;'S#{;'S;=`$d<%lO#{U5TVrSOt#{uw#{x#O#{#P#Q5j#Q;'S#{;'S;=`$d<%lO#{U5qU#VQrSOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{~6YO#R~U6aU#]QrSOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U6zUrS!TQOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U7cYrSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#o7^#o;'S#{;'S;=`$d<%lO#{U8YUyQrSOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U8qZrSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#U9d#U#o7^#o;'S#{;'S;=`$d<%lO#{U9i[rSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#`7^#`#a:_#a#o7^#o;'S#{;'S;=`$d<%lO#{U:d[rSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#g7^#g#h;Y#h#o7^#o;'S#{;'S;=`$d<%lO#{U;_[rSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#X7^#X#Y<T#Y#o7^#o;'S#{;'S;=`$d<%lO#{U<[YuQrSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#o7^#o;'S#{;'S;=`$d<%lO#{^=RY#SWrSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#o7^#o;'S#{;'S;=`$d<%lO#{^=xY#UWrSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#o7^#o;'S#{;'S;=`$d<%lO#{^>o[#TWrSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#f7^#f#g?e#g#o7^#o;'S#{;'S;=`$d<%lO#{U?j[rSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#i7^#i#j;Y#j#o7^#o;'S#{;'S;=`$d<%lO#{U@gU!YQrSOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{~AOO#d~",
|
||||
tokenizers: [operatorTokenizer, 1, 2, 3, tokenizer, new LocalTokenGroup("[~RP!O!PU~ZO!z~~", 11)],
|
||||
topRules: {"Program":[0,25]},
|
||||
specialized: [{term: 20, get: (value: any, stack: any) => (specializeKeyword(value, stack) << 1), external: specializeKeyword},{term: 20, get: (value: keyof typeof spec_Identifier) => spec_Identifier[value] || -1}],
|
||||
tokenPrec: 1591
|
||||
tokenData: "AO~R|OX#{XY$jYZ%TZp#{pq$jqs#{st%ntu'Vuw#{wx'[xy'ayz'zz{#{{|(e|}#{}!O(e!O!P#{!P!Q+X!Q![)S![!]3t!]!^%T!^!}#{!}#O4_#O#P6T#P#Q6Y#Q#R#{#R#S6s#S#T#{#T#Y7^#Y#Z8l#Z#b7^#b#c<z#c#f7^#f#g=q#g#h7^#h#i>h#i#o7^#o#p#{#p#q@`#q;'S#{;'S;=`$d<%l~#{~O#{~~@yS$QUmSOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{S$gP;=`<%l#{^$qUmS!fYOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U%[UmS!xQOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{^%uZmS!gYOY%nYZ#{Zt%ntu&huw%nwx&hx#O%n#O#P&h#P;'S%n;'S;=`'P<%lO%nY&mS!gYOY&hZ;'S&h;'S;=`&y<%lO&hY&|P;=`<%l&h^'SP;=`<%l%n~'[O!q~~'aO!o~U'hUmS!lQOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U(RUmS!}QOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U(jWmSOt#{uw#{x!Q#{!Q![)S![#O#{#P;'S#{;'S;=`$d<%lO#{U)ZYmShQOt#{uw#{x!O#{!O!P)y!P!Q#{!Q![)S![#O#{#P;'S#{;'S;=`$d<%lO#{U*OWmSOt#{uw#{x!Q#{!Q![*h![#O#{#P;'S#{;'S;=`$d<%lO#{U*oWmShQOt#{uw#{x!Q#{!Q![*h![#O#{#P;'S#{;'S;=`$d<%lO#{U+^WmSOt#{uw#{x!P#{!P!Q+v!Q#O#{#P;'S#{;'S;=`$d<%lO#{U+{^mSOY,wYZ#{Zt,wtu-zuw,wwx-zx!P,w!P!Q#{!Q!},w!}#O2m#O#P0Y#P;'S,w;'S;=`3n<%lO,wU-O^mSqQOY,wYZ#{Zt,wtu-zuw,wwx-zx!P,w!P!Q0o!Q!},w!}#O2m#O#P0Y#P;'S,w;'S;=`3n<%lO,wQ.PXqQOY-zZ!P-z!P!Q.l!Q!}-z!}#O/Z#O#P0Y#P;'S-z;'S;=`0i<%lO-zQ.oP!P!Q.rQ.wUqQ#Z#[.r#]#^.r#a#b.r#g#h.r#i#j.r#m#n.rQ/^VOY/ZZ#O/Z#O#P/s#P#Q-z#Q;'S/Z;'S;=`0S<%lO/ZQ/vSOY/ZZ;'S/Z;'S;=`0S<%lO/ZQ0VP;=`<%l/ZQ0]SOY-zZ;'S-z;'S;=`0i<%lO-zQ0lP;=`<%l-zU0tWmSOt#{uw#{x!P#{!P!Q1^!Q#O#{#P;'S#{;'S;=`$d<%lO#{U1ebmSqQOt#{uw#{x#O#{#P#Z#{#Z#[1^#[#]#{#]#^1^#^#a#{#a#b1^#b#g#{#g#h1^#h#i#{#i#j1^#j#m#{#m#n1^#n;'S#{;'S;=`$d<%lO#{U2r[mSOY2mYZ#{Zt2mtu/Zuw2mwx/Zx#O2m#O#P/s#P#Q,w#Q;'S2m;'S;=`3h<%lO2mU3kP;=`<%l2mU3qP;=`<%l,wU3{UmSwQOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U4fW!wQmSOt#{uw#{x!_#{!_!`5O!`#O#{#P;'S#{;'S;=`$d<%lO#{U5TVmSOt#{uw#{x#O#{#P#Q5j#Q;'S#{;'S;=`$d<%lO#{U5qU!vQmSOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{~6YO!r~U6aU!|QmSOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U6zUmSyQOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U7cYmSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#o7^#o;'S#{;'S;=`$d<%lO#{U8YUtQmSOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{U8qZmSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#U9d#U#o7^#o;'S#{;'S;=`$d<%lO#{U9i[mSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#`7^#`#a:_#a#o7^#o;'S#{;'S;=`$d<%lO#{U:d[mSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#g7^#g#h;Y#h#o7^#o;'S#{;'S;=`$d<%lO#{U;_[mSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#X7^#X#Y<T#Y#o7^#o;'S#{;'S;=`$d<%lO#{U<[YpQmSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#o7^#o;'S#{;'S;=`$d<%lO#{^=RY!sWmSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#o7^#o;'S#{;'S;=`$d<%lO#{^=xY!uWmSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#o7^#o;'S#{;'S;=`$d<%lO#{^>o[!tWmSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#f7^#f#g?e#g#o7^#o;'S#{;'S;=`$d<%lO#{U?j[mSOt#{uw#{x!_#{!_!`8R!`#O#{#P#T#{#T#i7^#i#j;Y#j#o7^#o;'S#{;'S;=`$d<%lO#{U@gU!OQmSOt#{uw#{x#O#{#P;'S#{;'S;=`$d<%lO#{~AOO#R~",
|
||||
tokenizers: [operatorTokenizer, 1, 2, 3, tokenizer, new LocalTokenGroup("[~RP!O!PU~ZO!k~~", 11)],
|
||||
topRules: {"Program":[0,20]},
|
||||
specialized: [{term: 15, get: (value: any, stack: any) => (specializeKeyword(value, stack) << 1), external: specializeKeyword},{term: 15, get: (value: keyof typeof spec_Identifier) => spec_Identifier[value] || -1}],
|
||||
tokenPrec: 1164
|
||||
})
|
||||
|
|
|
|||
|
|
@ -532,72 +532,6 @@ describe('Assign', () => {
|
|||
})
|
||||
})
|
||||
|
||||
describe('CompoundAssign', () => {
|
||||
test('parses += operator', () => {
|
||||
expect('x += 5').toMatchTree(`
|
||||
CompoundAssign
|
||||
AssignableIdentifier x
|
||||
PlusEq +=
|
||||
Number 5`)
|
||||
})
|
||||
|
||||
test('parses -= operator', () => {
|
||||
expect('count -= 1').toMatchTree(`
|
||||
CompoundAssign
|
||||
AssignableIdentifier count
|
||||
MinusEq -=
|
||||
Number 1`)
|
||||
})
|
||||
|
||||
test('parses *= operator', () => {
|
||||
expect('total *= 2').toMatchTree(`
|
||||
CompoundAssign
|
||||
AssignableIdentifier total
|
||||
StarEq *=
|
||||
Number 2`)
|
||||
})
|
||||
|
||||
test('parses /= operator', () => {
|
||||
expect('value /= 10').toMatchTree(`
|
||||
CompoundAssign
|
||||
AssignableIdentifier value
|
||||
SlashEq /=
|
||||
Number 10`)
|
||||
})
|
||||
|
||||
test('parses %= operator', () => {
|
||||
expect('remainder %= 3').toMatchTree(`
|
||||
CompoundAssign
|
||||
AssignableIdentifier remainder
|
||||
ModuloEq %=
|
||||
Number 3`)
|
||||
})
|
||||
|
||||
test('parses compound assignment with expression', () => {
|
||||
expect('x += 1 + 2').toMatchTree(`
|
||||
CompoundAssign
|
||||
AssignableIdentifier x
|
||||
PlusEq +=
|
||||
BinOp
|
||||
Number 1
|
||||
Plus +
|
||||
Number 2`)
|
||||
})
|
||||
|
||||
test('parses compound assignment with function call', () => {
|
||||
expect('total += add 5 3').toMatchTree(`
|
||||
CompoundAssign
|
||||
AssignableIdentifier total
|
||||
PlusEq +=
|
||||
FunctionCall
|
||||
Identifier add
|
||||
PositionalArg
|
||||
Number 5
|
||||
PositionalArg
|
||||
Number 3`)
|
||||
})
|
||||
})
|
||||
|
||||
describe('DotGet whitespace sensitivity', () => {
|
||||
test('no whitespace - DotGet works when identifier in scope', () => {
|
||||
expect('basename = 5; basename.prop').toMatchTree(`
|
||||
|
|
|
|||
|
|
@ -1,278 +0,0 @@
|
|||
import { expect, describe, test } from 'bun:test'
|
||||
|
||||
import '../shrimp.grammar' // Importing this so changes cause it to retest!
|
||||
|
||||
describe('try/catch/finally/throw', () => {
|
||||
test('parses try with catch', () => {
|
||||
expect(`try:
|
||||
risky-operation
|
||||
catch err:
|
||||
handle-error err
|
||||
end`).toMatchTree(`
|
||||
TryExpr
|
||||
keyword try
|
||||
colon :
|
||||
TryBlock
|
||||
FunctionCallOrIdentifier
|
||||
Identifier risky-operation
|
||||
CatchExpr
|
||||
keyword catch
|
||||
Identifier err
|
||||
colon :
|
||||
TryBlock
|
||||
FunctionCall
|
||||
Identifier handle-error
|
||||
PositionalArg
|
||||
Identifier err
|
||||
keyword end
|
||||
`)
|
||||
})
|
||||
|
||||
test('parses try with finally', () => {
|
||||
expect(`try:
|
||||
do-work
|
||||
finally:
|
||||
cleanup
|
||||
end`).toMatchTree(`
|
||||
TryExpr
|
||||
keyword try
|
||||
colon :
|
||||
TryBlock
|
||||
FunctionCallOrIdentifier
|
||||
Identifier do-work
|
||||
FinallyExpr
|
||||
keyword finally
|
||||
colon :
|
||||
TryBlock
|
||||
FunctionCallOrIdentifier
|
||||
Identifier cleanup
|
||||
keyword end
|
||||
`)
|
||||
})
|
||||
|
||||
test('parses try with catch and finally', () => {
|
||||
expect(`try:
|
||||
risky-operation
|
||||
catch err:
|
||||
handle-error err
|
||||
finally:
|
||||
cleanup
|
||||
end`).toMatchTree(`
|
||||
TryExpr
|
||||
keyword try
|
||||
colon :
|
||||
TryBlock
|
||||
FunctionCallOrIdentifier
|
||||
Identifier risky-operation
|
||||
CatchExpr
|
||||
keyword catch
|
||||
Identifier err
|
||||
colon :
|
||||
TryBlock
|
||||
FunctionCall
|
||||
Identifier handle-error
|
||||
PositionalArg
|
||||
Identifier err
|
||||
FinallyExpr
|
||||
keyword finally
|
||||
colon :
|
||||
TryBlock
|
||||
FunctionCallOrIdentifier
|
||||
Identifier cleanup
|
||||
keyword end
|
||||
`)
|
||||
})
|
||||
|
||||
test('parses single-line try with catch', () => {
|
||||
expect('result = try: parse-number input catch err: 0 end').toMatchTree(`
|
||||
Assign
|
||||
AssignableIdentifier result
|
||||
Eq =
|
||||
TryExpr
|
||||
keyword try
|
||||
colon :
|
||||
FunctionCall
|
||||
Identifier parse-number
|
||||
PositionalArg
|
||||
Identifier input
|
||||
CatchExpr
|
||||
keyword catch
|
||||
Identifier err
|
||||
colon :
|
||||
Number 0
|
||||
keyword end
|
||||
`)
|
||||
})
|
||||
|
||||
test('parses single-line try with finally', () => {
|
||||
expect('try: work catch err: 0 finally: cleanup end').toMatchTree(`
|
||||
TryExpr
|
||||
keyword try
|
||||
colon :
|
||||
FunctionCallOrIdentifier
|
||||
Identifier work
|
||||
CatchExpr
|
||||
keyword catch
|
||||
Identifier err
|
||||
colon :
|
||||
Number 0
|
||||
FinallyExpr
|
||||
keyword finally
|
||||
colon :
|
||||
FunctionCallOrIdentifier
|
||||
Identifier cleanup
|
||||
keyword end
|
||||
`)
|
||||
})
|
||||
|
||||
test('parses throw statement with string', () => {
|
||||
expect("throw 'error message'").toMatchTree(`
|
||||
Throw
|
||||
keyword throw
|
||||
String
|
||||
StringFragment error message
|
||||
`)
|
||||
})
|
||||
|
||||
test('parses throw statement with identifier', () => {
|
||||
expect('throw error-object').toMatchTree(`
|
||||
Throw
|
||||
keyword throw
|
||||
Identifier error-object
|
||||
`)
|
||||
})
|
||||
|
||||
test('parses throw statement with dict', () => {
|
||||
expect('throw [type=validation-error message=failed]').toMatchTree(`
|
||||
Throw
|
||||
keyword throw
|
||||
Dict
|
||||
NamedArg
|
||||
NamedArgPrefix type=
|
||||
Identifier validation-error
|
||||
NamedArg
|
||||
NamedArgPrefix message=
|
||||
Identifier failed
|
||||
`)
|
||||
})
|
||||
|
||||
test('does not parse identifiers that start with try', () => {
|
||||
expect('trying = try: work catch err: 0 end').toMatchTree(`
|
||||
Assign
|
||||
AssignableIdentifier trying
|
||||
Eq =
|
||||
TryExpr
|
||||
keyword try
|
||||
colon :
|
||||
FunctionCallOrIdentifier
|
||||
Identifier work
|
||||
CatchExpr
|
||||
keyword catch
|
||||
Identifier err
|
||||
colon :
|
||||
Number 0
|
||||
keyword end
|
||||
`)
|
||||
})
|
||||
})
|
||||
|
||||
describe('function-level exception handling', () => {
|
||||
test('parses function with catch', () => {
|
||||
expect(`read-file = do path:
|
||||
read-data path
|
||||
catch e:
|
||||
empty-string
|
||||
end`).toMatchTree(`
|
||||
Assign
|
||||
AssignableIdentifier read-file
|
||||
Eq =
|
||||
FunctionDef
|
||||
Do do
|
||||
Params
|
||||
Identifier path
|
||||
colon :
|
||||
FunctionCall
|
||||
Identifier read-data
|
||||
PositionalArg
|
||||
Identifier path
|
||||
CatchExpr
|
||||
keyword catch
|
||||
Identifier e
|
||||
colon :
|
||||
TryBlock
|
||||
FunctionCallOrIdentifier
|
||||
Identifier empty-string
|
||||
keyword end
|
||||
`)
|
||||
})
|
||||
|
||||
test('parses function with finally', () => {
|
||||
expect(`cleanup-task = do x:
|
||||
do-work x
|
||||
finally:
|
||||
close-resources
|
||||
end`).toMatchTree(`
|
||||
Assign
|
||||
AssignableIdentifier cleanup-task
|
||||
Eq =
|
||||
FunctionDef
|
||||
Do do
|
||||
Params
|
||||
Identifier x
|
||||
colon :
|
||||
FunctionCall
|
||||
Identifier do-work
|
||||
PositionalArg
|
||||
Identifier x
|
||||
FinallyExpr
|
||||
keyword finally
|
||||
colon :
|
||||
TryBlock
|
||||
FunctionCallOrIdentifier
|
||||
Identifier close-resources
|
||||
keyword end
|
||||
`)
|
||||
})
|
||||
|
||||
test('parses function with catch and finally', () => {
|
||||
expect(`safe-operation = do x:
|
||||
risky-work x
|
||||
catch err:
|
||||
log err
|
||||
default-value
|
||||
finally:
|
||||
cleanup
|
||||
end`).toMatchTree(`
|
||||
Assign
|
||||
AssignableIdentifier safe-operation
|
||||
Eq =
|
||||
FunctionDef
|
||||
Do do
|
||||
Params
|
||||
Identifier x
|
||||
colon :
|
||||
FunctionCall
|
||||
Identifier risky-work
|
||||
PositionalArg
|
||||
Identifier x
|
||||
CatchExpr
|
||||
keyword catch
|
||||
Identifier err
|
||||
colon :
|
||||
TryBlock
|
||||
FunctionCall
|
||||
Identifier log
|
||||
PositionalArg
|
||||
Identifier err
|
||||
FunctionCallOrIdentifier
|
||||
Identifier default-value
|
||||
FinallyExpr
|
||||
keyword finally
|
||||
colon :
|
||||
TryBlock
|
||||
FunctionCallOrIdentifier
|
||||
Identifier cleanup
|
||||
keyword end
|
||||
`)
|
||||
})
|
||||
})
|
||||
|
|
@ -184,17 +184,6 @@ const chooseIdentifierToken = (input: InputStream, stack: Stack): number => {
|
|||
}
|
||||
|
||||
const nextCh = getFullCodePoint(input, peekPos)
|
||||
const nextCh2 = getFullCodePoint(input, peekPos + 1)
|
||||
|
||||
// Check for compound assignment operators: +=, -=, *=, /=, %=
|
||||
if ([43/* + */, 45/* - */, 42/* * */, 47/* / */, 37/* % */].includes(nextCh) && nextCh2 === 61/* = */) {
|
||||
// Found compound operator, check if it's followed by whitespace
|
||||
const charAfterOp = getFullCodePoint(input, peekPos + 2)
|
||||
if (isWhiteSpace(charAfterOp) || charAfterOp === -1 /* EOF */) {
|
||||
return AssignableIdentifier
|
||||
}
|
||||
}
|
||||
|
||||
if (nextCh === 61 /* = */) {
|
||||
// Found '=', but check if it's followed by whitespace
|
||||
// If '=' is followed by non-whitespace (like '=cool*'), it won't be tokenized as Eq
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ export const globals = {
|
|||
switch (value.type) {
|
||||
case 'string': case 'array': return value.value.length
|
||||
case 'dict': return value.value.size
|
||||
default: throw new Error(`length: expected string, array, or dict, got ${value.type}`)
|
||||
default: return 0
|
||||
}
|
||||
},
|
||||
|
||||
|
|
@ -65,24 +65,7 @@ export const globals = {
|
|||
identity: (v: any) => v,
|
||||
|
||||
// collections
|
||||
at: (collection: any, index: number | string) => {
|
||||
const value = toValue(collection)
|
||||
if (value.type === 'string' || value.type === 'array') {
|
||||
const idx = typeof index === 'number' ? index : parseInt(index as string)
|
||||
if (idx < 0 || idx >= value.value.length) {
|
||||
throw new Error(`at: index ${idx} out of bounds for ${value.type} of length ${value.value.length}`)
|
||||
}
|
||||
return value.value[idx]
|
||||
} else if (value.type === 'dict') {
|
||||
const key = String(index)
|
||||
if (!value.value.has(key)) {
|
||||
throw new Error(`at: key '${key}' not found in dict`)
|
||||
}
|
||||
return value.value.get(key)
|
||||
} else {
|
||||
throw new Error(`at: expected string, array, or dict, got ${value.type}`)
|
||||
}
|
||||
},
|
||||
at: (collection: any, index: number | string) => collection[index],
|
||||
range: (start: number, end: number | null) => {
|
||||
if (end === null) {
|
||||
end = start
|
||||
|
|
|
|||
|
|
@ -1,5 +1,3 @@
|
|||
import { type Value, toValue, toNull } from 'reefvm'
|
||||
|
||||
export const list = {
|
||||
slice: (list: any[], start: number, end?: number) => list.slice(start, end),
|
||||
map: async (list: any[], cb: Function) => {
|
||||
|
|
@ -42,41 +40,9 @@ export const list = {
|
|||
return true
|
||||
},
|
||||
|
||||
// mutating
|
||||
push: (list: Value, item: Value) => {
|
||||
if (list.type !== 'array') return toNull()
|
||||
return toValue(list.value.push(item))
|
||||
},
|
||||
pop: (list: Value) => {
|
||||
if (list.type !== 'array') return toNull()
|
||||
return toValue(list.value.pop())
|
||||
},
|
||||
shift: (list: Value) => {
|
||||
if (list.type !== 'array') return toNull()
|
||||
return toValue(list.value.shift())
|
||||
},
|
||||
unshift: (list: Value, item: Value) => {
|
||||
if (list.type !== 'array') return toNull()
|
||||
return toValue(list.value.unshift(item))
|
||||
},
|
||||
splice: (list: Value, start: Value, deleteCount: Value, ...items: Value[]) => {
|
||||
const realList = list.value as any[]
|
||||
const realStart = start.value as number
|
||||
const realDeleteCount = deleteCount.value as number
|
||||
const realItems = items.map(item => item.value)
|
||||
return toValue(realList.splice(realStart, realDeleteCount, ...realItems))
|
||||
},
|
||||
|
||||
// sequence operations
|
||||
reverse: (list: any[]) => list.slice().reverse(),
|
||||
sort: async (list: any[], cb?: (a: any, b: any) => number) => {
|
||||
const arr = [...list]
|
||||
if (!cb) return arr.sort()
|
||||
for (let i = 0; i < arr.length; i++)
|
||||
for (let j = i + 1; j < arr.length; j++)
|
||||
if ((await cb(arr[i], arr[j])) > 0) [arr[i], arr[j]] = [arr[j], arr[i]]
|
||||
return arr
|
||||
},
|
||||
sort: (list: any[], cb?: (a: any, b: any) => number) => list.slice().sort(cb),
|
||||
concat: (...lists: any[][]) => lists.flat(1),
|
||||
flatten: (list: any[], depth: number = 1) => list.flat(depth),
|
||||
unique: (list: any[]) => Array.from(new Set(list)),
|
||||
|
|
@ -86,14 +52,8 @@ export const list = {
|
|||
first: (list: any[]) => list[0] ?? null,
|
||||
last: (list: any[]) => list[list.length - 1] ?? null,
|
||||
rest: (list: any[]) => list.slice(1),
|
||||
take: (list: any[], n: number) => {
|
||||
if (n < 0) throw new Error(`take: count must be non-negative, got ${n}`)
|
||||
return list.slice(0, n)
|
||||
},
|
||||
drop: (list: any[], n: number) => {
|
||||
if (n < 0) throw new Error(`drop: count must be non-negative, got ${n}`)
|
||||
return list.slice(n)
|
||||
},
|
||||
take: (list: any[], n: number) => list.slice(0, n),
|
||||
drop: (list: any[], n: number) => list.slice(n),
|
||||
append: (list: any[], item: any) => [...list, item],
|
||||
prepend: (list: any[], item: any) => [item, ...list],
|
||||
'index-of': (list: any[], item: any) => list.indexOf(item),
|
||||
|
|
@ -126,13 +86,4 @@ export const list = {
|
|||
}
|
||||
return groups
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
// raw functions deal directly in Value types, meaning we can modify collection
|
||||
// careful - they MUST return a Value!
|
||||
; (list.splice as any).raw = true
|
||||
; (list.push as any).raw = true
|
||||
; (list.pop as any).raw = true
|
||||
; (list.shift as any).raw = true
|
||||
; (list.unshift as any).raw = true
|
||||
}
|
||||
|
|
@ -3,24 +3,12 @@ export const math = {
|
|||
floor: (n: number) => Math.floor(n),
|
||||
ceil: (n: number) => Math.ceil(n),
|
||||
round: (n: number) => Math.round(n),
|
||||
min: (...nums: number[]) => {
|
||||
if (nums.length === 0) throw new Error('min: expected at least one argument')
|
||||
return Math.min(...nums)
|
||||
},
|
||||
max: (...nums: number[]) => {
|
||||
if (nums.length === 0) throw new Error('max: expected at least one argument')
|
||||
return Math.max(...nums)
|
||||
},
|
||||
min: (...nums: number[]) => Math.min(...nums),
|
||||
max: (...nums: number[]) => Math.max(...nums),
|
||||
pow: (base: number, exp: number) => Math.pow(base, exp),
|
||||
sqrt: (n: number) => {
|
||||
if (n < 0) throw new Error(`sqrt: cannot take square root of negative number ${n}`)
|
||||
return Math.sqrt(n)
|
||||
},
|
||||
sqrt: (n: number) => Math.sqrt(n),
|
||||
random: () => Math.random(),
|
||||
clamp: (n: number, min: number, max: number) => {
|
||||
if (min > max) throw new Error(`clamp: min (${min}) must be less than or equal to max (${max})`)
|
||||
return Math.min(Math.max(n, min), max)
|
||||
},
|
||||
clamp: (n: number, min: number, max: number) => Math.min(Math.max(n, min), max),
|
||||
sign: (n: number) => Math.sign(n),
|
||||
trunc: (n: number) => Math.trunc(n),
|
||||
|
||||
|
|
|
|||
|
|
@ -21,11 +21,7 @@ export const str = {
|
|||
'replace-all': (str: string, search: string, replacement: string) => str.replaceAll(search, replacement),
|
||||
slice: (str: string, start: number, end?: number | null) => str.slice(start, end ?? undefined),
|
||||
substring: (str: string, start: number, end?: number | null) => str.substring(start, end ?? undefined),
|
||||
repeat: (str: string, count: number) => {
|
||||
if (count < 0) throw new Error(`repeat: count must be non-negative, got ${count}`)
|
||||
if (!Number.isInteger(count)) throw new Error(`repeat: count must be an integer, got ${count}`)
|
||||
return str.repeat(count)
|
||||
},
|
||||
repeat: (str: string, count: number) => str.repeat(count),
|
||||
'pad-start': (str: string, length: number, pad: string = ' ') => str.padStart(length, pad),
|
||||
'pad-end': (str: string, length: number, pad: string = ' ') => str.padEnd(length, pad),
|
||||
lines: (str: string) => str.split('\n'),
|
||||
|
|
|
|||
|
|
@ -176,12 +176,9 @@ describe('introspection', () => {
|
|||
await expect(`length 'hello'`).toEvaluateTo(5, globals)
|
||||
await expect(`length [1 2 3]`).toEvaluateTo(3, globals)
|
||||
await expect(`length [a=1 b=2]`).toEvaluateTo(2, globals)
|
||||
})
|
||||
|
||||
test('length throws on invalid types', async () => {
|
||||
await expect(`try: length 42 catch e: 'error' end`).toEvaluateTo('error', globals)
|
||||
await expect(`try: length true catch e: 'error' end`).toEvaluateTo('error', globals)
|
||||
await expect(`try: length null catch e: 'error' end`).toEvaluateTo('error', globals)
|
||||
await expect(`length 42`).toEvaluateTo(0, globals)
|
||||
await expect(`length true`).toEvaluateTo(0, globals)
|
||||
await expect(`length null`).toEvaluateTo(0, globals)
|
||||
})
|
||||
|
||||
test('inspect formats values', async () => {
|
||||
|
|
@ -344,84 +341,6 @@ describe('collections', () => {
|
|||
await expect(`list.index-of [1 2 3] 5`).toEvaluateTo(-1, globals)
|
||||
})
|
||||
|
||||
test('list.push adds to end and mutates array', async () => {
|
||||
await expect(`arr = [1 2]; list.push arr 3; arr`).toEvaluateTo([1, 2, 3], globals)
|
||||
})
|
||||
|
||||
test('list.push returns the size of the array', async () => {
|
||||
await expect(`arr = [1 2]; arr | list.push 3`).toEvaluateTo(3, globals)
|
||||
})
|
||||
|
||||
test('list.pop removes from end and mutates array', async () => {
|
||||
await expect(`arr = [1 2 3]; list.pop arr; arr`).toEvaluateTo([1, 2], globals)
|
||||
})
|
||||
|
||||
test('list.pop returns removed element', async () => {
|
||||
await expect(`list.pop [1 2 3]`).toEvaluateTo(3, globals)
|
||||
})
|
||||
|
||||
test('list.pop returns null for empty array', async () => {
|
||||
await expect(`list.pop []`).toEvaluateTo(null, globals)
|
||||
})
|
||||
|
||||
test('list.shift removes from start and mutates array', async () => {
|
||||
await expect(`arr = [1 2 3]; list.shift arr; arr`).toEvaluateTo([2, 3], globals)
|
||||
})
|
||||
|
||||
test('list.shift returns removed element', async () => {
|
||||
await expect(`list.shift [1 2 3]`).toEvaluateTo(1, globals)
|
||||
})
|
||||
|
||||
test('list.shift returns null for empty array', async () => {
|
||||
await expect(`list.shift []`).toEvaluateTo(null, globals)
|
||||
})
|
||||
|
||||
test('list.unshift adds to start and mutates array', async () => {
|
||||
await expect(`arr = [2 3]; list.unshift arr 1; arr`).toEvaluateTo([1, 2, 3], globals)
|
||||
})
|
||||
|
||||
test('list.unshift returns the length of the array', async () => {
|
||||
await expect(`arr = [2 3]; arr | list.unshift 1`).toEvaluateTo(3, globals)
|
||||
})
|
||||
|
||||
test('list.splice removes elements and mutates array', async () => {
|
||||
await expect(`arr = [1 2 3 4 5]; list.splice arr 1 2; arr`).toEvaluateTo([1, 4, 5], globals)
|
||||
})
|
||||
|
||||
test('list.splice returns removed elements', async () => {
|
||||
await expect(`list.splice [1 2 3 4 5] 1 2`).toEvaluateTo([2, 3], globals)
|
||||
})
|
||||
|
||||
test('list.splice from start', async () => {
|
||||
await expect(`list.splice [1 2 3 4 5] 0 2`).toEvaluateTo([1, 2], globals)
|
||||
})
|
||||
|
||||
test('list.splice to end', async () => {
|
||||
await expect(`arr = [1 2 3 4 5]; list.splice arr 3 2; arr`).toEvaluateTo([1, 2, 3], globals)
|
||||
})
|
||||
|
||||
test('list.sort with no callback sorts ascending', async () => {
|
||||
await expect(`list.sort [3 1 4 1 5] null`).toEvaluateTo([1, 1, 3, 4, 5], globals)
|
||||
})
|
||||
|
||||
test('list.sort with callback sorts using comparator', async () => {
|
||||
await expect(`
|
||||
desc = do a b:
|
||||
b - a
|
||||
end
|
||||
list.sort [3 1 4 1 5] desc
|
||||
`).toEvaluateTo([5, 4, 3, 1, 1], globals)
|
||||
})
|
||||
|
||||
test('list.sort with callback for strings by length', async () => {
|
||||
await expect(`
|
||||
by-length = do a b:
|
||||
(length a) - (length b)
|
||||
end
|
||||
list.sort ['cat' 'a' 'dog' 'elephant'] by-length
|
||||
`).toEvaluateTo(['a', 'cat', 'dog', 'elephant'], globals)
|
||||
})
|
||||
|
||||
test('list.any? checks if any element matches', async () => {
|
||||
await expect(`
|
||||
gt-three = do x: x > 3 end
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user