1018 lines
21 KiB
TypeScript
1018 lines
21 KiB
TypeScript
import { test, expect, describe } from "bun:test"
|
|
import { run } from "#index"
|
|
import { toBytecode } from "#bytecode"
|
|
|
|
describe("ADD", () => {
|
|
test("add two numbers", async () => {
|
|
const str = `
|
|
PUSH 1
|
|
PUSH 5
|
|
ADD
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 6 })
|
|
|
|
const str2 = `
|
|
PUSH 100
|
|
PUSH 500
|
|
ADD
|
|
`
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'number', value: 600 })
|
|
})
|
|
})
|
|
|
|
describe("SUB", () => {
|
|
test("subtract two numbers", async () => {
|
|
const str = `
|
|
PUSH 5
|
|
PUSH 2
|
|
SUB
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 3 })
|
|
})
|
|
})
|
|
|
|
describe("MUL", () => {
|
|
test("multiply two numbers", async () => {
|
|
const str = `
|
|
PUSH 5
|
|
PUSH 2
|
|
MUL
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 10 })
|
|
})
|
|
})
|
|
|
|
describe("DIV", () => {
|
|
test("divide two numbers", async () => {
|
|
const str = `
|
|
PUSH 10
|
|
PUSH 2
|
|
DIV
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 5 })
|
|
|
|
const str2 = `
|
|
PUSH 10
|
|
PUSH 0
|
|
DIV
|
|
`
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'number', value: Infinity })
|
|
})
|
|
})
|
|
|
|
describe("MOD", () => {
|
|
test("modulo two numbers", async () => {
|
|
const str = `
|
|
PUSH 17
|
|
PUSH 5
|
|
MOD
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 2 })
|
|
})
|
|
})
|
|
|
|
describe("PUSH", () => {
|
|
test("pushes value onto stack", async () => {
|
|
const str = `
|
|
PUSH 42
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 42 })
|
|
})
|
|
})
|
|
|
|
describe("POP", () => {
|
|
test("removes top value", async () => {
|
|
const str = `
|
|
PUSH 10
|
|
PUSH 20
|
|
POP
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 10 })
|
|
})
|
|
})
|
|
|
|
describe("DUP", () => {
|
|
test("duplicates top value", async () => {
|
|
const str = `
|
|
PUSH 5
|
|
DUP
|
|
ADD
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 10 })
|
|
})
|
|
})
|
|
|
|
describe("EQ", () => {
|
|
test("equality comparison", async () => {
|
|
const str = `
|
|
PUSH 5
|
|
PUSH 5
|
|
EQ
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'boolean', value: true })
|
|
|
|
const str2 = `
|
|
PUSH 5
|
|
PUSH 10
|
|
EQ
|
|
`
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'boolean', value: false })
|
|
})
|
|
|
|
test('equality with regexes', async () => {
|
|
const str = `
|
|
PUSH /cool/i
|
|
PUSH /cool/i
|
|
EQ
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'boolean', value: true })
|
|
|
|
const str2 = `
|
|
PUSH /cool/
|
|
PUSH /cool/i
|
|
EQ
|
|
`
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'boolean', value: false })
|
|
|
|
const str3 = `
|
|
PUSH /not-cool/
|
|
PUSH /cool/
|
|
EQ
|
|
`
|
|
expect(await run(toBytecode(str3))).toEqual({ type: 'boolean', value: false })
|
|
})
|
|
})
|
|
|
|
describe("NEQ", () => {
|
|
test("not equal comparison", async () => {
|
|
const str = `
|
|
PUSH 5
|
|
PUSH 10
|
|
NEQ
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'boolean', value: true })
|
|
})
|
|
})
|
|
|
|
describe("LT", () => {
|
|
test("less than", async () => {
|
|
const str = `
|
|
PUSH 5
|
|
PUSH 10
|
|
LT
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'boolean', value: true })
|
|
})
|
|
})
|
|
|
|
describe("GT", () => {
|
|
test("greater than", async () => {
|
|
const str = `
|
|
PUSH 10
|
|
PUSH 5
|
|
GT
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'boolean', value: true })
|
|
})
|
|
})
|
|
|
|
describe("LTE", () => {
|
|
test("less than or equal", async () => {
|
|
// equal case
|
|
const str = `
|
|
PUSH 5
|
|
PUSH 5
|
|
LTE
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'boolean', value: true })
|
|
|
|
// less than case
|
|
const str2 = `
|
|
PUSH 3
|
|
PUSH 5
|
|
LTE
|
|
`
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'boolean', value: true })
|
|
|
|
// greater than case (false)
|
|
const str3 = `
|
|
PUSH 10
|
|
PUSH 5
|
|
LTE
|
|
`
|
|
expect(await run(toBytecode(str3))).toEqual({ type: 'boolean', value: false })
|
|
})
|
|
})
|
|
|
|
describe("GTE", () => {
|
|
test("greater than or equal", async () => {
|
|
// equal case
|
|
const str = `
|
|
PUSH 5
|
|
PUSH 5
|
|
GTE
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'boolean', value: true })
|
|
|
|
// greater than case
|
|
const str2 = `
|
|
PUSH 10
|
|
PUSH 5
|
|
GTE
|
|
`
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'boolean', value: true })
|
|
|
|
// less than case (false)
|
|
const str3 = `
|
|
PUSH 3
|
|
PUSH 5
|
|
GTE
|
|
`
|
|
expect(await run(toBytecode(str3))).toEqual({ type: 'boolean', value: false })
|
|
})
|
|
})
|
|
|
|
describe("Logical patterns", () => {
|
|
test("AND pattern - short circuits when false", async () => {
|
|
// false && <anything> should short-circuit and return false
|
|
const str = `
|
|
PUSH 1
|
|
PUSH 0
|
|
EQ
|
|
DUP
|
|
JUMP_IF_FALSE .end
|
|
POP
|
|
PUSH 999
|
|
.end:
|
|
`
|
|
const result = await run(toBytecode(str))
|
|
expect(result.type).toBe('boolean')
|
|
if (result.type === 'boolean') {
|
|
expect(result.value).toBe(false)
|
|
}
|
|
})
|
|
|
|
test("AND pattern - evaluates both when true", async () => {
|
|
const str = `
|
|
PUSH 1
|
|
DUP
|
|
JUMP_IF_FALSE .end
|
|
POP
|
|
PUSH 2
|
|
.end:
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 2 })
|
|
})
|
|
|
|
test("OR pattern - short circuits when true", async () => {
|
|
const str = `
|
|
PUSH 1
|
|
DUP
|
|
JUMP_IF_TRUE .end
|
|
POP
|
|
PUSH 2
|
|
.end:
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 1 })
|
|
})
|
|
|
|
test("OR pattern - evaluates second when false", async () => {
|
|
const str = `
|
|
PUSH 1
|
|
PUSH 0
|
|
EQ
|
|
DUP
|
|
JUMP_IF_TRUE .end
|
|
POP
|
|
PUSH 2
|
|
.end:
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 2 })
|
|
})
|
|
})
|
|
|
|
describe("NOT", () => {
|
|
test("logical not", async () => {
|
|
// number is truthy, so NOT returns false
|
|
const str = `
|
|
PUSH 1
|
|
NOT
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'boolean', value: false })
|
|
|
|
// 0 is truthy in this language, so NOT returns false
|
|
const str2 = `
|
|
PUSH 0
|
|
NOT
|
|
`
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'boolean', value: false })
|
|
|
|
// boolean false is falsy, so NOT returns true
|
|
const str3 = `
|
|
PUSH 1
|
|
PUSH 0
|
|
EQ
|
|
NOT
|
|
`
|
|
expect(await run(toBytecode(str3))).toEqual({ type: 'boolean', value: true })
|
|
})
|
|
})
|
|
|
|
describe("Truthiness", () => {
|
|
test("only null and false are falsy", async () => {
|
|
// 0 is truthy (unlike JS)
|
|
const str1 = `
|
|
PUSH 0
|
|
JUMP_IF_FALSE .end
|
|
PUSH 1
|
|
.end:
|
|
`
|
|
expect(await run(toBytecode(str1))).toEqual({ type: 'number', value: 1 })
|
|
|
|
// empty string is truthy (unlike JS)
|
|
const str2 = `
|
|
PUSH ''
|
|
JUMP_IF_FALSE .end
|
|
PUSH 1
|
|
.end:
|
|
`
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'number', value: 1 })
|
|
|
|
// false is falsy
|
|
const str3 = `
|
|
PUSH 0
|
|
PUSH 0
|
|
EQ
|
|
JUMP_IF_FALSE .end
|
|
PUSH 999
|
|
.end:
|
|
`
|
|
expect(await run(toBytecode(str3))).toEqual({ type: 'number', value: 999 })
|
|
})
|
|
})
|
|
|
|
describe("HALT", () => {
|
|
test("stops execution", async () => {
|
|
const str = `
|
|
PUSH 42
|
|
HALT
|
|
PUSH 100
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 42 })
|
|
})
|
|
})
|
|
|
|
describe("LOAD / STORE", () => {
|
|
test("variables", async () => {
|
|
const str = `
|
|
PUSH 42
|
|
STORE x
|
|
PUSH 21
|
|
LOAD x
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 42 })
|
|
})
|
|
|
|
test("multiple variables", async () => {
|
|
const str = `
|
|
PUSH 10
|
|
STORE a
|
|
PUSH 20
|
|
STORE b
|
|
PUSH 44
|
|
LOAD a
|
|
LOAD b
|
|
ADD
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 30 })
|
|
})
|
|
})
|
|
|
|
describe("TRY_LOAD", () => {
|
|
test("variable found", async () => {
|
|
const str = `
|
|
PUSH 100
|
|
STORE count
|
|
TRY_LOAD count
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 100 })
|
|
|
|
const str2 = `
|
|
PUSH 'Bobby'
|
|
STORE name
|
|
TRY_LOAD name
|
|
`
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'string', value: 'Bobby' })
|
|
})
|
|
|
|
test("variable missing", async () => {
|
|
const str = `
|
|
PUSH 100
|
|
STORE count
|
|
TRY_LOAD count1
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: 'count1' })
|
|
|
|
const str2 = `
|
|
PUSH 'Bobby'
|
|
STORE name
|
|
TRY_LOAD full-name
|
|
`
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'string', value: 'full-name' })
|
|
})
|
|
|
|
test("with different value types", async () => {
|
|
// Array
|
|
const str1 = `
|
|
PUSH 1
|
|
PUSH 2
|
|
PUSH 3
|
|
MAKE_ARRAY #3
|
|
STORE arr
|
|
TRY_LOAD arr
|
|
`
|
|
const result1 = await run(toBytecode(str1))
|
|
expect(result1.type).toBe('array')
|
|
|
|
// Dict
|
|
const str2 = `
|
|
PUSH 'key'
|
|
PUSH 'value'
|
|
MAKE_DICT #1
|
|
STORE dict
|
|
TRY_LOAD dict
|
|
`
|
|
const result2 = await run(toBytecode(str2))
|
|
expect(result2.type).toBe('dict')
|
|
|
|
// Boolean
|
|
const str3 = `
|
|
PUSH true
|
|
STORE flag
|
|
TRY_LOAD flag
|
|
`
|
|
expect(await run(toBytecode(str3))).toEqual({ type: 'boolean', value: true })
|
|
|
|
// Null
|
|
const str4 = `
|
|
PUSH null
|
|
STORE empty
|
|
TRY_LOAD empty
|
|
`
|
|
expect(await run(toBytecode(str4))).toEqual({ type: 'null', value: null })
|
|
})
|
|
|
|
test("in nested scope", async () => {
|
|
// Function should be able to TRY_LOAD variable from parent scope
|
|
const str = `
|
|
PUSH 42
|
|
STORE outer
|
|
MAKE_FUNCTION () .fn
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
HALT
|
|
.fn:
|
|
TRY_LOAD outer
|
|
RETURN
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 42 })
|
|
})
|
|
|
|
test("missing variable in nested scope returns name", async () => {
|
|
// If variable doesn't exist in any scope, should return name as string
|
|
const str = `
|
|
PUSH 42
|
|
STORE outer
|
|
MAKE_FUNCTION () .fn
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
HALT
|
|
.fn:
|
|
TRY_LOAD inner
|
|
RETURN
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: 'inner' })
|
|
})
|
|
|
|
test("used for conditional variable existence check", async () => {
|
|
// Pattern: use TRY_LOAD to check if variable exists and get its value or name
|
|
const str = `
|
|
PUSH 100
|
|
STORE count
|
|
TRY_LOAD count
|
|
PUSH 'count'
|
|
EQ
|
|
`
|
|
// Variable exists, so TRY_LOAD returns 100, which != 'count'
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'boolean', value: false })
|
|
|
|
const str2 = `
|
|
PUSH 100
|
|
STORE count
|
|
TRY_LOAD missing
|
|
PUSH 'missing'
|
|
EQ
|
|
`
|
|
// Variable missing, so TRY_LOAD returns 'missing', which == 'missing'
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'boolean', value: true })
|
|
})
|
|
|
|
test("with function value", async () => {
|
|
const str = `
|
|
MAKE_FUNCTION () .fn
|
|
STORE myFunc
|
|
JUMP .skip
|
|
.fn:
|
|
PUSH 99
|
|
RETURN
|
|
.skip:
|
|
TRY_LOAD myFunc
|
|
`
|
|
const result = await run(toBytecode(str))
|
|
expect(result.type).toBe('function')
|
|
})
|
|
})
|
|
|
|
describe("JUMP", () => {
|
|
test("relative jump forward", async () => {
|
|
const str = `
|
|
PUSH 1
|
|
JUMP .skip
|
|
PUSH 100
|
|
.skip:
|
|
PUSH 2
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 2 })
|
|
})
|
|
|
|
test("forward jump skips instructions", async () => {
|
|
// Use forward jump to skip, demonstrating relative addressing
|
|
const str = `
|
|
PUSH 100
|
|
JUMP .end
|
|
PUSH 200
|
|
PUSH 300
|
|
.end:
|
|
PUSH 400
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 400 })
|
|
})
|
|
|
|
test("backward - simple loop", async () => {
|
|
// Very simple: counter starts at 0, loops 3 times incrementing
|
|
// On 3rd iteration (counter==3), exits and returns counter
|
|
const bytecode = toBytecode(`
|
|
PUSH 0
|
|
STORE counter
|
|
.loop:
|
|
LOAD counter
|
|
PUSH 3
|
|
EQ
|
|
JUMP_IF_FALSE .body
|
|
LOAD counter
|
|
HALT
|
|
.body:
|
|
LOAD counter
|
|
PUSH 1
|
|
ADD
|
|
STORE counter
|
|
JUMP .loop
|
|
`)
|
|
|
|
const result = await run(bytecode)
|
|
expect(result).toEqual({ type: 'number', value: 3 })
|
|
})
|
|
})
|
|
|
|
describe("JUMP_IF_FALSE", () => {
|
|
test("conditional jump when false", async () => {
|
|
const str = `
|
|
PUSH 1
|
|
PUSH 0
|
|
EQ
|
|
JUMP_IF_FALSE .skip
|
|
PUSH 100
|
|
.skip:
|
|
PUSH 42
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 42 })
|
|
})
|
|
|
|
test("no jump when true", async () => {
|
|
const str = `
|
|
PUSH 1
|
|
JUMP_IF_FALSE .skip
|
|
PUSH 100
|
|
.skip:
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 100 })
|
|
})
|
|
})
|
|
|
|
describe("JUMP_IF_TRUE", () => {
|
|
test("conditional jump when true", async () => {
|
|
const str = `
|
|
PUSH 1
|
|
JUMP_IF_TRUE .skip
|
|
PUSH 100
|
|
.skip:
|
|
PUSH 42
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 42 })
|
|
})
|
|
})
|
|
|
|
describe("MAKE_ARRAY", () => {
|
|
test("creates array", async () => {
|
|
const str = `
|
|
PUSH 10
|
|
PUSH 20
|
|
PUSH 30
|
|
MAKE_ARRAY #3
|
|
`
|
|
const result = await run(toBytecode(str))
|
|
expect(result.type).toBe('array')
|
|
if (result.type === 'array') {
|
|
expect(result.value).toHaveLength(3)
|
|
expect(result.value[0]).toEqual({ type: 'number', value: 10 })
|
|
expect(result.value[1]).toEqual({ type: 'number', value: 20 })
|
|
expect(result.value[2]).toEqual({ type: 'number', value: 30 })
|
|
}
|
|
})
|
|
})
|
|
|
|
describe("ARRAY_GET", () => {
|
|
test("gets element", async () => {
|
|
const str = `
|
|
PUSH 10
|
|
PUSH 20
|
|
PUSH 30
|
|
MAKE_ARRAY #3
|
|
PUSH 1
|
|
ARRAY_GET
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 20 })
|
|
})
|
|
})
|
|
|
|
describe("ARRAY_SET", () => {
|
|
test("sets element", async () => {
|
|
const str = `
|
|
PUSH 10
|
|
PUSH 20
|
|
PUSH 30
|
|
MAKE_ARRAY #3
|
|
DUP
|
|
PUSH 1
|
|
PUSH 99
|
|
ARRAY_SET
|
|
PUSH 1
|
|
ARRAY_GET
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 99 })
|
|
})
|
|
})
|
|
|
|
describe("ARRAY_PUSH", () => {
|
|
test("appends to array", async () => {
|
|
const str = `
|
|
PUSH 10
|
|
PUSH 20
|
|
MAKE_ARRAY #2
|
|
DUP
|
|
PUSH 30
|
|
ARRAY_PUSH
|
|
ARRAY_LEN
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 3 })
|
|
})
|
|
|
|
test("mutates original array", async () => {
|
|
const str = `
|
|
PUSH 10
|
|
PUSH 20
|
|
MAKE_ARRAY #2
|
|
DUP
|
|
PUSH 30
|
|
ARRAY_PUSH
|
|
PUSH 2
|
|
ARRAY_GET
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 30 })
|
|
})
|
|
})
|
|
|
|
describe("ARRAY_LEN", () => {
|
|
test("gets length", async () => {
|
|
const str = `
|
|
PUSH 10
|
|
PUSH 20
|
|
PUSH 30
|
|
MAKE_ARRAY #3
|
|
ARRAY_LEN
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'number', value: 3 })
|
|
})
|
|
})
|
|
|
|
describe("MAKE_DICT", () => {
|
|
test("creates dict", async () => {
|
|
const str = `
|
|
PUSH 'name'
|
|
PUSH 'Alice'
|
|
PUSH 'age'
|
|
PUSH 30
|
|
MAKE_DICT #2
|
|
`
|
|
const result = await run(toBytecode(str))
|
|
expect(result.type).toBe('dict')
|
|
if (result.type === 'dict') {
|
|
expect(result.value.size).toBe(2)
|
|
expect(result.value.get('name')).toEqual({ type: 'string', value: 'Alice' })
|
|
expect(result.value.get('age')).toEqual({ type: 'number', value: 30 })
|
|
}
|
|
})
|
|
})
|
|
|
|
describe("DICT_GET", () => {
|
|
test("gets value", async () => {
|
|
const str = `
|
|
PUSH 'name'
|
|
PUSH 'Bob'
|
|
MAKE_DICT #1
|
|
PUSH 'name'
|
|
DICT_GET
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: 'Bob' })
|
|
})
|
|
})
|
|
|
|
describe("DICT_SET", () => {
|
|
test("sets value", async () => {
|
|
const str = `
|
|
MAKE_DICT #0
|
|
DUP
|
|
PUSH 'key'
|
|
PUSH 'value'
|
|
DICT_SET
|
|
PUSH 'key'
|
|
DICT_GET
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: 'value' })
|
|
})
|
|
})
|
|
|
|
describe("DICT_HAS", () => {
|
|
test("checks key exists", async () => {
|
|
const str = `
|
|
PUSH 'key'
|
|
PUSH 'value'
|
|
MAKE_DICT #1
|
|
PUSH 'key'
|
|
DICT_HAS
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'boolean', value: true })
|
|
})
|
|
|
|
test("checks key missing", async () => {
|
|
const str = `
|
|
MAKE_DICT #0
|
|
PUSH 'missing'
|
|
DICT_HAS
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'boolean', value: false })
|
|
})
|
|
})
|
|
|
|
describe("STR_CONCAT", () => {
|
|
test("concats together strings", async () => {
|
|
const str = `
|
|
PUSH "Hi "
|
|
PUSH "friend"
|
|
PUSH "!"
|
|
STR_CONCAT #3
|
|
`
|
|
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: "Hi friend!" })
|
|
|
|
const str2 = `
|
|
PUSH "Holy smokes!"
|
|
PUSH "It's "
|
|
PUSH "alive!"
|
|
STR_CONCAT #2
|
|
`
|
|
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'string', value: "It's alive!" })
|
|
|
|
|
|
const str3 = `
|
|
PUSH 1
|
|
PUSH " + "
|
|
PUSH 1
|
|
PUSH " = "
|
|
PUSH 1
|
|
PUSH 1
|
|
ADD
|
|
STR_CONCAT #5
|
|
`
|
|
|
|
expect(await run(toBytecode(str3))).toEqual({ type: 'string', value: "1 + 1 = 2" })
|
|
})
|
|
|
|
test("empty concat (count=0)", async () => {
|
|
const str = `
|
|
PUSH "leftover"
|
|
STR_CONCAT #0
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: "" })
|
|
})
|
|
|
|
test("single string", async () => {
|
|
const str = `
|
|
PUSH "hello"
|
|
STR_CONCAT #1
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: "hello" })
|
|
})
|
|
|
|
test("converts numbers to strings", async () => {
|
|
const str = `
|
|
PUSH 42
|
|
PUSH 100
|
|
PUSH 7
|
|
STR_CONCAT #3
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: "421007" })
|
|
})
|
|
|
|
test("converts booleans to strings", async () => {
|
|
const str = `
|
|
PUSH "Result: "
|
|
PUSH true
|
|
STR_CONCAT #2
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: "Result: true" })
|
|
|
|
const str2 = `
|
|
PUSH false
|
|
PUSH " is false"
|
|
STR_CONCAT #2
|
|
`
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'string', value: "false is false" })
|
|
})
|
|
|
|
test("converts null to strings", async () => {
|
|
const str = `
|
|
PUSH "Value: "
|
|
PUSH null
|
|
STR_CONCAT #2
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: "Value: null" })
|
|
})
|
|
|
|
test("mixed types", async () => {
|
|
const str = `
|
|
PUSH "Count: "
|
|
PUSH 42
|
|
PUSH ", Active: "
|
|
PUSH true
|
|
PUSH ", Total: "
|
|
PUSH null
|
|
STR_CONCAT #6
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: "Count: 42, Active: true, Total: null" })
|
|
})
|
|
|
|
test("array format", async () => {
|
|
const bytecode = toBytecode([
|
|
["PUSH", "Hello"],
|
|
["PUSH", " "],
|
|
["PUSH", "World"],
|
|
["STR_CONCAT", 3],
|
|
["HALT"]
|
|
])
|
|
|
|
const result = await run(bytecode)
|
|
expect(result).toEqual({ type: 'string', value: "Hello World" })
|
|
})
|
|
|
|
test("with variables", async () => {
|
|
const str = `
|
|
PUSH "Alice"
|
|
STORE name
|
|
PUSH "Hello, "
|
|
LOAD name
|
|
PUSH "!"
|
|
STR_CONCAT #3
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: "Hello, Alice!" })
|
|
})
|
|
|
|
test("composable (multiple concatenations)", async () => {
|
|
const str = `
|
|
PUSH "Hello"
|
|
PUSH " "
|
|
PUSH "World"
|
|
STR_CONCAT #3
|
|
PUSH "!"
|
|
STR_CONCAT #2
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: "Hello World!" })
|
|
})
|
|
|
|
test("with emoji and unicode", async () => {
|
|
const str = `
|
|
PUSH "Hello "
|
|
PUSH "🌍"
|
|
PUSH "!"
|
|
STR_CONCAT #3
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: "Hello 🌍!" })
|
|
|
|
const str2 = `
|
|
PUSH "こんにちは"
|
|
PUSH "世界"
|
|
STR_CONCAT #2
|
|
`
|
|
expect(await run(toBytecode(str2))).toEqual({ type: 'string', value: "こんにちは世界" })
|
|
})
|
|
|
|
test("with expressions", async () => {
|
|
const str = `
|
|
PUSH "Result: "
|
|
PUSH 10
|
|
PUSH 5
|
|
ADD
|
|
STR_CONCAT #2
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: "Result: 15" })
|
|
})
|
|
|
|
test("large concat", async () => {
|
|
const str = `
|
|
PUSH "a"
|
|
PUSH "b"
|
|
PUSH "c"
|
|
PUSH "d"
|
|
PUSH "e"
|
|
PUSH "f"
|
|
PUSH "g"
|
|
PUSH "h"
|
|
PUSH "i"
|
|
PUSH "j"
|
|
STR_CONCAT #10
|
|
`
|
|
expect(await run(toBytecode(str))).toEqual({ type: 'string', value: "abcdefghij" })
|
|
})
|
|
})
|
|
|
|
describe("BREAK", () => {
|
|
test("throws error when no break target", async () => {
|
|
// BREAK requires a break target frame on the call stack
|
|
// A single function call has no previous frame to mark as break target
|
|
const bytecode = toBytecode(`
|
|
MAKE_FUNCTION () .fn
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
HALT
|
|
.fn:
|
|
BREAK
|
|
`)
|
|
|
|
try {
|
|
await run(bytecode)
|
|
expect(true).toBe(false) // Should not reach here
|
|
} catch (e: any) {
|
|
expect(e.message).toContain('no break target found')
|
|
}
|
|
})
|
|
|
|
test("exits from nested function call", async () => {
|
|
// BREAK unwinds to the break target (the outer function's frame)
|
|
// Main calls outer, outer calls inner, inner BREAKs back to outer's caller (main)
|
|
const bytecode = toBytecode(`
|
|
MAKE_FUNCTION () .outer
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
PUSH 42
|
|
HALT
|
|
.outer:
|
|
MAKE_FUNCTION () .inner
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
PUSH 99
|
|
RETURN
|
|
.inner:
|
|
BREAK
|
|
`)
|
|
|
|
const result = await run(bytecode)
|
|
expect(result).toEqual({ type: 'number', value: 42 })
|
|
})
|
|
})
|