charlang

package module
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 15, 2026 License: MIT Imports: 64 Imported by: 6

README

Coverage Go Reference Go Report Card

中文版 | English Version

The Char Language (Charlang)

Charlang is a fast, dynamic scripting language to embed in Go applications. Charlang is compiled and executed as bytecode on stack-based VM that's written in native Go. Charlang has a more-common runtime error handling(try-catch-finally) than Golang.

Charlang is inspired by and based on awesome script language uGo. Special thanks to uGo's creater(ozanh) and contributors.

1. Features

  • Written in native Go (no cgo).
  • if else statements.
  • for and for in statements.
  • try catch finally statements.
  • param, global, var and const declarations.
  • Rich builtins.
  • Module support.
  • Go like syntax with additions.

2. More Features

  • New types such as Byte, Image, Any...
  • New functions: NewCommonError, NewError and more...
  • New builtin functions: getRandomInt, writeResp, setRespHeader, writeRespHeader and much more...
  • New global variables and resources.
  • A new thread-model.
  • Runtime/dynamically script compiling and running capability.
  • Builtin Console and GUI Code Editor.
  • Server mode: quickly start a WEB and/or application server.
  • Run as system service.

Fibonacci Example

var fib

fib = func(x) {
    if x == 0 {
        return 0
    } else if x == 1 {
        return 1
    }
    return fib(x-1) + fib(x-2)
}

return fib(35)

Charlang Home

Go Reference

Builtin Functions

Performance Benchmark

Charlang demonstrates impressive performance as an interpreted scripting language. Here's a comparison with Go and Python:

Iterative Fibonacci Performance
n Charlang Go Python Best
fib(100000) 6 ms 0 ms 60 ms Go

Key Finding: Charlang iterative performance is close to Go, 10x faster than Python.

Recursive Fibonacci Performance
n Charlang Go Python Best
fib(35) 1299 ms 32 ms 802 ms Go
fib(40) 14420 ms 360 ms 8917 ms Go

Key Finding: Go recursive is ~40x faster than Charlang (interpreter overhead).

Summary
Scenario Charlang Performance
Iterative operations Close to Go, 10x faster than Python
String operations Similar to Go
Array/Map operations Efficient
Recursive operations Has interpreter overhead, prefer iterative

📖 Detailed Reports: docs/benchmark/

Additional Documentation (中英文双语)

4. Download

Or download the package from Charlang Official Site

5. Installation

Download the latest Charlang executable file or compressed package above or from the official website, and then put it in a directory, preferably within the system path(such as C:\Windows in Windows or /usr/bin). If you download a compressed package, decompress it first. Then it is ready to use, run it in any terminal or console application(Window CMD, PowerShell, Terminal or bash);

6. Quick Start

Install Charlang first according to the installation guide, or build from source code by:

go get -u github.com/topxeq/charlang

go get -u github.com/topxeq/charlang/cmd/char

Charlang has a REPL application to learn and test Charlang language, run Charlang's main executable file with no command-line arguments to start it.

char.exe or ./char

D:\tmpx>char
Charlang 1.9.6 by TopXeQ
> 1.8 * 3.79
6.822
> a := 12
> pln(a + 19) 
31
> for i in 3 {\
    pln(i, i+1)\
  }
0 1
1 2
2 3
> q

D:\tmpx>

Use command 'q' to exit the REPL.

Run Charlang with a file name to compile and run the script code.

D:\tmpx>char test.char
aaa[3]

D:\tmpx>

The following simple example shows the how to embed Charlang engine and run scripts in Golang.

package main

import (
    "fmt"

    "github.com/topxeq/charlang"
)

func main() {
    script := `
param ...args

mapEach := func(seq, fn) {

    if !isArray(seq) {
        return error("want array, got " + typeName(seq))
    }

    var out = []

    if sz := len(seq); sz > 0 {
        out = repeat([0], sz)
    } else {
        return out
    }

    try {
        for i, v in seq {
            out[i] = fn(v)
        }
    } catch err {
        println(err)
    } finally {
        return out, err
    }
}

global multiplier

v, err := mapEach(args, func(x) { return x*multiplier })
if err != undefined {
    return err
}
return v
`

    bytecode, err := charlang.Compile([]byte(script), charlang.DefaultCompilerOptions)
    if err != nil {
        panic(err)
    }
    globals := charlang.Map{"multiplier": charlang.Int(2)}
    ret, err := charlang.NewVM(bytecode).Run(
        globals,
        charlang.Int(1), charlang.Int(2), charlang.Int(3), charlang.Int(4),
    )
    if err != nil {
        panic(err)
    }
    fmt.Println(ret) // [2, 4, 6, 8]
}

Refer to the documentation below to find more examples to run Charlang code.

7. Documentation

7.1 Get the Binary

Download the binary release files according to your OS from the website: Charlang Homepage.

7.2 Compile from Source Code

If you want to modify the code, or build Charlang for specific platforms,

go get -u github.com/topxeq/charlang

or

cd $GOPATH/src/github.com/topxeq

git clone https://github.com/topxeq/tkc

git clone https://github.com/topxeq/charlang

cd $GOPATH/src/github.com/topxeq/charlang/cmd

go install
7.3 Start Running the Shell or Scripts

After download, extract the executable from the zip file, put it into a directory, better in the system path.

Then type 'char' in the terminal/console to start the interactive command-line shell interface. Also you can run some scripts using command like 'char test.char', or 'char -example basic.char'. Here 'test.char' is the source code file(in UTF-8 encoding, plain text format).

Using command-line switch '-view' will show the source code of the script instead of run it.

7.4 Various Ways to Run Charlang Scripts

Examples:

  • Run from a source file: char d:\scripts\test.char
  • Run the text in clipboard as script source: char -clip
  • Run from the remote server: char -remote http://replacewithyourdomain.com/script/abc.char
  • Run the example code: char -example basic.char
  • Run from Golang source directory: char -gopath basic.char
  • Run from local scripts directory: place a config file local.cfg in the subdirectory 'char' under the user's home directory, with text content such as c:\scripts, then char -local basic.char will run 'c:\script\basic.char'
  • Run from cloud/network: place a config file cloud.cfg in the subdirectory 'char' under the user's home directory, with text content such as http://script.my.com/, then char -cloud basic.char will be the same as char -remote http://script.my.com/basic.char
  • Select the script(or input the script file path in console mode) to run: char -selectScript
  • Load the script in the builtin console(multi-line) editor: char -cedit d:\scripts\test.char, then press Ctrl-Q to run, Ctrl-X to exit
  • Load the script in the builtin GUI editor: char -edit d:\scripts\test.char, then modify or run it in the editor(click the 'Quick Run' button) on Windows(WebView2)
  • Run it in the CharEd IDE(Lazarus), which can be downloaded from the official website, in the Windows package
  • Use it as an embeded script language engine, in any Golang compatible languages
  • Run it through other languages, with the compiled DLL of Charlang
7.5 Get the Examples

All the source code examples marked by file names in the document can be retrieved or run by the command line like:

C:\Users\Administrator>char -example -view basic.char
// do simple add operation
x := 1.2
y := x + 1

println(x + y)

pass()

C:\Users\Administrator>char -example basic.char
3.4000000000000004

C:\Users\Administrator>

You can browse to https://topget.org/dc/c/charlang/example/basic.char to view the source code in an online text editor.

Using command-line switch '-viewPage' with '-example' will show the online code page in system-default browser as well.

7.6 Quick Tour
Hello World!

file: example001.char

// function 'pln' is the same as 'println' in other languages
pln("Hello world!")

The function 'pln' is the same as 'println' in other languages. pln formats using the default formats for its arguments and writes to standard output.

And in Charlang, comments are supported. You can use // or /* ... */ to guide the comments.

The resulting output of the script:

C:\Users\Administrator>char -example example001.char
Hello world!

C:\Users\Administrator>
Comments

file: example002.char

As mentioned above, like Golang, Charlang supports line comments (//...) and block comments (/* ... */). Comments in the code will be ignored by the compiler and virtual machine. You can use Ctrl+/key combination in many text or source code editors to switch whether the line is commented or not.

/*
  multi-line block comments - 1
  multi-line block comments - 2
  multi-line block comments - 3
*/

a := 8    // line comments

// line comments at the start of a new line
pln("a:", a)

The output:

C:\Users\Administrator>char -example example002.char
a: 8
Define Variables

file: example003.char

// define a variable before using it
var a

a = 1

pln(a)

// assign a value of another type to a
a = "abc"

pln(a)

// define and assign in one step
b := true

pln(b)

// can not use := again for the same variable
// the next line will cause error
// b := 1.1

The result:

C:\Users\Administrator>char -example example003.char
1
abc
true

Note that unlike Golang, a variable can be assigned a value of different types.

Declare more than 1 variable in one line within a pair of parentheses.

var (a, b, c)

...
Data Type Name

file: example004.char


a := 3 // assign an integer(int) value to variable 'a'

// function 'pl' is equivalent to the printf function in other languages, 
// followed by an additional newline character "\n"
// and the conversion characters are the same as Golang, 
// '%T' is used to output the value's type, '%v' is the general output format for any value
pl("[%T] %v", a, a)

// Instead of using '%T', which will output the native type in Golang(in which Charlang is written)
// function 'typeOf' is often used to get the type name of a variable in Charlang
pl("[%v] %v", typeOf(a), a)

The output:

C:\Users\Administrator>char -example example004.char
[charlang.Int] 3
[int] 3
Boolean Data Type

file: example005.char


// Boolean values

b := true

// function 'prf' is the same as 'printf' in C/C++/Golang
prf("[%v] %v\n", typeOf(b), b)

c := false

prf("[%T] %v\n", c, c)

prf("!b = %v\n", !b) // the operators are the same as Golang and many other languages

prf("b == c: %v\n", b == c)

prf("1 > 14: %v\n", 1 > 14)

prf("b == true: %v\n", b == true)

prf("b && c: %v\n", b && c)

prf("b || c: %v\n", b || c)

The output:

C:\Users\Administrator>char -example example005.char
[bool] true
[charlang.Bool] false
!b = false
b == c: false
1 > 14: false
b == true: true
b && c: false
b || c: true
Integer Data Type

file: example006.char


// Integer

c1 := 19

c2 := 18

pln(c1 + c2/3)

pl("%v, %v", typeOf(c1), c1)

pl("%T, %v", c1+c2, c1+c2)
pl("%v, %v", typeOf(c2/3), c2/3)
pl("%v, %v", typeOf(c1+c2/3), c1+c2/3)
pl("%T, %v", (c1+c2/3)*6, (c1+c2/3)*6)

The output:

C:\Users\Administrator>char -example example006.char
25
int, 19
charlang.Int, 37
int, 6
int, 25
charlang.Int, 150
Float Data Type

file: example007.char


// Float

f1 := 1.32

pl("%v, %v", typeOf(f1), f1)

previus_f1 := f1

f1 = f1 * 0.8

// function 'pr' is the same as 'print' in other languages
pr(previus_f1, "*", 0.8, "=", f1)

pln()

f2 := 0.93
f2 /= 0.3

pr(0.93, "/", 0.3, "=", f2, "\n")

The output:

C:\Users\Administrator>char -example example007.char
float, 1.32
1.32*0.8=1.056
0.93/0.3=3.1
String/Bytes/Chars Data Type

file: example008.char


// String, Bytes and Chars

s1 := "abc"

// concatenate strings
s2 := s1 + "3"

// function 'plt' will output the value with its Charlang type
plt(s2)

pln(s1, "+", "3", "=", s2)

s5 := "上善若水"

// function 'plt' will output the value with its internal(Golang) type
plo(s5)

s6 := bytes(s5)

// s6 will be a bytes array
pln("s6:", s6)

// t will be a utf-8 character(rune in Golang)
t := char(5)

plo(t)

// s7 will be array of chars
// in this example, will be 4 unicode characters, each has 3 bytes
s7 := chars(s5)

plt(s7)

// slice of s5(string) will be a string with only one ASCII(0-255) character
pl("s5[1:2] = %v(%#v)", s5[1:2], s5[1:2])

// slice of s6(bytes, i.e. array of byte) will be a byte array contains only one item
pl("s6[1:2] = %v(%#v)", s6[1:2], s6[1:2])

// slice of s7(chars, i.e. array of char) will be a char array contains only one item
pl("s7[1:2] = %v(%#v)", s7[1:2], s7[1:2])

// covert utf-8 chars to string
pl("string(s7[1:3]) = %v(%#v)", string(s7[1:3]), string(s7[1:3]))

// covert utf-8 chars to bytes, then to string, has the same effect as above
pl("string(bytes(string(s7[1:3]))) = %v(%#v)", string(bytes(string(s7[1:3]))), string(bytes(string(s7[1:3]))))

// output the first item of string, bytes and chars, as a single character
pl("%c", s5[1])
pl("%c", s6[1])
pl("%c", s7[1])

// output the first item of string, bytes and chars, with its value and type
pl("%T, %#v", s5[1], s5[1])
pl("%v, %#v", typeOf(s6[1]), s6[1])
pl("%T, %#v", s7[1], s7[1])

// iterate the string using 'for' loop
for i := 0; i < len(s5); i++ {
	pl("%v: %v, %v", i, typeOf(s5[i]), s5[i])
}

// iterate the string using 'for-in' loop
for i, v in s5 {
	pl("%v: %v, %v", i, typeOf(v), v)
}

// iterate the chars
for i, v in s7 {
	// function 'typeName' is equivalent to 'typeOf'
	pl("%v: %v, %v", i, typeName(v), v)
}

The output:

C:\Users\Administrator>char -example example008.char
(string)abc3
abc + 3 = abc3
(charlang.String)"上善若水"
s6: [228 184 138 229 150 132 232 139 165 230 176 180]
(charlang.Char)5
(chars)[19978 21892 33509 27700]
s5[1:2] = �("\xb8")
s6[1:2] = [184]([]byte{0xb8})
s7[1:2] = [21892]([]int32{21892})
string(s7[1:3]) = 善若("善若")
string(bytes(string(s7[1:3]))) = 善若("善若")
¸
¸
善
charlang.Int, 184
int, 184
charlang.Char, 21892
0: int, 228
1: int, 184
2: int, 138
3: int, 229
4: int, 150
5: int, 132
6: int, 232
7: int, 139
8: int, 165
9: int, 230
10: int, 176
11: int, 180
0: byte, 228
1: byte, 184
2: byte, 138
3: byte, 229
4: byte, 150
5: byte, 132
6: byte, 232
7: byte, 139
8: byte, 165
9: byte, 230
10: byte, 176
11: byte, 180
0: char, 19978
1: char, 21892
2: char, 33509
3: char, 27700
Array
// declare an array
a := [1, 2, 3, "abc", 12.3]

println("a:", a)

println("a[2]:", a[2])

println("length of a:", len(a))

// reassign the array variable
a = [1, 2]

// append values
a = append(a, "abc")

// array item can be any type, even another array
b := ["xyz", 16, a]

pln("b:", b)

output:

a: [1, 2, 3, "abc", 12.3]
a[2]: 3
length of a: 5
b: ["xyz", 16, [1, 2, "abc"]]

Refer to the array example in More Examples section for more information about array type.

Map

In Charlang, map is a set of key-value pairs where key is string and the value is of any value types. Value of a map can be accessed using indexer [] or selector '.' operators.

// declare an empty map
a := {}

// all keys will be converted to string type, values keep their original types
a["Num"] = 3
a[5] = "abc"
a[-1] = true
a["ary"] = [1, "xyz", false]
a[false] = "not true"
a.Item1 = "item 1"

pln(a)

// length is the number of key-value pairs in the map
pl("length of a: %v", len(a))

// index by dot
pl("a.Num: %v", a.Num)

// index by square brackets
a["Num"]++
pln(a["Num"])

// slice
pln(a[5][2:3])

a[5] = a[5] + a[5]

// slice to end
a[5] = a[5][1:]
pl("a[5]: %v", a[5])

// slice from begining
pln(a[5][:2])

// iterate
for k, v in a {
	println("[", k, "]:", v)
}
  
pln("---")

// declare map with initial values
b := {"intItem": 12, "floatItem": 5.6, "boolItem": true, "stringItem": "str1", "arrayItem": ["array", "in", "map"], "mapItem": {"map": 1, "in": "map"}}

plt(b)

pln("---")

c := {}

// all keys will be converted to string type
c[3] = "3"
c[18] = "abc"
c[-198] = "true"

pl("c: %v", c)

v1 := c[18]

if v1 == undefined {
	println("v1:", v1)
}

// index with non-existent key
v2 := c[19]

if v2 == undefined {
	println("v2:", v2)
}

// remove key-value pair
delete(c, 18)

println("c:", c)

output:

{"Num": 3, "5": "abc", "-1": true, "ary": [1, "xyz", false], "false": "not true", "Item1": "item 1"}
length of a: 6
a.Num: 3
4
c
a[5]: bcabc
bc
[ Num ]: 4
[ 5 ]: bcabc
[ -1 ]: true
[ ary ]: [1, "xyz", false]
[ false ]: not true
[ Item1 ]: item 1
---
(map){"intItem": 12, "floatItem": 5.6, "boolItem": true, "stringItem": "str1", "arrayItem": ["array", "in", "map"], "mapItem": {"map": 1, "in": "map"}}
---
c: {"3": "3", "18": "abc", "-198": "true"}
v2: undefined
c: {"3": "3", "-198": "true"}

Refer to the map example in More Examples section for more information about map type.

Function Type(Declare Function)

Function is a data type in Charlang.

// declare a function with arguments
f1 := func(a, b, c, d) {
	return a*b + c/d
}

result1 := f1(3, 6, 8, 9)

pln("result1=", result1)

// variadic function(function accepts a variable number of arguments)
f2 := func(v0, v1, ...args) {
	sum := v0 + v1

	argsLen := len(args)

	for i := 0; i < argsLen; i++ {
		sum += args[i]
	}

	return sum
}

result2 := f2(3, 6, 8, 9, 7)

pln("result2=", result2)
For Loop
c1 := 0

// classic for loop
for i := 0; i < 5; i++ {
	c1 += i
}

pln(c1 * 3)

// for loop with condition only
i := 0

for i < 5 {
	pl("i: %v", i)

	i = i + 1
}

// infinite loop(if no break)

c := 5
for {
	c = c + 5

	if c < 10 {
		continue
	}

	if c > 30 {
		break
	}
}

pln("c:", c)

Output:

30
i: 0
i: 1
i: 2
i: 3
i: 4
c: 35
If Statement
var a

if !a {
	pln("!a")
}

pln("!a", !a)

if a {
	pln("a =", a)
} else {
	pln("a is not initialized")
}

b := 1

if b {
	pln("b =", b)
} else {
	pln("b is not initialized")
}

pln("!b", !b)

var c = "abc"

pln("!c", !c)

Output:

!a
!a true
a is not initialized
b = 1
!b false
!c false
Predefined Global Variables

There are some prefined global variables in Charlang, which can be refered by 'global' keyword. The following code will show the command-line arguments in order,

global argsG

for i, v in argsG {
    pl("[%v] %v", i, v)
}

The global predefined variable 'argsG' holds the command-line parameters while running the Charlang's main program. The data type of argsG is array, so we could use it instantly without other declaration.

If using Charlang as a library in Golang, we can pass other global variables other than the predefined ones.

The common global predefined variables include:

  • versionG: the current version of Charlang;
  • basePathG: the base path of Charlang, will be the current user's home directory such as c:\Users\Administrator or the service root directory(c:\char in Windows and /char in Linux);
  • argsG: the array typed variable holds the command-line parameters;
  • scriptPathG: the path of the script file running currently;
  • runModeG: running mode of Charlang(script, repl, service, charms, chp, chardc, ...)

And while runnin as a WEB/Application/Micro-service server, there are additional predefined global variables:

  • requestG: the HTTP request object, holds the request information;
  • responseG: the HTTP respone object that could write response to, or set response settings;
  • reqUriG: the route of the request, such as 'static/images/img001.png'
  • paraMapG: holds the GET/POST form values, in a map object, such as {"auth": "xxxxx", "input1": "value1"}

In Windows platform, there are some additional predefined global variables:

  • guiG: holds the object to interact with WebView2 component which could used to establish GUI applications.
Error handling: Try-Catch-Finally
a := 0

var r

try {
	r = 3 / a

} catch e {
	pln("exception:", e)

} finally {
	
	pln("r:", r)
}

pln("done")

Output:

D:\tmp>char -example tryCatch.char
exception: ZeroDivisionError: 
r: undefined
done
Run Charlang Script/Code
  • Run a piece of Charlang code(in format as string),
sourceT := `
param (v1, v2)

return v1 + v2
`

codeT := charCode(sourceT)

codeT.compile()

resultT := codeT.run(12, 8.5)

pl("result: %v", resultT)

charCode is the object type to hold Charlang code to run, compile the source code before run it. Various parameters could be passed to the code object.

The output:

D:\tmp>char -exam runCode.char
result: 20.5
  • Passing various length paramters,
sourceT := `
param ...vargs

pln(toJson(vargs, "-sort"))

return vargs[2]

`

codeT := charCode(sourceT)

codeT.compile()

rs := codeT.run("abc", 123.5, true, {"name": "Tom", "age": 16})

pl("rs: %v", rs)
  • Run code like a function call, and the fix part of parameters with various length paramters,
sourceT := `
param (v1, v2, ...vargs)

pln("input:", v1, v2, ...vargs)

sum := v1 + v2

for i, v in vargs {
	sum += v
}

return sum
`

addAll := charCode(sourceT).compile()

resultT := addAll(12, 8.5, 2, 3, 16)

pl("result: %v", resultT)
Multi-Threading
  • First way:
func1 := func(v0) {
	for i := 0; i < 5; i++ {
		v0++

		pl("(thread) v0=%v", v0)

		sleep(1.0)
	}
}

a := 5

func1.threadRun(a)

sleep(0.15)

for i := 0; i < 5; i++ {
	a += 10

	pl("(main) a=%v", a)

	sleep(1.3)
}
  • Second way, import the 'ex' module and use the ex.threadRunFunc function:

Note: here also demonstrate the usage of mutex and pass/set value by reference.

ex := import("ex")

roundsT := 1000

mutex1 := mutex()

func1 := func(v0) {

	for i := 0; i < roundsT; i++ {
		lock(mutex1)

		setValueByRef(v0, unref(v0)+1)

		unlock(mutex1)

		pl("(thread) *v0=%v", unref(v0))

		sleep(0.05)
	}
}

a := new("int", 5)

ex.threadRunFunc(func1, a)

sleep(0.15)

for i := 0; i < roundsT; i++ {
	lock(mutex1)

	setValueByRef(a, unref(a)+10)

	unlock(mutex1)

	pl("(main) *a=%v", unref(a))

	sleep(0.065)
}
  • The third way, run in another VM:

Note: this example also demonstrate how to pass parameters to the thread runs in another VM.

// using Array or Map to pass parameters which may change in the thread

sourceT := `
param (v0)

for i := 0; i < 5; i++ {
	v0[0] ++

	pl("(thread) v0=%v", v0[0])

	sleep(1.0)
}

return

`

c1 := charCode(sourceT).compile()

if isErr(c1) {
	fatalf("failed to compile code: %v", c1)
}

a := [5]

c1.threadRun(a)

sleep(0.15)

for i := 0; i < 5; i++ {
	a[0] += 10

	pl("(main) a=%v", a[0])

	sleep(1.3)
}
Gel

Gel in Charlang is an object to encapsulate values or functions.

sourceT := `
param (v0, ...vargs)

pln(v0, vargs)

add := func(a1, a2) {
	return a1 + a2
}

mul := func(a1, a2) {
	return a1 * a2
}

if v0 == "add" {
	return add
} else if v0 == "mul" {
	return mul
} else if v0 == "Pi" {
	return 3.1415926
}

return errStrf("member/method not found: %v", v0)
`

c1 := charCode(sourceT)

if isErr(c1.compile()) {
	pl("failed to compile: %v", c1.lastError)
	exit()
}

g1 := gel(c1)

rs := g1.add(1, 2)

plo(rs)

pl("g1.Pi: %v", g1.Pi)

pl("unknown member: %v", g1.var1)

pln(isErr(g1.var1))

pln(getErrStr(g1.var1))

try {
	pl("unknown func: %v", g1.func1())
} catch e {
	pl("unknown func(%v): %v", g1.func1, e)
}

rs2 := g1.mul(3.6, 8)

plo(rs2)

The output:

D:\tmp>char -example gel1.char
add []
(charlang.Int)3
Pi []
g1.Pi: 3.1415926
var1 []
unknown member: TXERROR:member/method not found: var1
true
member/method not found: var1
func1 []
unknown func(TXERROR:member/method not found: func1): NotCallableError: string
mul []
(charlang.Float)28.8

We can use 'ex' module to load gels as well, loaded gels are compiled already.

ex := import("ex")

sourceT := `
param (v0, ...vargs)

pln(v0, vargs)

add := func(a1, a2) {
	return a1 + a2
}

mul := func(a1, a2) {
	return a1 * a2
}

if v0 == "add" {
	return add
} else if v0 == "mul" {
	return mul
} else if v0 == "Pi" {
	return 3.1415926
}

return errStrf("member/method not found: %v", v0)
`

g1 := ex.loadGel(sourceT)

rs := g1.add(1, 2)

plo(rs)

pl("g1.Pi: %v", g1.Pi)

pl("unknown member: %v", g1.var1)

pln(isErrX(g1.var1))

pln(getErrStrX(g1.var1))

try {
	pl("unknown func: %v", g1.func1())
} catch e {
	pl("unknown func(%v): %v", g1.func1, e)
}

rs2 := g1.mul(3.6, 8)

plo(rs2)
Eval Machine(Virtual Machine to Run More Than One Piece of Script)

Demonstrate how to create a new virtual machine to run scripts and/or eval the result value.

ev1 := evalMachine("value1", "value2", 2, true)

// parameters could be passed in global variable inputG
// and argsG which all values will be converted to string
rs1 := ev1.eval(`
global inputG
global argsG

pln(inputG)
pln(argsG)

`)

plt(rs1)

rs := ev1.eval("3.6 * 12.5")

plt(rs)

rs = ev1.eval("a := 4")

plt(rs)

rs = ev1.eval("mathSqrt(16 * a)")

plt(rs)

// modify one of the paramter
ev1.eval("inputG[2] = 3.1415926")

rs = ev1.eval(`
return inputG
`)

plt(rs)

Running result:

D:\tmpx>char -exam eval1.char
["value1", "value2", 2, true]
["value1", "value2", "2", "true"]
(undefined)undefined
(float)45
(undefined)undefined
(float)8
(array)["value1", "value2", 3.1415926, true]
  • to modify and/or add value to parameters
// pass parameters through evaluations of an evalMachine
aryT := [[1, 2, 3]]

ev1 := evalMachine(1, 2, aryT)

rs1 := ev1.eval(`
global inputG

ary1 := inputG[2][0]

ary1[0] + ary1[1] + ary1[2]

`)

plt(rs1)

// change the value
aryT[0][2] = 5

rs := ev1.eval("return ary1[0] + ary1[1] + ary1[2]")

plt(rs)

// append a value
aryT[0] = append(aryT[0], 18)

rs = ev1.eval(`

ary1 = inputG[2][0]

plt(ary1)

return ary1[0] + ary1[1] + ary1[2] + ary1[3]
`)

plt(rs)

Output:

(int)6
(int)8
(array)[1, 2, 5, 18]
(int)26
Run JavaScript Code

Demonstrate how to create a JavaScript virtual machine to run JavaScript code and/or eval the result value.

// initialize a JavaScript Virtual Machine
vmT := jsVm()

// run a piece of JavaScript code, and return the last evaluation
rs := vmT.run(`
let a = 1.2

var b = a * 2.7

b
`)

// get and output the return result
pl("result: %v", rs)

// set a global value
vmT.set("c", "abc")

// eval is equivalent to run
rs2 := vmT.eval(`let d = "" + b + c; d`)

pl("result2: %v", rs2)

// get a global variable value from the VM
value_a := vmT.get("a")

pl("value a: %v(%v)", value_a, typeOf(value_a))

// set a function/delegate/callback with parameters, then call it
sourceT := `
param ...vargs

global inputG

pln(inputG, vargs)

return vargs[0] + vargs[1] + inputG[0]
`

d1 := delegate(sourceT)

d1c := d1.compile(vmT.get("b")) // pass another parameter(via global variable inputG which will be an array)

vmT.set("f1", d1c)

rs3 := vmT.run(`let d3 = f1(3, 5); d3`)

pl("result3: %v", rs3)

Running result:

D:\tmpx>char -exam runJavaScript.char
result: 3.24
result2: 3.24abc
value a: 1.2(float)
[3.24] [3, 5]
result3: 11.24
Implement a Common Web Server

Demonstrate how to implement a more flexible Web server, with support of static files, dynamic pages(as PHP, JSP, ASPX...) and micro-services.

Start a Simple Web Server(with SSL Support) to Serve Static Files
// quickly start a static web server to serve files under certain directory
// port and certificate directory could be set
handlerT := httpHandler("static", joinPath(getHomeDir(), "pages"))

if isErr(handlerT) {
	fatalf("failed to create httpHandler: %v", getErrStr(handlerT))
}

muxT := mux()

muxT.setHandler("/", handlerT)

pln("starting http server on port 80(default)...")
checkErr(muxT.threadStartHttpServer())

// the certificate files should be server.crt and server.key
pln("starting https(SSL) server on port 443...")
plErr(muxT.threadStartHttpsServer("-port=443", "-certDir=."))

for {
	pln(time().format("2006-01-02 15:04:05"), "heartbeat")
	sleep(5.0)
}
Start a Common Web Server
// a very simple web server
// to test the server, open your browser, and browse to the URL address: http://127.0.0.1

muxT := mux()

handlerT := func(requestA, responseA) {
	// pl("req: %#v, res: %#v", requestA, responseA)

	writeResp(responseA, "This is a test!")

	return "TX_END_RESPONSE_XT"
}

muxT.setHandler("/", handlerT)

rs := muxT.startHttpServer()

pl("result: %v", rs)

Modify the code part in handlerT to fulfill customized requirement of the Web server. You can mix a static files handler with the same Mux object in different route, such as:

muxT.setHandler("/", staticFileHandlerT)
muxT.setHandler("/common", commonHandlerT)
Web Server with Multi-thread

One more example to Demonstrate the usage of mutex to avoid conflicts for multi http requests:

n1 := new("int", 0)

mutex1 := mutex()

muxT := mux()

handlerT := func(requestA, responseA) {
	pl("req: %#v, res: %#v", requestA, responseA)

	params1 := parseReqFormEx(requestA)

	plo(params1)

	setRespHeader(responseA, "Access-Control-Allow-Origin", "*")
	setRespHeader(responseA, "Access-Control-Allow-Headers", "*")
	setRespHeader(responseA, "Content-Type", "application/json;charset=utf-8")

	authT := trim(params1["auth"])

	if authT != "abc123" {
		writeResp(responseA, genJsonResp(requestA, "fail", "auth failed"))
		return "TX_END_RESPONSE_XT"
	}

	inputT := params1["input"]

	if inputT == undefined {
		writeResp(responseA, genJsonResp(requestA, "fail", "input could not be empty"))
		return "TX_END_RESPONSE_XT"
	}

	c1 := int(inputT)

	mutex1.lock()
	setValueByRef(n1, unref(n1)+c1)
	mutex1.unlock()

	writeResp(responseA, genJsonResp(requestA, "success", toStr(unref(n1))))

	return "TX_END_RESPONSE_XT"
}

muxT.setHandler("/test", handlerT)

rs := muxT.startHttpServer()

pl("result: %v", rs)
Request Handler Running in a New Virtual Machine

Another example to Demonstrate how to set handler runnin in a new VM, and the way to pass parameters to it:

// handler runs in a seperate VM, more safe but with a little more system resource(and time) cost/overhead
n1 := new("int", 0)

mutex1 := mutex()

muxT := mux()

handlerT := httpHandler().set("code", `
param(n1, mutex1)

global requestG
global responseG

pl("req: %#v, res: %#v", requestG, responseG)

pl("n1: %#v, mutex1: %#v", n1, mutex1)

params1 := parseReqForm(requestG)

plo(params1)

setRespHeader(responseG, "Access-Control-Allow-Origin", "*")
setRespHeader(responseG, "Access-Control-Allow-Headers", "*")
setRespHeader(responseG, "Content-Type", "application/json;charset=utf-8")

authT := trim(params1["auth"])

if authT != "abc123" {
	writeResp(responseG, genJsonResp(requestG, "fail", "auth failed"))
	return "TX_END_RESPONSE_XT"
}

inputT := params1["input"]

if inputT == undefined {
	writeResp(responseG, genJsonResp(requestG, "fail", "input could not be empty"))
	return "TX_END_RESPONSE_XT"
}

c1 := int(inputT)

pln("c1:", c1)

mutex1.lock()

setValueByRef(n1, unref(n1)+c1)
mutex1.unlock()

writeResp(responseG, genJsonResp(requestG, "success", toStr(unref(n1))))

return "TX_END_RESPONSE_XT"

`, n1, mutex1)

if isErr(handlerT) {
	fatalf("failed to create http handler: %v", getErrStr(handlerT))
}

muxT.setHandler("/test", handlerT)

pln("starting web server on port 8080...")
rs := muxT.startHttpServer("-port=8080")

pl("result: %v", rs)
Serve Static and Dynamic HTML Pages at the Same Time

Read HTML template from the file according to the route(in the URL parameter).

// demonstrate how to serve static and dynamic HTML pages, not this is not the only way

staticHandlerT := httpHandler("static", joinPath(getHomeDir(), "pages"))

if isErr(staticHandlerT) {
	fatalf("failed to create static handler: %v", getErrStr(staticHandlerT))
}

dynamicHandlerT := func(requestA, responseA) {
	// set the proper response header
	setRespHeader(responseA, "Access-Control-Allow-Origin", "*")
	setRespHeader(responseA, "Access-Control-Allow-Headers", "*")
	setRespHeader(responseA, "Content-Type", "text/html;charset=utf-8")

	// get the parameters from the HTTP request
	paramsT := parseReqForm(requestG)

	// get the 'req' parameter from query string or post form values
	// it will be used as route
	reqT := trim(params1["req"])

	// get HTML template from specified folder
	templateDirT := `c:\test\tmpl`

	templateFileT := joinPath(templateDirT, reqT+".html")

	templateHtmlT := loadText(templateFileT)

	// do some modifications on the template
	strReplace(templateHtmlT, "{{field1}}", getNowStr())

	// write the processed text to HTTP response
	writeResp(responseA, templateHtmlT)

	// write "TX_END_RESPONSE_XT" to end the response stream/output
	return "TX_END_RESPONSE_XT"
}

// serve dynamic pages
muxT.setHandler("/pages", dynamicHandlerT)

// serve other route as static pages
muxT.setHandler("/", staticHandlerT)

rs := muxT.startHttpServer()

pl("result: %v", rs)
Charlang's Embedded Fully Functional Web/Microservices/Application Server

 

Charlang's main program comes with a server mode that supports a lightweight WEB/Application/API all-in-one server. You can start it using the following command line:

D:\tmp>char -server -dir=scripts
[2024/08/23 08:08:22] Charlang Server V1.3.3 -port=:80 -sslPort=:443 -dir=scripts -webDir=scripts -certDir=scripts
[2024/08/23 08:08:22] try starting ssl server on :443...
[2024/08/23 08:08:22] try starting server on :80 ...
[2024/08/23 08:08:22] failed to start https: open scripts\server.crt: The system cannot find the file specified.

As can be seen, the server mode of Charlang can be started with the '-server' parameter, and the '-port' parameter can be used to specify the HTTP service port (please add a colon), '-sslPort' can be used to specify the SSL port, '-certDir' can be used to specify the certificate file directory of the SSL service (which should be two files: server.crt and server.key), '-dir' can be used to specify the root directory of the service, and '-webDir' can be used to specify the web service for static pages and resources. These parameters have default values and can be seen without entering any parameters.

The error in the output information is because the SSL certificate was not provided, and the SSL service will not be able to start. Adding the certificate files will suffice.

Then open a browser to access the address http://127.0.0.1:80 to access the all-in-one web service written in Charlang.

Assuming that the specified directory contains three files: charmsIndex.char, charmsTmpl.html, and charmsApi.char, various modes supported by the application server established by Charlang can be displayed.

First, access it with a browser http://127.0.0.1/charmsTmpl.html This will be accessing general web services, as the web directory defaults to the same as the server root directory. Therefore, the static file charmsTmpl.html under the root directory will be displayed, which is an example web page.

Screenshot

You can see that the "{{text1}}" tag after the text 'Please click the button ' in the webpage. This is the tag that we need to replace when displaying the dynamic webpage later. The content of the charmsTmpl.html file is as follows:

<html>
<body>
    <script>
        function test() {
            let xhr = new XMLHttpRequest();

            xhr.open('POST', 'http://127.0.0.1:80/charms/charmsApi', true);

            xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded")

            xhr.onload = function(){
                alert(xhr.responseText);
            }

            xhr.send("param1=abc&param2=123");
        }
    </script>

    <div>
        <span>Please click the button {{text1}}：</span><button onclick="javascript:test();">Button1</button>
    </div>

</body>
</html>

Then we try to perform dynamic web page output, which is similar to dynamically rendering of webpages in the background supported by PHP, ASP, JSP, or other similar frameworks. Then browse to 'http://127.0.0.1/charms/charmsIndex' . Add the charms path to the URL, which is a virtual path indicating that the server will search for the charmsIndex.char file in the root directory while starting the server. This code will output the webpage content. Let's take a look inside the charmsIndex.char file.

// responseG is the predefined global variable which holds the HTTP response object to write to
global responseG

// basePathG is the predefined global variable which holds the specified base path while starting the server
global basePathG

// Set the default global return value variable outG to the string TX_END_RESPONSE_XT
// If the default Charlang server receives a function to process a request, the return result is TX_END_RESPONSE_XT
// The server processing(output of the HTTP response) of the page will be terminated, otherwise the return value will be output as a string to the webpage
outG := "TX_END_RESPONSE_XT"

// Obtain the corresponding web page template(HTML)
// The joinPath function will merge multiple file paths into one complete file path
// The first parameter represents the variable to be placed in the result, where $push represents stack pushing
// basePathG is a built-in global variable that represents the root directory of the service
templatePathT := joinPath(basePathG, `charmsTmpl.html`)

// Load the file as a text string(HTML)
templateTextT := loadText(templatePathT)

// Replace the {{text1}} tag to letter A
templateTextT = strReplace(templateTextT, "{{text1}}", "A")

// Set the corresponding response header
setRespHeader(responseG, "Content-Type", "text/html; charset=utf-8")

// Write the HTML to the web page output
// responseG is also a predefined global variable that represents the HTTP/webpage output object to be written to
writeResp(responseG, templateTextT)

// Return 'TX_END_RESPONSE_XT' to end the output
return outG

In Charlang server model, each HTTP request will be processed by a separate virtual machine, which can be seen as a microservice concept. The microservice in this example only replaces the specified tags in the loaded webpage template and outputs them to the webpage. Although it is simple, it has already demonstrated the basic principle of dynamic webpage, that is, it can perform necessary and controllable rendering before outputting the webpage.

Let's browse to 'http://127.0.0.1/charms/charmsIndex'. It will result in the following results:

Screenshot

We can found that the original tag has indeed been replaced with the uppercase letter A, verifying the effect of dynamic web pages.

Looking at the webpage template file charmsTmpl.html above, once the button is clicked, the JavaScript function test will be executed, where an AJAX request is made and the result of the request will be output using the alert function. This is a typical example of a client accessing a backend API service. Let's take a look at how to implement this backend API service. The following is the content of the charmsApi.char file also located in the server root directory:

// declare the global variables to use in the context
global requestG
global reqNameG
global reqUriG
global responseG
global paraMapG

// Get the current time and put it into variable t
t := getNowStr()

// Output reference information(to server's local console, not the HTTP response)
// Where reqNameG is a predefined global variable that represents the service name, which is the last part of the access URL
// reqUriG is a predefined global variable that represents the service route/path
// paraMapG is also a global variable that represents the query string or form parameters contained in HTTP requests (which can be in GET or POST requests)
pl(`[%v] reqNameG: %v, reqUriG: %v, paraMapG: %v`, t, reqNameG, reqUriG, paraMapG)

// Set output response header information (to JSON format)
setRespHeader(responseG, "Content-Type", "text/json; charset=utf-8")

// Set the response status to 200 (HTTP_oK), indicating a successful request response
writeRespHeader(responseG, 200)

// Assembling response strings using spr instructions
str1 := spr("The request is: %v, uri: %v, parameters: %v", reqNameG, reqUriG, paraMapG)

// Generate encapsulated JSON responses using genJsonResp, or output strings in other formats on your own
respStr := genJsonResp(requestG, "success", str1)

// Write and output the response string (to a webpage)
writeResp(responseG, respStr)

// End processing and return 'TX_END_RESPONSE_XT' to terminate the continued output of the response stream
return "TX_END_RESPONSE_XT"

Then, if we click button button1 on the webpage, we will get the following alert pop-up:

Screenshot

This is because the webpage charmsTmpl.html called AJAX request to the service located at http://127.0.0.1:80/charms/charmsApi. And our Charlang server will find charmsApi.char (automatically added with the .char file name suffix) and execute it, so it will output the content we want.

Now, an example of a small but fully functional WEB/application/API all-in-one server has been fully demonstrated. It is already sufficient for a general and small application service, and has almost no external dependencies. Deployment is also very convenient, only requiring the main program of Charlang and corresponding HTML and script files in the specified directory.

 

Charlang as System Service

Charlang can be started as a system service and supports operating systems such as Windows and Linux. As long as you add the command line parameter '-reinstallService' to run the Charlang main program, you can install a system service called charService in the system (which can be seen using the service management module in computer management under Windows). Note that installing services in the operating system generally requires administrator privileges. Under Windows, you need to open the CMD window as an administrator to execute this command, while under Linux, you need to execute it as root or with the sudo command.

After the service is started, a log will be recorded in the file charService.log in the service root directory (c:\char in Windows and /char in Linux). When the service starts for the first time, it will search for all files with names similar to taskXXX.char in the service root directory (such as task001.char, taskAbc.char, etc.) and run them one by one, and output their execution results (returned value) to the log. This type of code file is called a one-time-run task file, and is generally used in situations where it needs to be started and run once. It can also be manually run the command 'char -restartService' to restart the service and achieve the goal of task re-execution.

There are another kind of one-time-run task files which will be run in a seperated thread called 'thread tasks', their file name similar to threadTaskXXX.char in the service root directory (such as threadTask001.char, threadTaskAbc.char, etc.). These tasks is for those tasks need running continously, such as WEB servers, FRP server or client, ... If some error occur while running thread-tasks, the information will be logged in file 'runThreadTask.log' in service root directory.

In addition, during operation, the charService service checks the service root directory every 5 seconds. If there are files with names similar to autoRemoveTaskXXX.char (such as autoRemoveTask001.char, autoRemoveTaskAbc.char, etc.), the code in these files will be immediately executed and then deleted. This mechanism is similar to a task queue, allowing us to add tasks to the queue (placed in the service root directory) at any time, and Charlang service will execute these tasks at any time. And since the task will be deleted immediately after execution, it will not be executed repeatedly.

The command line parameters related to service installation, removal, start, stop, and restart of the Charlang main program also include '-installService', '-removeService', '-startService', '-stopService', '-restartService', and so on.

The task code can refer to examples such as task001.char, threadTask001.char, autoRemoveTask001.char, etc.

  • One-time-task Example

file: task001.char

global basePathG

logPathT := joinPath(basePathG, "charService.log")

rs := appendText("\ntask001.char\n", logPathT)

return "task001 returns some result 000"
  • Thread-task Example

file: threadTask001.char

for {
	saveText(getNowStr(), `c:\char\task1.txt`)

	sleep(60.0)
}

It will be a continous loop which will write the current time string in the file every 60 seconds.

The following is the thread-task to run Frpc client when system started,

file: threadTaskFrpc.char

appendText(spr("\n[%v] %v %v\n", getNowStr(), "threadTaskFrpc", "starting..."), `c:\logs\frpcTask.log`)

rs := systemCmd(`c:\tools\frp\frpc.exe`, `-c`, `c:\tools\frp\frpc.ini`)

appendText(spr("\n[%v] %v %v\n", getNowStr(), "threadTaskFrpc", rs), `c:\logs\frpcTask.log`)
  • Auto-remove-task Example

file: autoRemoveTask001.char

global basePathG

logPathT := joinPath(basePathG, "charService.log")

rs := appendText("\nautoRemoveTask001.char\n", logPathT)
7.7 More Examples
Builtin Function: checkErr

checkErr: check if the object is error or error string, if true, exit the program with output, usage: checkErr(result, "-format=Failed to process: %v\n"), the default format is "Error: %v\n"

file: checkErr.char

Anonymous Function

file: anonymousFunc.char

More About Array

file: array.char

More About Map

file: map.char

Mutable String

file: mutableString.char

Big Int

file: bigInt.char

Big Float

file: bigFloat.char

Bitwise Processing

file: bitwise.char

Calculate BMI

file: bmi.char

Calculate Cosine Similarity of Two Vectors

file: calCosineSimilarity.char

Calculate Cosine Similarity of Two Vectors by Big Floats
  • more precision

file: calCosineSimilarityBig.char

One More Example for Gels

file: gel3.char

Redirect Stdout to a File

Note: Better run the example code with charw.exe(i.e. the GUI version of Charlang in Windows).

file: guiRedirectStdout.char

Get Named Value in Charlang

Note: These values should be defined in the Charlang source code first before using them. In charadd.go:

...

var namedValueMapG = map[string]interface{}{
	"tk.TimeFormat":            tk.TimeFormat,            // "2006-01-02 15:04:05"
	"tk.TimeFormatMS":          tk.TimeFormatMS,          // "2006-01-02 15:04:05.000"
	"tk.TimeFormatMSCompact":   tk.TimeFormatMSCompact,   // "20060102150405.000"
	"tk.TimeFormatCompact":     tk.TimeFormatCompact,     // "20060102150405"
	"tk.TimeFormatCompact2":    tk.TimeFormatCompact2,    // "2006/01/02 15:04:05"
	"tk.TimeFormatDateCompact": tk.TimeFormatDateCompact, // "20060102"

	"time.Layout":   time.Layout,
	"time.RFC1123":  time.RFC1123,
	"time.RFC3339":  time.RFC3339,
	"time.DateTime": time.DateTime,
	"time.DateOnly": time.DateOnly,
	"time.TimeOnly": time.TimeOnly,

	"maxInt":   math.MaxInt,
	"minInt":   math.MinInt,
	"maxFloat": math.MaxFloat64,
	"minFloat": math.SmallestNonzeroFloat64,

...

Get these values by calling getNamedValue(getConst) function.

file: namedValue.char

Call Named Function in Golang

Note: These functions should be defined in the Charlang source code first before calling them. In charadd.go:

...

var namedFuncMapG = map[string]interface{}{
	"fmt.Fprintf": fmt.Fprintf,
	"tk.NewTK":    tk.NewTK,
}

...

Call these functions by calling callNamedValue function and passing the proper parameters.

file: callNamedFunc.char

With this method, in theory, we can add any functions in Golang's standard library or 3rd party repositories.

Compare Binary Files

file: binCompare.char

A Simple Text Editor

file: editFile.char

A simple text editor with file load/save, JSON validate, code running features, in GUI.

Base64 Encoding of Images

file: base64EncodeImage.char

Encode an image file to Base64 code to use in img tag in HTML, for example,

D:\tmp>char -exam base64EncodeImage.char -file=d:\downtemp\curtain-2757815_960_720.png
data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA8AAAAHECAYAAAD22EOkAAABeGlDQ1BJQ0MgUHJvZmlsZQAAeJx1kL9LAmEcxh+1sB+GQRINDTdIQyiEDTWWDUKIiBlktdyddxqcetydRDQ2tDq4VLRk0X9QW/QPBEFQTUHU3FAQQcj1nCcood/jve+H5/0+7733AN60JpfMgTmgVLaMTCIubOQ2Bf8rhjGOSYSwIMqmvpxOJ9G3vh/hcfpD1Dmr/1zPGs0rpgx4hsiLsm5Y5CVyatfSHa6RQ3JRzJPPyRGDFyTfO7rk8rvDBZd/HDaymRXAGyALhS6WulguGiVyhBwuaVW5fR/nTwJKeX2Nfbq1TGSQQBwCJFSxAw0WouxlZt...
Plot Data Graph in Console

file: asciiPlot.char

Snapshot

Plot Data Graph in Console with Realtime Data Update

file: asciiPlotRealTime.char

Demonstrate multi-thread, update one area of console...

Plot Simple Data Graph to Image

file: basicPlot.char

Demonstrate plotting a simple line chart with data in an array...

Plot Simple Data Graph to Web View

file: basicPlotToWebView.char

Demonstrate plotting a simple line chart with data in an array, then render it into an IMG element in WebView2...

Plot Line Charts

file: imagePlot.char

More examples of plotting line charts to images...

Calculator in WebView2

file: calculatorInWebView.char

A tiny GUI calculator running in WebView2, use the HTML/CSS/JavaScript example code from github.com/WebDevSimplified/Vanilla-JavaScript-Calculator. Demonstrate how to embed WEB applications in Charlang.

Estimating the Value of Pi(π) using Monte Carlo Algorithm in WebView2

file: guiCalPi.char

Demonstrate how to run a thread to update the WEB page by JavaScript continously in a WebView2 applications in Charlang.

Byte Queue

file: byteQueue.char

Demonstrate usage of a non-builtin data type "byteQueue", using 'newObj' function.

7.8 Advance Topics
Language Considerations

Charlang source code is compiled to bytecode and run in a Virtual Machine (VM). Compiled bytecode can be serialized/deserialized for wire to remove compilation step before execution for remote processes, and deserialization will solve version differences to a certain degree.

Main script and Charlang source modules in Charlang are all functions which have compiledFunction type name. Parameters can be defined for main function with param statement and main function returns a value with return statement as well. If return statement is missing, undefined value is returned by default. All functions return single value but thanks to destructuring feature Charlang allows to return multiple values as an array and set returning array elements to multiple variables.

Charlang relies on Go's garbage collector and there is no allocation limit for objects. Builtin objects can be disabled before compilation.

Charlang can handle runtime errors and Go panic with try-catch-finally statements which is similar to Ecmascript implementation with a few minor differences. Although Go developers are not fan of try-catch-finally, they are well known statements to work with.

Charlang is developed to be an embedded script language for Go applications also, and importing source modules from files will not be added in near future but one can implement a custom module to return file content to the compiler.

Charlang currently has a simple optimizer for constant folding and evaluating expressions which do not have side effects. Optimizer greedily evaluates expressions having only literals (int, uint, char, float, bool, string). Optimizer can be disabled with compiler options.

Run Script from Command Line
  • One line
D:\tmp>char -cmd=pln(1+3)
4
  • Multiple lines and/or with spaces

Original code:

a := 3
pln(a * 12)

Command-line after url-encode the parameter:

D:\tmp>char -cmd=a%20:=3%0Apln(a%20*%2012) -urlDecode
36
  • Multiple lines and/or with spaces(alternative way)

Encrypt the script first:

D:\tmp>char
Charlang 1.2.2 by TopXeQ
> encryptText("a := 12\npln(a * 5)", "char") 
694B9F86EB4B1024390E25200A6264602C571C20282F29
>

Then prefix the string //TXDEF# before the parameter,

D:\tmp>char -cmd=//TXDEF#694B9F86EB4B1024390E25200A6264602C571C20282F29
60
Show Environment Information of Charlang
D:\tmp>char -env
Charlang by TopXeQ V1.2.3
basePath: C:\Users\Administrator\char
localPath: d:\scripts
cloudPath: https://script.example.com/scripts/
Compile a Script to One Executable
D:\tmp>char -compile -output=basic.exe -example basic.char

D:\tmpx>basic.exe
3.4000000000000004

D:\tmpx>basic
3.4000000000000004

Compile a script with charw.exe in Windows, to avoid the console window(CMD) to show while running. For example:


charw -compile -output=cal.exe -example guiCalculator.char

D:\tmpx>cal.exe

Snapshot

Charlang as An Embedded Language in Golang

To run a Charlang script in Golang, it must be compiled to create a Bytecode object then it is provided to Virtual Machine (VM). Charlang has a simple optimizer enabled by default in the compiler. Optimizer evaluates simple expressions not having side effects to replace expressions with constant values. Note that, optimizer can be disabled to speed up compilation process.

Since it's in active development stage, for a successful compilation, please git clone https://github.com/topxeq/tkc in your $GOPATH/src/github.com/topxeq(%GOPATH%/src/github.com/topxeq in windows) directory first. Then add replace github.com/topxeq/tkc v0.0.0 => $GOPATH/src/github.com/topxeq/tkc in go.mod file. Be sure to replace $GOPATH to your actual GOPATH.

package main

import (
  "fmt"

  "github.com/topxeq/charlang"
)

func main() {
  script := `
  param num

  var fib
  fib = func(n, a, b) {
    if n == 0 {
      return a
    } else if n == 1 {
      return b
    }
    return fib(n-1, b, a+b)
    }
  return fib(num, 0, 1)
  `
  bytecode, err := charlang.Compile([]byte(script), &charlang.DefaultCompilerOptions)

  if err != nil {
    panic(err)
  }

  retValue, err := charlang.NewVM(bytecode).Run(nil,  charlang.Int(35))

  if err != nil {
    panic(err)
  }

  fmt.Println(retValue) // 9227465
}

Script above is pretty self explanatory, which calculates the fibonacci number of given number.

Compiler options hold all customizable options for the compiler. TraceCompilerOptions is used to trace parse-optimize-compile steps for debugging and testing purposes like below;

bytecode, err := charlang.Compile([]byte(script), charlang.TraceCompilerOptions)
// or change output and disable tracing parser
// opts := charlang.TraceCompilerOptions
// opts.Trace = os.Stderr
// opts.TraceParser = false
// bytecode, err := charlang.Compile([]byte(script), opts)

VM execution can be aborted by using Abort method which cause Run method to return an error wrapping ErrVMAborted error. Abort must be called from a different goroutine and it is safe to call multiple times.

Errors returned from Run method can be checked for specific error values with Go's errors.Is function in errors package.

VM instances are reusable. Clear method of VM clears all references held and ensures stack and module cache is cleaned.

vm := charlang.NewVM(bytecode)
retValue, err := vm.Run(nil,  Charlang.Int(35))
/* ... */
// vm.Clear()
retValue, err := vm.Run(nil,  Charlang.Int(34))
/* ... */

Global variables can be provided to VM which are declared with global keyword. Globals are accessible to source modules as well. Map like objects should be used to get/set global variables as below.

script := `
param num
global upperBound
return num > upperBound ? "big" : "small"
`
bytecode, err := charlang.Compile([]byte(script), charlang.DefaultCompilerOptions)

if err != nil {
  panic(err)
}

g := charlang.Map{"upperBound": charlang.Int(1984)}
retValue, err := charlang.NewVM(bytecode).Run(g, charlang.Int(2018))
// retValue == charlang.String("big")

There is a special type SyncMap in charlang to make goroutine safe map object where scripts/Go might need to interact with each other concurrently, e.g. one can collect statistics or data within maps. Underlying map of SyncMap is guarded with a sync.RWMutex.

module := `
global stats

return func() {
  stats.fn2++
  /* ... */
}
`
script := `
global stats

fn1 := func() {
  stats.fn1++
  /* ... */
}

fn1()

fn2 := import("module")
fn2()
`
mm := charlang.NewModuleMap()
mm.AddSourceModule("module", []byte(module))

opts := charlang.DefaultCompilerOptions
opts.ModuleMap = mm

bytecode, err := charlang.Compile([]byte(script), opts)

if err != nil {
  panic(err)
}

g := &charlang.SyncMap{
    Map: charlang.Map{"stats": charlang.Map{"fn1": charlang.Int(0), "fn2": charlang.Int(0)}},
}
_, err = charlang.NewVM(bytecode).Run(g)
/* ... */

As can be seen from examples above, VM's Run method takes arguments and its signature is as below. A map like globals argument or nil value can be provided for globals parameter. args variadic parameter enables providing arbitrary number of arguments to VM which are accessed via param statement.

func (vm *VM) Run(globals Object, args ...Object) (Object, error)
Variables Declaration and Scopes
param

param keyword is used to declare a parameter for main function (main script). Parenthesis is required for multiple declarations. Last argument can also be variadic. Unlike var keyword, initializing value is illegal. Variadic argument initialized as an empty array [], and others are initialized as undefined if not provided. param keyword can be used only once in main function.

param (arg0, arg1, ...vargs)

param foo
param bar    // illegal, multiple param keyword is not allowed

if condition  {
  param arg    // illegal, not allowed in this scope
}

func(){
    param (a, b)    // illegal, not allowed in this scope
}
global

global keyword is to declare global variables. Note that var statements or short variable declaration := always creates local variables not global. Parenthesis is required for multiple declarations. Unlike var, initializing value is illegal. global statements can appear multiple times in the scripts.

global gives access to indexable globals argument with a variable name provided to Virtual Machine (VM).

If nil is passed to VM as globals, a temporary map assigned to globals.

Any assignment to a global variable creates or updates the globals element.

Note that global variables can be accessed by imported source modules which enables to export objects to scripts like extern in C.

global foo
global (bar, baz)

// "globals" builtin function returns "globals" provided to VM.
g := globals()
v := g["foo"]    // same as `global foo; v := foo`

if condition {
  global x     // illegal, not allowed in this scope
}

func() {
  global y     // illegal, not allowed in this scope
}
var

var keyword is used to declare a local variable. Parenthesis is required for multiple declaration. Note: Tuple assignment is not supported with var statements.

var foo               // foo == undefined
var (bar, baz = 1)    // bar == undefined, baz == 1
var (bar,
     baz = 1)         // valid
var (
    foo = 1
    bar
    baz = "baz"
)                     // valid

A value can be assigned to a variable using short variable declaration := and assignment = operators.

  • := operator defines a new variable in the scope and assigns a value.
  • = operator assigns a new value to an existing variable in the scope.
                 // function scope A
a := "foo"       // define 'a' in local scope

func() {         // function scope B
  b := 52        // define 'b' in function scope B
  
  func() {       // function scope C
    c := 19.84   // define 'c' in function scope C

    a = "bee"    // ok: assign new value to 'a' from function scope A
    b = 20       // ok: assign new value to 'b' from function scope B

    b := true    // ok: define new 'b' in function scope C
                 //     (shadowing 'b' from function scope B)
  }
  
  a = "bar"      // ok: assign new value to 'a' from function scope A
  b = 10         // ok: assign new value to 'b'
  a := -100      // ok: define new 'a' in function scope B
                 //     (shadowing 'a' from function scope A)
  
  c = -9.1       // illegal: 'c' is not defined
  var b = [1, 2] // illegal: 'b' is already defined in the same scope
}

b = 25           // illegal: 'b' is not defined
var a = {d: 2}   // illegal: 'a' is already defined in the same scope

Following is illegal because variable is not defined when function is created.

In assignment statements right hand side is compiled before left hand side.

f := func() {
  f()    // illegal: unresolved symbol "f"
}

var f
f = func() {
  f()    // ok: "f" is declared before assignment.
}

Unlike Go, a variable can be assigned a value of different types.

a := 123        // assigned    'int'
a = "123"       // reassigned 'string'
a = [1, 2, 3]   // reassigned 'array'

Capturing loop variables returns the last value of the variable set after last post statement of the for loop, like Go.

var f

for i := 0; i < 3; i++ {
  f = func(){
    return i
  }  
}

println(f())  // 3

Like Go, to capture the variable define a new variable using same name or different.

var f

for i := 0; i < 3; i++ {
  i := i
  f = func(){
    return i
  }  
}

println(f())  // 2
const

const keyword is used to declare a local constant variable. Parenthesis is required for multiple declaration. Note: Tuple assignment is not supported.

The value of a constant can't be changed through reassignment.

Reassignment is checked during compilation and an error is thrown.

An initializer for a constant is required while declaring. The const declaration creates a read-only reference to a value. It does not mean the value it holds is immutable.

const (
  a = 1
  b = {foo: "bar"}
)

const c       // illegal, no initializer

a = 2         // illegal, reassignment
b.foo = "baz" // legal

iota is supported as well.

const (
  x = iota
  y
  z
)
println(x, y, z) // 0 1 2

const (
  x = 1<<iota
  y
  z
)
println(x, y, z) // 1 2 4

const (
  _ = 1<<iota
  x
  y
  z
)
println(x, y, z) // 2 4 8

const (
  x = 1+iota
  _
  z
)
println(x, z) // 1 3

const (
  x = func() { return iota }() // illegal, compile error
)

const (
  iota = 1 // illegal, compile error
)

RHS of the assignment can be any expression so iota can be used with them as well.

const (
  x = [iota]
  y
)
println(x) // [0]
println(y) // [1]

const (
  _ = iota
  x = "string" + iota
  y
)
println(x) // string1
println(y) // string2

Warning: if a variable named iota is created before const assignments, iota is not used for enumeration and it is treated as normal variable.

iota := "foo"

const (
  x = iota
  y
)
println(x) // foo
println(y) // foo
Values and Value Types

In Charlang, everything is a value, and, all values are associated with a type(object).

19 + 84                 // int values
1u + 5u                 // uint values
"foo" + `bar`           // string values
-9.22 + 1e10            // float values
true || false           // bool values
'ç' > '9'               // char values
[1, false, "foo"]       // array value
{a: 12.34, "b": "bar"}  // map value
func() { /*...*/ }      // function value

Here's a list of fundamental value types in Charlang.

Charlang Type Description Equivalent Type in Go
int signed 64-bit integer value int64
uint unsigned 64-bit integer value uint64
float 64-bit floating point value float64
bool boolean value bool
char unicode character rune
string unicode string string
bytes byte array []byte
error error value -
array value array []Object
map value map with string keys map[string]Object
undefined undefined value -
compiledFunction function value -
Error Values

In Charlang, an error can be represented using "error" typed values. An error value is created using error builtin function, and, it has an underlying message. The underlying message of an error can be accessed using .Message selector. Error has also a name which is accessed using .Name. Errors created with error builtin have default name error but builtin errors have different names like NotIterableError, ZeroDivisionError.

First argument passed to error builtin function is converted to string as message.

err1 := error("oops")
err2 := error(1+2+3)         // equivalent to err2 := error("6")
if isError(err1) {           // 'isError' is a builtin function
  name := err1.Name          // get underlying name
  message := err1.Message    // get underlying message
}
Charlang Runtime Types
Basic types:
  • bool: boolean (bool in Go)
  • byte: unsigned 8bit integer (uint8 in Go)
  • char: character (rune in Go)
  • int: signed 64bit integer (int64 in Go)
  • uint: unsigned 64bit integer (uint64 in Go)
  • float: 64bit floating point (float64 in Go)
  • string: string (string in Go)
  • bytes: byte array ([]byte in Go)
  • chars: character ([]rune in Go)
  • array: objects array ([]Object in Go)
  • map: objects map with string keys (map[string]Object in Go)
  • error: an error with a string Name and Message
  • undefined: undefined
More types:
  • bigInt: holds an big integer value
  • bigFloat: holds an big float value
  • mutableString: mutable string
  • orderedMap: map with fix-ordered items
  • objectRef: object reference to pass to functions
  • stack: a common stack
  • queue: a common queue
  • function: callable function
  • compiledFunction: compiled function
  • charCode: holds the source code and runnable Charlang code
  • gel: holds the source code and runnable Charlang code mainly for remote call
  • statusResult: status object, usually return by server side, in form of: {"Status": "success", "Value": "more info"} or {"Status": "fail", "Value": "error message"}
  • stringBuilder: holds a strings.Builder object in Golang
  • bytesBuffer: holds a bytes.Buffer object in Golang
  • database: holds a database object in Golang
  • time: holds a time.Time object in Golang
  • location: holds a time.Location object in Golang
  • seq: an object to generate unique, sequential numbers
  • mutex: mutex for multi-threading
  • mux: mux(router) for http request
  • httpReq: holds a http.Request object in Golang
  • httpResp: holds a http.Response object in Golang
  • httpHandler: holds a http.HandleFunc object in Golang
  • reader: holds a io.Reader object in Golang
  • writer: holds a io.Writer object in Golang
  • file: holds a os.File object in Golang
  • image: holds a image.Image object in Golang
  • delegate: holds a delegate(callback) function for calling
  • etable: holds an object with multi-sheet table data like Excel or CSV
  • excel: holds an object with Excel data
  • any: an object to hold any value types
Go Type Definitions
  • int
type Int int64
  • uint
type Uint uint64

Note: uint values can be represented by adding u suffix to integer values.

  • float
type Float float64
  • bool
type Bool bool
  • char
type Char rune
  • string
type String string
  • bytes
type Bytes []byte
  • error
type Error struct {
  Name    string
  Message string
  Cause   error
}
  • array
type Array []Object
  • map
type Map map[string]Object
  • syncMap
type SyncMap struct {
  mu sync.RWMutex
  Map
}
Type Conversion/Coercion Table
int uint float bool char string bytes array map error undefined
int - uint64(v) float64(v) !IsFalsy() rune(v) strconv X X X String() X
uint int64(v) - float64(v) !IsFalsy() rune(v) strconv X X X String() X
float int64(v) uint64(v) - !IsFalsy() rune(v) strconv X X X String() X
bool 1 / 0 1 / 0 1.0 / 0.0 - 1 / 0 "true" / "false" X X X String() X
char int64(v) uint64(v) float64(v) !IsFalsy() - string(v) X X X String() X
string strconv strconv strconv !IsFalsy() utf8. DecodeRuneInString(v) - []byte(v) X X String() X
bytes X X X !IsFalsy() X string(v) - X X String() X
array X X X !IsFalsy() X String() X - X String() X
map X X X !IsFalsy() X String() X X - String() X
error X X X X X String() X X X - X
undefined X X X !IsFalsy() X String() X X X X -
  • X: No conversion. Conversion function will throw runtime error, TypeError.
  • strconv: converted using Go's conversion functions from strconv package.
  • IsFalsy(): use Object.IsFalsy() function.
  • String(): use Object.String() function.
Object.IsFalsy()

Object.IsFalsy() interface method is used to determine if a given value should evaluate to false (e.g. for condition expression of if statement).

  • int: v == 0
  • uint: v == 0
  • float: math.IsNaN(v)
  • bool: !v
  • char: v == 0
  • string: len(v) == 0
  • bytes: len(v) == 0
  • array: len(v) == 0
  • map: len(v) == 0
  • error: true (error is always falsy)
  • undefined: true (undefined is always falsy)
Builtin Errors

Builtin errors do not have message but have name. With .New(message) function call on an error value creates a new error by wrapping the error.

  • WrongNumArgumentsError
  • InvalidOperatorError
  • IndexOutOfBoundsError
  • NotIterableError
  • NotIndexableError
  • NotIndexAssignableError
  • NotCallableError
  • NotImplementedError
  • ZeroDivisionError
  • TypeError
Undefined Values

In Charlang, an undefined value can be used to represent an unexpected or non-existing value:

  • A function that does not return a value explicitly considered to return undefined value.
  • Indexer or selector on composite value types may return undefined if the key or index does not exist.
  • Builtin functions may return undefined.
a := func() { b := 4 }()    // a == undefined
c := {a: "foo"}["b"]        // c == undefined
d := sort(undefined)        // d == undefined
e := delete({}, "foo")      // "delete" always returns undefined

Builtin function isUndefined, isUndef or == operator can be used to check value is undefined.

Array Values

In Charlang, array is an ordered list of values of any types. Elements of an array can be accessed using indexer [].

[1, 2, 3][0]       // == 1
[1, 2, 3][2]       // == 3
[1, 2, 3][3]       // RuntimeError: IndexOutOfBoundsError

["foo", 'x', [1, 2, 3], {bar: 2u}, true, undefined, bytes()]   // ok
Map Values

In Charlang, map is a set of key-value pairs where key is string and the value is of any value types. Value of a map can be accessed using indexer [] or selector '.' operators.

m := { a: 1, "b": false, c: "foo" }
m["b"]                                // == false
m.c                                   // == "foo"
m.x                                   // == undefined

{a: [1, 2, 3], b: {c: "foo", d: "bar"}} // ok
Function Values

In Charlang, function is a callable value with a number of function arguments and a return value. Just like any other values, functions can be passed into or returned from another function.

sum := func(arg1, arg2) {
  return arg1 + arg2
}

var mul = func(arg1, arg2) {
  return arg1 * arg2
}

adder := func(base) {
  return func(x) { return base + x }  // capturing 'base'
}

add5 := adder(5)
nine := add5(4)    // == 9

Unlike Go, Charlang does not have function declarations. All functions are anonymous functions. So the following code is illegal:

func foo(arg1, arg2) {  // illegal
  return arg1 + arg2
}

Charlang also supports variadic functions:

variadic := func (a, b, ...c) {
  return [a, b, c]
}
variadic(1, 2, 3, 4) // [1, 2, [3, 4]]

variadicClosure := func(a) {
  return func(b, ...c) {
    return [a, b, c]
  }
}
variadicClosure(1)(2, 3, 4) // [1, 2, [3, 4]]

Only the last parameter can be variadic. The following code is illegal:

// illegal, because "a" is variadic and is not the last parameter
illegal := func(...a, b) {}

When calling a function, the number of passing arguments must match that of function definition.

f := func(a, b) {}
f(1, 2, 3)    // RuntimeError: WrongNumArgumentsError

Like Go, you can use ellipsis ... to pass value of array type as its last parameter:

f1 := func(a, b, c) { return a + b + c }
f1(...[1, 2, 3])    // => 6
f1(1, ...[2, 3])    // => 6
f1(1, 2, ...[3])    // => 6
f1(...[1, 2])       // RuntimeError: WrongNumArgumentsError

f2 := func(a, ...b) {}
f2(1)               // valid; a == 1, b == []
f2(1, 2)            // valid; a == 1, b == [2]
f2(1, 2, 3)         // valid; a == 1, b == [2, 3]
f2(...[1, 2, 3])    // valid; a == 1, b == [2, 3]
Type Conversions

Although the type is not directly specified in Charlang, one can use type conversion builtin functions to convert between value types.

s1 := string(1984)    // "1984"
i2 := int("-999")     // -999
f3 := float(-51)      // -51.0
b4 := bool(1)         // true
c5 := char("X")       // 'X'
Order of evaluation

Expressions are evaluated from left to right but in assignments, right hand sideof the assignment is evaluated before left hand side.

a := 1
f := func() {
  a*=10
  return a
}
g := func() {
  a++
  return a
}
h := func() {
  a+=2
  return a
}
d := {}
d[f()] = [g(), h()]
return d    // d == {"40": [2, 4]}
Operators
Unary Operators
Operator Operation Types(Results)
+ 0 + x int(int), uint(uint), char(char), float(float), bool(int)
- 0 - x int(int), uint(uint), char(int), float(float), bool(int)
^ bitwise complement ^x int(int), uint(uint), char(char), bool(int)
! logical NOT all types*

* In Charlang, all values can be either truthy or falsy.

Binary Operators
Operator Usage
== equal
!= not equal
&& logical AND
|| logical OR
+ add/concat
- subtract
* multiply
/ divide
& bitwise AND
| bitwise OR
^ bitwise XOR
&^ bitclear (AND NOT)
<< shift left
>> shift right
< less than
<= less than or equal to
> greater than
>= greater than or equal to
Ternary Operators

Charlang has a ternary conditional operator (condition expression) ? (true expression) : (false expression).

a := true ? 1 : -1    // a == 1

min := func(a, b) {
  return a < b ? a : b
}
b := min(5, 10)      // b == 5
Assignment and Increment Operators
Operator Usage
+= (lhs) = (lhs) + (rhs)
-= (lhs) = (lhs) - (rhs)
*= (lhs) = (lhs) * (rhs)
/= (lhs) = (lhs) / (rhs)
%= (lhs) = (lhs) % (rhs)
&= (lhs) = (lhs) & (rhs)
|= (lhs) = (lhs) | (rhs)
&^= (lhs) = (lhs) &^ (rhs)
^= (lhs) = (lhs) ^ (rhs)
<<= (lhs) = (lhs) << (rhs)
>>= (lhs) = (lhs) >> (rhs)
++ (lhs) = (lhs) + 1
-- (lhs) = (lhs) - 1
Operator Precedences

Unary operators have the highest precedence, and, ternary operator has the lowest precedence. There are five precedence levels for binary operators. Multiplication operators bind strongest, followed by addition operators, comparison operators, && (logical AND), and finally || (logical OR):

Precedence Operator
5 * / % << >> & &^
4 + - | ^
3 == != < <= > >=
2 &&
1 ||

Like Go, ++ and -- operators form statements, not expressions, they fall outside the operator hierarchy.

Selector and Indexer

One can use selector (.) and indexer ([]) operators to read or write elements of composite types (array, map, string, bytes).

["one", "two", "three"][1]  // == "two"

bytes(0, 1, 2, 3)[1]    // == 1

// Like Go, indexing string returns byte value of index as int value.
"foobarbaz"[4]    // == 97

m := {
  a: 1,
  b: [2, 3, 4],
  c: func() { return 10 }
}
m.a              // == 1
m["b"][1]        // == 3
m.c()            // == 10
m.x.y.z          // == undefined
m.x.y.z = 1      // RuntimeError: NotIndexAssignableError
m.x = 5          // add 'x' to map 'm'

Like Go, one can use slice operator [:] for sequence value types such as array, string, bytes. Negative indexes are illegal.

a := [1, 2, 3, 4, 5][1:3]    // == [2, 3]
b := [1, 2, 3, 4, 5][3:]     // == [4, 5]
c := [1, 2, 3, 4, 5][:3]     // == [1, 2, 3]
d := "hello world"[2:10]     // == "llo worl"
e := [1, 2, 3, 4, 5][:]      // == [1, 2, 3, 4, 5]
f := [1, 2, 3, 4, 5][-1:]    // RuntimeError: InvalidIndexError
g := [1, 2, 3, 4, 5][10:]    // RuntimeError: IndexOutOfBoundsError

Note: Keywords cannot be used as selectors.

a := {}
a.func = ""     // Parse Error: expected selector, found 'func'

Use double quotes and indexer to use keywords with maps.

a := {}
a["func"] = ""
Statements
If Statement

"If" statement is very similar to Go.

if a < 0 {
  // execute if 'a' is negative
} else if a == 0 {
  // execute if 'a' is zero
} else {
  // execute if 'a' is positive
}

Like Go, the condition expression may be preceded by a simple statement, which executes before the expression is evaluated.

if a := foo(); a < 0 {
  // execute if 'a' is negative
}
For Statement

"For" statement is very similar to Go.

// for (init); (condition); (post) {}
for a:=0; a<10; a++ {
  // ...
}

// for (condition) {}
for a < 10 {
  // ...
}

// for {}
for {
  // ...
}
For-In Statement

It's similar to Go's for range statement. "For-In" statement can iterate any iterable value types (array, map, bytes, string).

for v in [1, 2, 3] {          // array: element
  // 'v' is array element value
}
for i, v in [1, 2, 3] {       // array: index and element
  // 'i' is index
  // 'v' is array element value
}
for k, v in {k1: 1, k2: 2} {  // map: key and value
  // 'k' is key
  // 'v' is map element value
}
for i, v in "foo" {           // array: index and element
  // 'i' is index
  // 'v' is char
}
Modules

Module is the basic compilation unit in Charlang. A module can import another module using import expression. There 3 types of modules. Source modules, builtin modules and custom modules. Source module is in the form Charlang code. Builtin module type is map[string]Object. Lastly, any value implementing Go Importable interface can be a module. Import method must return a valid Charlang Object or []byte. Source module is called like a compiled function and returned value is stored for future use. Other module values are copied while importing in VM if Copier interface is implemented.

type Importable interface {
  Import(moduleName string) (interface{}, error)
}

type Copier interface {
  Copy() Object
}

Main module:

sum := import("sum")    // load a module
println(sum(10))        // module function

Source module as sum:

base := 5

return func(x) {
  return x + base
}

In Charlang, modules are very similar to functions.

  • import expression loads the module code and execute it like a function.
  • Module should return a value using return statement.
    • Module can return a value of any types: int, map, function, etc.
    • return in a module stops execution and return a value to the importing code.
    • If the module does not have any return statement, import expression simply returns undefined. (Just like the function that has no return.)
  • importing same module multiple times at different places or in different modules returns the same object so it preserves the state of imported object.
  • Arguments cannot be provided to source modules while importing although it is allowed to use param statement in module.
  • Modules can use global statements to access globally shared object.
Differences from Go

Unlike Go, Charlang does not have the following:

  • Imaginary values
  • Structs
  • Pointers
  • Channels
  • Goroutines
  • Tuple assignment (Charlang supports destructuring array)
  • Switch statement
  • Goto statement
  • Defer statement
  • Panic and recover
  • Type assertion
Interfaces

Charlang types implement Object interface. Any Go type implementing Object interface can be provided to Charlang VM.

Object interface

// Object represents an object in the VM.
type Object interface {
  // TypeName should return the name of the type.
  TypeName() string

  // String should return a string of the type's value.
  String() string

  // BinaryOp handles +,-,*,/,%,<<,>>,<=,>=,<,> operators.
  // Returned error stops VM execution if not handled with an error handler
  // and VM.Run returns the same error as wrapped.
  BinaryOp(tok token.Token, right Object) (Object, error)

  // IsFalsy returns true if value is falsy otherwise false.
  IsFalsy() bool

  // Equal checks equality of objects.
  Equal(right Object) bool

  // Call is called from VM if CanCall() returns true. Check the number of
  // arguments provided and their types in the method. Returned error stops VM
  // execution if not handled with an error handler and VM.Run returns the
  // same error as wrapped.
  Call(args ...Object) (Object, error)

  // CanCall returns true if type can be called with Call() method.
  // VM returns an error if one tries to call a noncallable object.
  CanCall() bool

  // Iterate should return an Iterator for the type.
  Iterate() Iterator

  // CanIterate should return whether the Object can be Iterated.
  CanIterate() bool

  // IndexGet should take an index Object and return a result Object or an
  // error for indexable objects. Indexable is an object that can take an
  // index and return an object. Returned error stops VM execution if not
  // handled with an error handler and VM.Run returns the same error as
  // wrapped. If Object is not indexable, ErrNotIndexable should be returned
  // as error.
  IndexGet(index Object) (value Object, err error)

  // IndexSet should take an index Object and a value Object for index
  // assignable objects. Index assignable is an object that can take an index
  // and a value on the left-hand side of the assignment statement. If Object
  // is not index assignable, ErrNotIndexAssignable should be returned as
  // error. Returned error stops VM execution if not handled with an error
  // handler and VM.Run returns the same error as wrapped.
  IndexSet(index, value Object) error
}
Iterator interface

If an object's CanIterate method returns true, its Iterate method must return a value implementing Iterator interface to use in for-in loops.

// Iterator wraps the methods required to iterate Objects in VM.
type Iterator interface {
  // Next returns true if there are more elements to iterate.
  Next() bool

  // Key returns the key or index value of the current element.
  Key() Object

  // Value returns the value of the current element.
  Value() Object
}
Copier interface

Assignments to Charlang values copy the values except array, map or bytes like Go. copy builtin function returns the copy of a value if Copier interface is implemented by object. If not implemented, same object is returned which copies the value under the hood by Go.

// Copier wraps the Copy method to create a deep copy of an object.
type Copier interface {
  Copy() Object
}
IndexDeleter interface

delete builtin checks if the given object implements IndexDeleter interface to delete an element from the object. map and syncMap implement this interface.

// IndexDeleter wraps the IndexDelete method to delete an index of an object.
type IndexDeleter interface {
    IndexDelete(Object) error
}
LengthGetter interface

len builtin checks if the given object implements IndexDeleter interface to get the length of an object. array, bytes, string, map and syncMap implement this interface.

// LengthGetter wraps the Len method to get the number of elements of an object.
type LengthGetter interface {
    Len() int
}
Object Interface Extensions

Note that ExCallerObject will replace the existing Object interface in the uture.

// ExCallerObject is an interface for objects that can be called with CallEx
// method. It is an extended version of the Call method that can be used to
// call an object with a Call struct. Objects implementing this interface is
// called with CallEx method instead of Call method.
// Note that CanCall() should return true for objects implementing this
// interface.
type ExCallerObject interface {
    Object
    CallEx(c Call) (Object, error)
}

// NameCallerObject is an interface for objects that can be called with CallName
// method to call a method of an object. Objects implementing this interface can
// reduce allocations by not creating a callable object for each method call.
type NameCallerObject interface {
    Object
    CallName(name string, c Call) (Object, error)
}

Documentation

Overview

Package builtins provides the built-in functions for the Charlang language.

Overview

This file contains all built-in functions that are available in Charlang scripts. Built-in functions are pre-defined functions that provide core language functionality and access to Go's standard library and external packages.

Function Categories

Built-in functions are organized into the following categories:

**Core Functions:**

  • print, printf, println - Output functions
  • len, type, typeof - Inspection functions
  • int, float, string, bool, char - Type conversion functions
  • append, copy, delete - Collection manipulation

**String Functions:**

  • str, format, sprintf - String formatting
  • split, join, replace, trim - String manipulation
  • regex, matches, find - Regular expressions

**Collection Functions:**

  • map, filter, reduce - Functional operations
  • sort, reverse, shuffle - Collection ordering
  • keys, values, items - Map operations

**I/O Functions:**

  • open, close, read, write - File operations
  • read_file, write_file - Convenience file functions
  • http_get, http_post - HTTP requests

**System Functions:**

  • time, sleep, timer - Time operations
  • exec, shell - Process execution
  • env, args - Environment access

**Data Processing:**

  • json, yaml, xml, csv - Data format handling
  • base64, hex, url_encode - Encoding functions
  • hash, md5, sha256 - Cryptographic functions

**External Services:**

  • database, query - Database operations
  • mail, ftp, s3 - External service integrations
  • excel, word, pdf - Document processing

Usage

Built-in functions are automatically available in Charlang scripts: 

print("Hello, World!")
result := len([1, 2, 3])  // result = 3
items := split("a,b,c", ",")  // items = ["a", "b", "c"]

Extending Builtins

To add a new built-in function:

  1. Add a constant to BuiltinType
  2. Add an entry to BuiltinsMap
  3. Add the function object to BuiltinObjects array
  4. Implement the function logic

Package charlang provides a scripting language interpreter with Go integration. Charlang is a dynamically-typed scripting language designed for embedding in Go applications.

Overview

Charlang provides:

  • A complete scripting language with familiar syntax
  • Seamless Go value integration via type conversion functions
  • A virtual machine (VM) for executing compiled bytecode
  • Extensible built-in functions and modules
  • Support for closures, generators, and object-oriented patterns

Core Components

The main components of Charlang are:

  • Compiler: Transforms source code into bytecode (compiler.go)
  • VM: Executes compiled bytecode (vm.go)
  • Objects: Represents all runtime values (objects.go)
  • Builtins: Provides built-in functions (builtins.go)
  • Parser: Parses source code into AST (parser/)

Basic Usage

Simple script execution: 

script := `print("Hello, World!")`
result, err := charlang.Execute(script, nil)

With variables: 

script := `x + y`
vars := map[string]interface{}{"x": 10, "y": 20}
result, err := charlang.Execute(script, vars)

Type Conversion

Charlang provides bidirectional type conversion between Go and Charlang: 

// Go to Charlang
obj, err := charlang.ToObject(goValue)

// Charlang to Go
goValue := charlang.ToInterface(obj)

Object Types

Charlang supports multiple object types including:

  • Primitive types: Int, Uint, Float, String, Bool, Char, Bytes
  • Container types: Array, Map, SyncMap
  • Function types: Function, CompiledFunction, BuiltinFunction
  • Special types: Undefined, Error, RuntimeError
  • External types: Time, Database, WebSocket, Excel, Image, etc.

Thread Safety

The VM and most object types are not thread-safe by default. Use SyncMap for concurrent map access and Mutex for synchronization.

Extending Charlang

You can extend Charlang with custom functions: 

customFunc := &charlang.Function{
    Name: "myFunc",
    Value: func(args ...charlang.Object) (charlang.Object, error) {
        return charlang.Int(42), nil
    },
}

Package opcodes defines the bytecode instructions for the Charlang VM.

Opcode Overview

Opcodes are single-byte instructions that the VM executes sequentially. Each opcode may have zero or more operands that provide additional data.

Instruction Format

Instructions are encoded as: [opcode][operand1][operand2]... Operands are either 1 byte (0-255) or 2 bytes (0-65535, big-endian).

Opcode Categories

  • Constants: OpConstant, OpNull, OpTrue, OpFalse
  • Variables: OpGetGlobal, OpSetGlobal, OpGetLocal, OpSetLocal, OpGetFree, OpSetFree
  • Calls: OpCall, OpCallName, OpGetBuiltin, OpReturn
  • Operations: OpBinaryOp, OpUnary, OpEqual, OpNotEqual
  • Control Flow: OpJump, OpJumpFalsy, OpAndJump, OpOrJump
  • Data Structures: OpMap, OpArray, OpSliceIndex, OpGetIndex, OpSetIndex
  • Closures: OpClosure, OpGetLocalPtr, OpGetFreePtr
  • Iteration: OpIterInit, OpIterNext, OpIterKey, OpIterValue
  • Modules: OpLoadModule, OpStoreModule
  • Exceptions: OpSetupTry, OpSetupCatch, OpSetupFinally, OpThrow, OpFinalizer
  • Stack: OpPop, OpDefineLocal

Index

Constants

View Source 
const (
	// True represents a true value.
	True = Bool(true)

	// False represents a false value.
	False = Bool(false)
)
View Source 
const (
	// AttrModuleName is a special attribute injected into modules to identify
	// the modules by name.
	AttrModuleName = "__module_name__"
)

Variables

View Source 
var (
	// DefaultCompilerOptions holds default Compiler options.
	DefaultCompilerOptions = CompilerOptions{
		OptimizerMaxCycle: 100,
		OptimizeConst:     true,
		OptimizeExpr:      true,
	}
	// TraceCompilerOptions holds Compiler options to print trace output
	// to stdout for Parser, Optimizer, Compiler.
	TraceCompilerOptions = CompilerOptions{
		Trace:             os.Stdout,
		TraceParser:       true,
		TraceCompiler:     true,
		TraceOptimizer:    true,
		OptimizerMaxCycle: 1<<8 - 1,
		OptimizeConst:     true,
		OptimizeExpr:      true,
	}
)
View Source 
var (
	// ErrSymbolLimit represents a symbol limit error which is returned by
	// Compiler when number of local symbols exceeds the symbo limit for
	// a function that is 256.
	ErrSymbolLimit = &Error{
		Name:    "SymbolLimitError",
		Message: "number of local symbols exceeds the limit",
	}

	// ErrStackOverflow represents a stack overflow error.
	ErrStackOverflow = &Error{Name: "StackOverflowError"}

	// ErrVMAborted represents a VM aborted error.
	ErrVMAborted = &Error{Name: "VMAbortedError"}

	// ErrWrongNumArguments represents a wrong number of arguments error.
	ErrWrongNumArguments = &Error{Name: "WrongNumberOfArgumentsError"}

	// ErrInvalidOperator represents an error for invalid operator usage.
	ErrInvalidOperator = &Error{Name: "InvalidOperatorError"}

	// ErrIndexOutOfBounds represents an out of bounds index error.
	ErrIndexOutOfBounds = &Error{Name: "IndexOutOfBoundsError"}

	// ErrInvalidIndex represents an invalid index error.
	ErrInvalidIndex = &Error{Name: "InvalidIndexError"}

	// ErrNotIterable is an error where an Object is not iterable.
	ErrNotIterable = &Error{Name: "NotIterableError"}

	// ErrNotIndexable is an error where an Object is not indexable.
	ErrNotIndexable = &Error{Name: "NotIndexableError"}

	// ErrNotIndexAssignable is an error where an Object is not index assignable.
	ErrNotIndexAssignable = &Error{Name: "NotIndexAssignableError"}

	// ErrNotCallable is an error where Object is not callable.
	ErrNotCallable = &Error{Name: "NotCallableError"}

	// ErrNotImplemented is an error where an Object has not implemented a required method.
	ErrNotImplemented = &Error{Name: "NotImplementedError"}

	// ErrZeroDivision is an error where divisor is zero.
	ErrZeroDivision = &Error{Name: "ZeroDivisionError"}

	// ErrType represents a type error.
	ErrType = &Error{Name: "TypeError"}
)
View Source 
var BigFloatZero = big.NewFloat(0)
View Source 
var BigIntZero = big.NewInt(0)
View Source 
var BuiltinCharCodeFunc = builtinCharCodeFunc
View Source 
var BuiltinObjects = [...]Object{}/* 586 elements not displayed */

BuiltinObjects contains the implementation objects for all built-in functions. Each BuiltinType constant is used as an index into this array. The array is indexed by BuiltinType value and contains BuiltinFunction objects.

Example: 

fn := BuiltinObjects[BuiltinPrint]  // Returns the print function object
result, err := fn.Call(arg1, arg2)
View Source 
var BuiltinsMap = map[string]BuiltinType{}/* 650 elements not displayed */

BuiltinsMap maps built-in function names to their BuiltinType identifiers. This allows the compiler and VM to resolve function names to their implementations. The map is exported for use by REPL and other tooling.

Example: 

builtinType := BuiltinsMap["print"]  // Returns BuiltinPrint
builtinType := BuiltinsMap["len"]    // Returns BuiltinLen
View Source 
var CodeTextG = ""
View Source 
var DebugModeG = false
View Source 
var ErrCommon = &Error{Name: "error"}
View Source 
var OpcodeNames = [...]string{
	OpNoOp:         "NOOP",
	OpConstant:     "CONSTANT",
	OpCall:         "CALL",
	OpGetGlobal:    "GETGLOBAL",
	OpSetGlobal:    "SETGLOBAL",
	OpGetLocal:     "GETLOCAL",
	OpSetLocal:     "SETLOCAL",
	OpGetBuiltin:   "GETBUILTIN",
	OpBinaryOp:     "BINARYOP",
	OpUnary:        "UNARY",
	OpEqual:        "EQUAL",
	OpNotEqual:     "NOTEQUAL",
	OpJump:         "JUMP",
	OpJumpFalsy:    "JUMPFALSY",
	OpAndJump:      "ANDJUMP",
	OpOrJump:       "ORJUMP",
	OpMap:          "MAP",
	OpArray:        "ARRAY",
	OpSliceIndex:   "SLICEINDEX",
	OpGetIndex:     "GETINDEX",
	OpSetIndex:     "SETINDEX",
	OpNull:         "NULL",
	OpPop:          "POP",
	OpGetFree:      "GETFREE",
	OpSetFree:      "SETFREE",
	OpGetLocalPtr:  "GETLOCALPTR",
	OpGetFreePtr:   "GETFREEPTR",
	OpClosure:      "CLOSURE",
	OpIterInit:     "ITERINIT",
	OpIterNext:     "ITERNEXT",
	OpIterKey:      "ITERKEY",
	OpIterValue:    "ITERVALUE",
	OpLoadModule:   "LOADMODULE",
	OpStoreModule:  "STOREMODULE",
	OpReturn:       "RETURN",
	OpSetupTry:     "SETUPTRY",
	OpSetupCatch:   "SETUPCATCH",
	OpSetupFinally: "SETUPFINALLY",
	OpThrow:        "THROW",
	OpFinalizer:    "FINALIZER",
	OpDefineLocal:  "DEFINELOCAL",
	OpTrue:         "TRUE",
	OpFalse:        "FALSE",
	OpCallName:     "CALLNAME",
}

OpcodeNames maps each opcode to its human-readable string representation. Used for debugging and disassembly output.

View Source 
var OpcodeOperands = [...][]int{
	OpNoOp:         {},
	OpConstant:     {2},
	OpCall:         {1, 1},
	OpGetGlobal:    {2},
	OpSetGlobal:    {2},
	OpGetLocal:     {1},
	OpSetLocal:     {1},
	OpGetBuiltin:   {2},
	OpBinaryOp:     {1},
	OpUnary:        {1},
	OpEqual:        {},
	OpNotEqual:     {},
	OpJump:         {2},
	OpJumpFalsy:    {2},
	OpAndJump:      {2},
	OpOrJump:       {2},
	OpMap:          {2},
	OpArray:        {2},
	OpSliceIndex:   {},
	OpGetIndex:     {1},
	OpSetIndex:     {},
	OpNull:         {},
	OpPop:          {},
	OpGetFree:      {1},
	OpSetFree:      {1},
	OpGetLocalPtr:  {1},
	OpGetFreePtr:   {1},
	OpClosure:      {2, 1},
	OpIterInit:     {},
	OpIterNext:     {},
	OpIterKey:      {},
	OpIterValue:    {},
	OpLoadModule:   {2, 2},
	OpStoreModule:  {2},
	OpReturn:       {1},
	OpSetupTry:     {2, 2},
	OpSetupCatch:   {},
	OpSetupFinally: {},
	OpThrow:        {1},
	OpFinalizer:    {1},
	OpDefineLocal:  {1},
	OpTrue:         {},
	OpFalse:        {},
	OpCallName:     {1, 1},
}

OpcodeOperands defines the operand specification for each opcode. Each entry is a slice of operand widths in bytes:

  • {} means no operands
  • {1} means one 1-byte operand (0-255)
  • {2} means one 2-byte operand (0-65535, big-endian)
  • {1, 1} means two 1-byte operands
  • {2, 1} means one 2-byte and one 1-byte operand
View Source 
var (
	PrintWriter io.Writer = os.Stdout
)

PrintWriter is the default writer for printf and println builtins. It defaults to os.Stdout but can be redirected for testing or logging.

View Source 
var RandomGeneratorG *tk.RandomX = nil
View Source 
var RegiCountG int = 30
View Source 
var ServerModeG = false
View Source 
var StatusResultFail = StatusResult{Status: "fail", Value: ""}
View Source 
var StatusResultInvalid = StatusResult{Status: "", Value: ""}
View Source 
var StatusResultSuccess = StatusResult{Status: "success", Value: ""}
View Source 
var VerboseG = false
View Source 
var VersionG = "2.1.3"

global vars

Functions

func AnysToOriginal 

func AnysToOriginal(aryA []Object) []interface{}

func ConvertFromObject 

func ConvertFromObject(vA Object) interface{}

func DownloadStringFromSSH 

func DownloadStringFromSSH(sshA string, filePathA string) string

func FormatInstructions 

func FormatInstructions(b []byte, posOffset int) []string

FormatInstructions returns string representation of bytecode instructions.

func FromStringObject 

func FromStringObject(argA String) string

FromStringObject creates a String object from string. Parameters:

  • argA: The string to wrap (required)

Returns:

  • A new String object

Examples: 

FromStringObject("hello") // Returns: String("hello")
FromStringObject("42") // Returns: String("42")

func GetCfgString 

func GetCfgString(fileNameA string) string

func GetMagic 

func GetMagic(numberA int) string

func GetSwitchFromObjects 

func GetSwitchFromObjects(argsA []Object, switchA string, defaultA string) string

GetSwitchFromObjects returns switch value from objects, or default when absent.

func IfSwitchExistsInObjects 

func IfSwitchExistsInObjects(argsA []Object, switchA string) bool

IfSwitchExistsInObjects reports whether the switch exists in object args.

func IsUndefInternal 

func IsUndefInternal(o Object) bool

func IterateInstructions 

func IterateInstructions(insts []byte,
	fn func(pos int, opcode Opcode, operands []int, offset int) bool)

IterateInstructions iterate instructions and call given function for each instruction. Note: Do not use operands slice in callback, it is reused for less allocation.

func MakeInstruction 

func MakeInstruction(buf []byte, op Opcode, args ...int) ([]byte, error)

MakeInstruction returns a bytecode for an Opcode and the operands.

Provide "buf" slice which is a returning value to reduce allocation or nil to create new byte slice. This is implemented to reduce compilation allocation that resulted in -15% allocation, +2% speed in compiler. It takes ~8ns/op with zero allocation.

Returning error is required to identify bugs faster when VM and Opcodes are under heavy development.

Warning: Unknown Opcode causes panic!

func NewChar 

func NewChar(codeA string) (interface{}, error)

func ObjectsToBytes 

func ObjectsToBytes(aryA []Object) []byte

func ObjectsToI 

func ObjectsToI(aryA []Object) []interface{}

func ObjectsToN 

func ObjectsToN(aryA []Object) []int

func ObjectsToO 

func ObjectsToO(aryA []Object) []interface{}

func ObjectsToS 

func ObjectsToS(aryA []Object) []string

func OneResultCallAdapter 

func OneResultCallAdapter(fn CallableFunc) func(args ...Object) Object

char add start OneResultCallAdapter wraps CallableFunc and returns only one Object result.

func OneResultCallExAdapter 

func OneResultCallExAdapter(fn CallableExFunc) func(args ...Object) Object

OneResultCallExAdapter wraps CallableExFunc and returns only one Object result.

func QuickCompile 

func QuickCompile(codeA string, compilerOptionsA ...*CompilerOptions) interface{}

func QuickRun 

func QuickRun(codeA interface{}, globalsA map[string]interface{}, additionsA ...Object) interface{}

func ReadOperands 

func ReadOperands(numOperands []int, ins []byte, operands []int) ([]int, int)

ReadOperands reads operands from bytecode instructions. It parses the operand bytes according to the specified widths and returns the operand values and the total bytes consumed.

Parameters:

  • numOperands: slice of operand widths (1 or 2 bytes each)
  • ins: bytecode instruction slice starting after the opcode
  • operands: pre-allocated slice to fill (reused to reduce allocations)

Returns:

  • operands: slice of parsed operand values
  • int: total number of bytes consumed

Example: 

// For OpConstant with operands {2}:
operands, offset := ReadOperands([]int{2}, ins[1:], make([]int, 0, 1))
// operands[0] contains the constant index

func RemoveCfgString 

func RemoveCfgString(fileNameA string) string

func RunAsFunc 

func RunAsFunc(codeA interface{}, argsA ...interface{}) interface{}

func RunCharCode 

func RunCharCode(codeA string, envA map[string]interface{}, paraMapA map[string]string, argsA ...Object) (interface{}, error)

func RunScriptOnHttp 

func RunScriptOnHttp(codeA string, compilerOptionsA *CompilerOptions, res http.ResponseWriter, req *http.Request, inputA string, argsA []string, parametersA map[string]string, globalsA map[string]interface{}, optionsA ...string) (string, error)

func SHA1 

func SHA1(data []byte) []byte

SHA1 returns SHA-1 digest bytes for input data.

func SHA1PRNG 

func SHA1PRNG(seed []byte, size int) ([]byte, error)

SHA1PRNG derives pseudo-random bytes from seed using SHA-1.

func SetCfgString 

func SetCfgString(fileNameA string, strA string) string

func ToFloatQuick 

func ToFloatQuick(o Object) float64

func ToGoBool 

func ToGoBool(o Object) (v bool, ok bool)

ToGoBool will try to convert an Object to Go bool value.

func ToGoByteSlice 

func ToGoByteSlice(o Object) (v []byte, ok bool)

ToGoByteSlice will try to convert an Object to Go byte slice.

func ToGoFloat64 

func ToGoFloat64(o Object) (v float64, ok bool)

ToGoFloat64 will try to convert a numeric, bool or string Object to Go float64 value.

func ToGoInt 

func ToGoInt(o Object) (v int, ok bool)

ToGoInt will try to convert a numeric, bool or string Object to Go int value.

func ToGoInt64 

func ToGoInt64(o Object) (v int64, ok bool)

ToGoInt64 will try to convert a numeric, bool or string Object to Go int64 value.

func ToGoIntWithDefault 

func ToGoIntWithDefault(o Object, defaultA int) int

ToGoIntWithDefault converts an Object to Go int value with a default fallback. It returns the default value if the conversion fails. Supported types: Bool, Byte, Char, Int, Uint, Float, String, MutableString.

func ToGoRune 

func ToGoRune(o Object) (v rune, ok bool)

ToGoRune will try to convert a int like Object to Go rune value.

func ToGoString 

func ToGoString(o Object) (v string, ok bool)

ToGoString will try to convert an Object to Go string value.

func ToGoUint64 

func ToGoUint64(o Object) (v uint64, ok bool)

ToGoUint64 will try to convert a numeric, bool or string Object to Go uint64 value.

func ToIntQuick 

func ToIntQuick(o Object) int

func ToInterface 

func ToInterface(o Object) (ret interface{})

ToInterface tries to convert an Object o to an interface{} value.

Types

type Any 

type Any struct {
	ObjectImpl
	Value        interface{}
	OriginalType string
	OriginalCode int

	Members map[string]Object `json:"-"`
}

Any represents container object and implements the Object interfaces. Any is used to hold some data which is not an Object in Charlang, such as structured data from Golang function call Any wraps any Go value as a Charlang Object for interoperability. It stores the original value, type name, and type code for type preservation.

Type code: 999.

Key characteristics:

  • Wraps arbitrary Go values (interface{}) as Charlang objects
  • Preserves original type information via OriginalType and OriginalCode
  • Provides transparent access to wrapped value via "value" method
  • Supports member attachment via Members map
  • Used for FFI (Foreign Function Interface) and Go value bridging

func NewAny 

func NewAny(vA interface{}, argsA ...string) *Any

func (*Any) BinaryOp 

func (o *Any) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (*Any) Call 

func (*Any) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (*Any) CallMethod 

func (o *Any) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Any) CallName 

func (o *Any) CallName(nameA string, c Call) (Object, error)

func (*Any) CanCall 

func (*Any) CanCall() bool

CanCall implements Object interface.

func (*Any) CanIterate 

func (*Any) CanIterate() bool

CanIterate implements Object interface.

func (*Any) Copy 

func (o *Any) Copy() Object

Copy implements Copier interface.

func (*Any) Equal 

func (o *Any) Equal(right Object) bool

Equal implements Object interface.

func (*Any) GetMember 

func (o *Any) GetMember(idxA string) Object

func (*Any) GetValue 

func (o *Any) GetValue() Object

func (*Any) HasMemeber 

func (o *Any) HasMemeber() bool

func (*Any) IndexGet 

func (o *Any) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (*Any) IndexSet 

func (o *Any) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (*Any) IsFalsy 

func (o *Any) IsFalsy() bool

IsFalsy implements Object interface.

func (*Any) Iterate 

func (*Any) Iterate() Iterator

Iterate implements Object interface.

func (*Any) SetMember 

func (o *Any) SetMember(idxA string, valueA Object) error

func (*Any) SetValue 

func (o *Any) SetValue(valueA Object) error

func (*Any) String 

func (o *Any) String() string

String implements Object interface.

func (*Any) TypeCode 

func (o *Any) TypeCode() int

func (*Any) TypeName 

func (*Any) TypeName() string

TypeName implements Object interface.

type Array 

type Array []Object

Array represents array of objects and implements Object interface.

func ToArray 

func ToArray(o Object) (v Array, ok bool)

ToArray will try to convert an Object to Charlang array value.

func (Array) BinaryOp 

func (o Array) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (Array) Call 

func (Array) Call(...Object) (Object, error)

Call implements Object interface.

func (Array) CallMethod 

func (o Array) CallMethod(nameA string, argsA ...Object) (Object, error)

func (Array) CallName 

func (o Array) CallName(nameA string, c Call) (Object, error)

func (Array) CanCall 

func (Array) CanCall() bool

CanCall implements Object interface.

func (Array) CanIterate 

func (Array) CanIterate() bool

CanIterate implements Object interface.

func (Array) Copy 

func (o Array) Copy() Object

Copy implements Copier interface.

func (Array) Equal 

func (o Array) Equal(right Object) bool

Equal implements Object interface.

func (Array) GetMember 

func (o Array) GetMember(idxA string) Object

func (Array) GetValue 

func (o Array) GetValue() Object

func (Array) HasMemeber 

func (o Array) HasMemeber() bool

func (Array) IndexGet 

func (o Array) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (Array) IndexSet 

func (o Array) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (Array) IsFalsy 

func (o Array) IsFalsy() bool

IsFalsy implements Object interface.

func (Array) Iterate 

func (o Array) Iterate() Iterator

Iterate implements Iterable interface.

func (Array) Len 

func (o Array) Len() int

Len implements LengthGetter interface.

func (Array) SetMember 

func (o Array) SetMember(idxA string, valueA Object) error

func (Array) String 

func (o Array) String() string

String implements Object interface.

func (Array) TypeCode 

func (Array) TypeCode() int

func (Array) TypeName 

func (Array) TypeName() string

TypeName implements Object interface.

type ArrayIterator 

type ArrayIterator struct {
	V Array
	// contains filtered or unexported fields
}

ArrayIterator represents an iterator for the array.

func (*ArrayIterator) Key 

func (it *ArrayIterator) Key() Object

Key implements Iterator interface.

func (*ArrayIterator) Next 

func (it *ArrayIterator) Next() bool

Next implements Iterator interface.

func (*ArrayIterator) Value 

func (it *ArrayIterator) Value() Object

Value implements Iterator interface.

type BigFloat 

type BigFloat struct {
	Value *big.Float

	Members map[string]Object `json:"-"`
}

BigFloat represents large signed float values and implements Object interface. BigFloat wraps big.Float for arbitrary-precision floating-point arithmetic. It supports floating-point numbers with configurable precision.

Type code: 203.

Key characteristics:

  • Wraps Go's math/big.Float for arbitrary-precision floats
  • Supports configurable precision and rounding modes
  • Supports comparison with other BigFloat values
  • String() returns decimal representation
  • Supports member attachment via Members map

func (*BigFloat) BinaryOp 

func (o *BigFloat) BinaryOp(tok token.Token, right Object) (Object, error)

func (*BigFloat) Call 

func (o *BigFloat) Call(_ ...Object) (Object, error)

func (*BigFloat) CallMethod 

func (o *BigFloat) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*BigFloat) CanCall 

func (o *BigFloat) CanCall() bool

func (*BigFloat) CanIterate 

func (*BigFloat) CanIterate() bool

func (*BigFloat) Equal 

func (o *BigFloat) Equal(right Object) bool

func (*BigFloat) GetMember 

func (o *BigFloat) GetMember(idxA string) Object

func (*BigFloat) GetValue 

func (o *BigFloat) GetValue() Object

func (*BigFloat) HasMemeber 

func (o *BigFloat) HasMemeber() bool

func (*BigFloat) IndexGet 

func (o *BigFloat) IndexGet(index Object) (Object, error)

func (*BigFloat) IndexSet 

func (o *BigFloat) IndexSet(index, value Object) error

func (*BigFloat) IsFalsy 

func (o *BigFloat) IsFalsy() bool

func (*BigFloat) Iterate 

func (*BigFloat) Iterate() Iterator

func (*BigFloat) SetMember 

func (o *BigFloat) SetMember(idxA string, valueA Object) error

func (*BigFloat) SetValue 

func (o *BigFloat) SetValue(valueA Object) error

func (*BigFloat) String 

func (o *BigFloat) String() string

func (*BigFloat) TypeCode 

func (*BigFloat) TypeCode() int

func (*BigFloat) TypeName 

func (*BigFloat) TypeName() string

type BigInt 

type BigInt struct {
	Value *big.Int

	Members map[string]Object `json:"-"`
}

BigInt represents large signed integer values and implements Object interface. BigInt wraps big.Int for arbitrary-precision integer arithmetic. It supports integers of unlimited size, beyond Int's 64-bit limit.

Type code: 201.

Key characteristics:

  • Wraps Go's math/big.Int for arbitrary-precision integers
  • Supports all arithmetic operations without overflow
  • Supports comparison with other BigInt values
  • String() returns decimal representation
  • Supports member attachment via Members map

func (*BigInt) BinaryOp 

func (o *BigInt) BinaryOp(tok token.Token, right Object) (Object, error)

func (*BigInt) Call 

func (o *BigInt) Call(_ ...Object) (Object, error)

func (*BigInt) CallMethod 

func (o *BigInt) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*BigInt) CanCall 

func (o *BigInt) CanCall() bool

func (*BigInt) CanIterate 

func (*BigInt) CanIterate() bool

func (*BigInt) Equal 

func (o *BigInt) Equal(right Object) bool

func (*BigInt) GetMember 

func (o *BigInt) GetMember(idxA string) Object

func (*BigInt) GetValue 

func (o *BigInt) GetValue() Object

func (*BigInt) HasMemeber 

func (o *BigInt) HasMemeber() bool

func (*BigInt) IndexGet 

func (o *BigInt) IndexGet(index Object) (Object, error)

func (*BigInt) IndexSet 

func (o *BigInt) IndexSet(index, value Object) error

func (*BigInt) IsFalsy 

func (o *BigInt) IsFalsy() bool

func (*BigInt) Iterate 

func (*BigInt) Iterate() Iterator

func (*BigInt) SetMember 

func (o *BigInt) SetMember(idxA string, valueA Object) error

func (*BigInt) SetValue 

func (o *BigInt) SetValue(valueA Object) error

func (*BigInt) String 

func (o *BigInt) String() string

func (*BigInt) TypeCode 

func (*BigInt) TypeCode() int

func (*BigInt) TypeName 

func (*BigInt) TypeName() string

type Bool 

type Bool bool

Bool represents boolean values and implements Object interface.

func ToBool 

func ToBool(o Object) (v Bool, ok bool)

ToBool will try to convert an Object to Charlang bool value.

func (Bool) BinaryOp 

func (o Bool) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (Bool) BoolValue 

func (o Bool) BoolValue() bool

func (Bool) Call 

func (Bool) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (Bool) CallMethod 

func (o Bool) CallMethod(nameA string, argsA ...Object) (Object, error)

func (Bool) CanCall 

func (Bool) CanCall() bool

CanCall implements Object interface.

func (Bool) CanIterate 

func (Bool) CanIterate() bool

CanIterate implements Object interface.

func (Bool) Equal 

func (o Bool) Equal(right Object) bool

Equal implements Object interface.

func (Bool) Format 

func (o Bool) Format(s fmt.State, verb rune)

Format implements fmt.Formatter interface.

func (Bool) GetMember 

func (o Bool) GetMember(idxA string) Object

func (Bool) GetValue 

func (o Bool) GetValue() Object

func (Bool) HasMemeber 

func (o Bool) HasMemeber() bool

func (Bool) IndexGet 

func (o Bool) IndexGet(index Object) (value Object, err error)

IndexGet implements Object interface.

func (Bool) IndexSet 

func (Bool) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (Bool) IsFalsy 

func (o Bool) IsFalsy() bool

IsFalsy implements Object interface.

func (Bool) Iterate 

func (Bool) Iterate() Iterator

Iterate implements Object interface.

func (Bool) SetMember 

func (o Bool) SetMember(idxA string, valueA Object) error

func (Bool) String 

func (o Bool) String() string

String implements Object interface.

func (Bool) TypeCode 

func (Bool) TypeCode() int

func (Bool) TypeName 

func (Bool) TypeName() string

TypeName implements Object interface.

type BuiltinFunction 

type BuiltinFunction struct {
	ObjectImpl
	Name    string
	Value   func(args ...Object) (Object, error)
	ValueEx func(Call) (Object, error)

	Members map[string]Object `json:"-"`
	Methods map[string]*Function

	Remark string
}

BuiltinFunction represents a builtin function object and implements Object interface. BuiltinFunction represents a built-in function provided by the Charlang runtime. Examples include print, len, type, new, and other language primitives.

Type code: 183.

Key characteristics:

  • Implements ExCallerObject interface for extended call context
  • Value: simple function signature with variadic Object args
  • ValueEx: extended signature with full Call context access
  • Supports dynamic method generation for namespace functions
  • Methods cache stores dynamically created function objects
  • Remark field stores additional documentation/description
  • Supports member attachment via Members map

Usage: 

builtin := &BuiltinFunction{
    Name: "print",
    Value: func(args ...Object) (Object, error) {
        fmt.Println(args[0].String())
        return Undefined, nil
    },
}

func (*BuiltinFunction) BinaryOp 

func (*BuiltinFunction) BinaryOp(token.Token, Object) (Object, error)

func (*BuiltinFunction) Call 

func (o *BuiltinFunction) Call(args ...Object) (Object, error)

Call implements Object interface.

func (*BuiltinFunction) CallEx 

func (o *BuiltinFunction) CallEx(c Call) (Object, error)

func (*BuiltinFunction) CallMethod 

func (o *BuiltinFunction) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*BuiltinFunction) CanCall 

func (*BuiltinFunction) CanCall() bool

CanCall implements Object interface.

func (*BuiltinFunction) CanIterate 

func (o *BuiltinFunction) CanIterate() bool

func (*BuiltinFunction) Copy 

func (o *BuiltinFunction) Copy() Object

Copy implements Copier interface.

func (*BuiltinFunction) Equal 

func (o *BuiltinFunction) Equal(right Object) bool

Equal implements Object interface.

func (*BuiltinFunction) GetMember 

func (o *BuiltinFunction) GetMember(idxA string) Object

func (*BuiltinFunction) GetValue 

func (o *BuiltinFunction) GetValue() Object

func (*BuiltinFunction) HasMemeber 

func (o *BuiltinFunction) HasMemeber() bool

func (*BuiltinFunction) IndexGet 

func (o *BuiltinFunction) IndexGet(index Object) (Object, error)

func (*BuiltinFunction) IndexSet 

func (*BuiltinFunction) IndexSet(index, value Object) error

func (*BuiltinFunction) IsFalsy 

func (o *BuiltinFunction) IsFalsy() bool

IsFalsy implements Object interface.

func (*BuiltinFunction) Iterate 

func (o *BuiltinFunction) Iterate() Iterator

Iterate implements Iterable interface.

func (*BuiltinFunction) SetMember 

func (o *BuiltinFunction) SetMember(idxA string, valueA Object) error

func (*BuiltinFunction) String 

func (o *BuiltinFunction) String() string

String implements Object interface.

func (*BuiltinFunction) TypeCode 

func (*BuiltinFunction) TypeCode() int

func (*BuiltinFunction) TypeName 

func (*BuiltinFunction) TypeName() string

TypeName implements Object interface.

type BuiltinModule 

type BuiltinModule struct {
	Attrs map[string]Object
}

BuiltinModule is an importable module that's written in Go.

func (*BuiltinModule) Import 

func (m *BuiltinModule) Import(moduleName string) (interface{}, error)

Import returns an immutable map for the module.

type BuiltinType 

type BuiltinType int

BuiltinType represents a unique identifier for each built-in function. These constants are used as indices into BuiltinObjects array and keys in BuiltinsMap. 

const (
	BuiltinAppend BuiltinType = iota

	BuiltinReset
	BuiltinStatusToStr
	BuiltinStatusToMap
	BuiltinDocxToStrs
	BuiltinDocxReplacePattern
	BuiltinDocxGetPlaceholders
	BuiltinDeepClone
	BuiltinGetCfgStr
	BuiltinSetCfgStr
	BuiltinRemoveCfgStr
	BuiltinShowTable
	BuiltinGuiServerCommand
	BuiltinGetMapItem
	BuiltinSetMapItem
	BuiltinSendMail
	BuiltinGetTextSimilarity
	BuiltinFuzzyFind
	BuiltinStrRemoveBomHead
	BuiltinLeSshInfo
	BuiltinStack
	BuiltinQueue
	BuiltinMapArray
	BuiltinPlotClearConsole
	BuiltinPlotDataToStr
	BuiltinPlotDataToImage
	BuiltinPlotLoadFont
	BuiltinResizeImage
	BuiltinImageToAscii
	BuiltinLoadImageFromFile
	BuiltinSaveImageToFile
	BuiltinGetImageInfo
	BuiltinStrToRgba
	BuiltinEncodeImage
	BuiltinEncodeBytesInImage
	BuiltinDecodeBytesFromImage
	BuiltinDrawImageOnImage
	BuiltinDrawTextWrappedOnImage
	BuiltinAddWatermarkToImage
	BuiltinSetImageOpacity
	BuiltinGenQr
	BuiltinScanQr
	BuiltinSaveImageToBytes
	BuiltinClose
	BuiltinRegSplit
	BuiltinReadCsv
	BuiltinExcelNew
	BuiltinExcelOpen
	BuiltinExcelOpenFromBytes
	BuiltinExcelOpenFile
	BuiltinExcelSaveAs
	BuiltinExcelWriteTo
	BuiltinExcelWriteToBytes
	BuiltinExcelClose
	BuiltinExcelNewSheet
	BuiltinExcelRemoveSheet
	BuiltinExcelReadAll
	BuiltinExcelGetSheetCount
	BuiltinExcelGetSheetList
	BuiltinExcelGetSheetName
	BuiltinExcelReadSheet
	BuiltinExcelReadCell
	BuiltinExcelReadCellImages
	BuiltinExcelWriteSheet
	BuiltinExcelWriteCell
	BuiltinExcelGetColumnIndexByName
	BuiltinExcelGetColumnNameByIndex
	BuiltinWriteCsv
	BuiltinRemovePath
	BuiltinRemoveDir
	BuiltinGetInput
	BuiltinGetInputf
	BuiltinGetInputPasswordf
	BuiltinGetChar
	BuiltinGetMultiLineInput
	BuiltinSetStdin
	BuiltinSetStdout
	BuiltinSetStderr
	BuiltinGetPipe
	BuiltinRegCount
	BuiltinStrRepeat
	BuiltinRegMatch
	BuiltinRegContains
	BuiltinRegContainsIn
	BuiltinLePrint
	BuiltinLeFindLines
	BuiltinLeFind
	BuiltinLeFindAll
	BuiltinLeReplace
	BuiltinLeLoadFromSsh
	BuiltinLeSaveToSsh
	BuiltinLeRemoveLine
	BuiltinLeRemoveLines
	BuiltinLeInsertLine
	BuiltinLeAppendLine
	BuiltinLeGetLine
	BuiltinLeSetLine
	BuiltinLeSetLines
	BuiltinLeConvertToUtf8
	BuiltinLeSort
	BuiltinLeViewAll
	BuiltinLeViewLine
	BuiltinLeViewLines
	BuiltinLeLoadFromUrl
	BuiltinLeLoadFromClip
	BuiltinLeSaveToClip
	BuiltinLeAppendFromFile
	BuiltinLeAppendToFile
	BuiltinLeLoadFromFile
	BuiltinLeSaveToFile
	BuiltinLeLoadFromStr
	BuiltinLeSaveToStr
	BuiltinLeGetList
	BuiltinLeAppendFromStr
	BuiltinLeClear
	BuiltinLeInfo
	BuiltinS3GetObjectBytes
	BuiltinS3GetObjectText
	BuiltinS3PutObject
	BuiltinS3GetObjectToFile
	BuiltinS3GetObjectReader
	BuiltinS3GetObjectUrl
	BuiltinS3GetObjectTags
	BuiltinS3GetObjectStat
	BuiltinS3StatObject
	BuiltinS3CopyObject
	BuiltinS3MoveObject
	BuiltinS3RemoveObject
	BuiltinS3ListObjects
	BuiltinAwsSign
	BuiltinNow
	BuiltinTimeToTick
	BuiltinFormatTime
	BuiltinTimeAddSecs
	BuiltinTimeAddDate
	BuiltinTimeBefore
	BuiltinIsCronExprValid
	BuiltinRunTicker
	BuiltinIsCronExprDue
	BuiltinSplitCronExpr
	BuiltinResetTasker
	BuiltinRunTasker
	BuiltinStopTasker
	BuiltinAddSimpleTask
	BuiltinAddShellTask
	BuiltinGetNowTimeStamp
	BuiltinBase64Encode
	BuiltinBase64Decode
	BuiltinBase64EncodeByRawUrl
	BuiltinBase64DecodeByRawUrl
	BuiltinXmlGetNodeStr
	BuiltinStrXmlEncode
	BuiltinFromXml
	BuiltinFormatXml
	BuiltinMd5
	BuiltinPostRequest
	BuiltinPrepareMultiPartFieldFromBytes
	BuiltinPrepareMultiPartFileFromBytes
	BuiltinHttpRedirect
	BuiltinReader
	BuiltinWriter
	BuiltinFile
	BuiltinBytesBuffer
	BuiltinImage
	BuiltinLoadImageFromBytes
	BuiltinLoadImageFromUrl
	BuiltinThumbImage
	BuiltinBytesStartsWith
	BuiltinBytesEndsWith
	BuiltinBytesContains
	BuiltinBytesIndex
	BuiltinIsEncrypted
	BuiltinEncryptData
	BuiltinDecryptData
	BuiltinEncryptStream
	BuiltinDecryptStream
	BuiltinSimpleEncode
	BuiltinSimpleDecode
	BuiltinToPinYin
	BuiltinKanjiToKana
	BuiltinKanaToRomaji
	BuiltinKanjiToRomaji
	BuiltinIsHttps
	BuiltinCopyFile
	BuiltinRenameFile
	BuiltinStrJoin
	BuiltinStrCount
	BuiltinStrSub
	BuiltinStrPad
	BuiltinStrRuneLen
	BuiltinStrIn
	BuiltinStrGetLastComponent
	BuiltinEnsureMakeDirs
	BuiltinExtractFileDir
	BuiltinExtractFileName
	BuiltinCheckToken
	BuiltinGetOtpCode
	BuiltinCheckOtpCode
	BuiltinEncryptText
	BuiltinDecryptText
	BuiltinEncryptTextByTXTE
	BuiltinDecryptTextByTXTE
	BuiltinEncryptDataByTXDEE
	BuiltinDecryptDataByTXDEE
	BuiltinEncryptTextByTXDEE
	BuiltinDecryptTextByTXDEE
	BuiltinAesEncrypt
	BuiltinAesDecrypt
	BuiltinGetSha256WithKeyYY
	BuiltinRsaEncryptStrYY
	BuiltinHtmlEncode
	BuiltinHtmlDecode
	BuiltinServeFile
	BuiltinGetFileInfo
	BuiltinGetFileAbs
	BuiltinGetFileRel
	BuiltinGetFileExt
	BuiltinGetMimeType
	BuiltinStartSocksServer
	BuiltinStartSocksClient
	BuiltinStartTransparentProxy
	BuiltinStartTransparentProxyEx
	BuiltinRenderMarkdown
	BuiltinReplaceHtmlByMap
	BuiltinProcessHtmlTemplate
	BuiltinIsDir
	BuiltinStrStartsWith
	BuiltinStrEndsWith
	BuiltinStrSplit
	BuiltinStrSplitN
	BuiltinGenToken
	BuiltinGenJwtToken
	BuiltinParseJwtToken
	BuiltinStrContains
	BuiltinStrContainsAny
	BuiltinStrContainsIn
	BuiltinStrIndex
	BuiltinGetNowStr
	BuiltinGetNowStrCompact
	BuiltinLock
	BuiltinUnlock
	BuiltinTryLock
	BuiltinRLock
	BuiltinRUnlock
	BuiltinTryRLock
	BuiltinToKMG
	BuiltinIntToStr
	BuiltinFloatToStr
	BuiltinStrToUtf8
	BuiltinStrUtf8ToGb
	BuiltinBytesGbToUtf8Str
	BuiltinIsUtf8
	BuiltinSimpleStrToMap
	BuiltinSimpleStrToMapReverse
	BuiltinReverseMap
	BuiltinGetFileList
	BuiltinMathAbs
	BuiltinMathSqrt
	BuiltinMathPow
	BuiltinMathExp
	BuiltinMathLog
	BuiltinMathLog10
	BuiltinMathMin
	BuiltinMathMax
	BuiltinMathCeil
	BuiltinMathFloor
	BuiltinMathRound
	BuiltinMathPi
	BuiltinMathE
	BuiltinMathSin
	BuiltinMathCos
	BuiltinMathTan
	BuiltinMathAtan2
	BuiltinFlexEval
	BuiltinCalDistanceOfLatLon
	BuiltinCalDistanceOfLonLat
	BuiltinAdjustFloat
	BuiltinBigInt
	BuiltinBigFloat
	BuiltinToOrderedMap
	BuiltinUnhex
	BuiltinHexToStr
	BuiltinBitNot
	BuiltinToUpper
	BuiltinToLower
	BuiltinSscanf
	BuiltinStrQuote
	BuiltinStrUnquote
	BuiltinStrToInt
	BuiltinStrToTime
	BuiltinDealStr
	BuiltinToInt
	BuiltinToBool
	BuiltinToBoolWithDefault
	BuiltinToFloat
	BuiltinToHex
	BuiltinCompareBytes
	BuiltinCompareText
	BuiltinLoadBytes
	BuiltinLoadBytesFromFile
	BuiltinLoadBytesFromFileLimit
	BuiltinSaveBytes
	BuiltinOpenFile
	BuiltinCloseFile
	BuiltinCompressData
	BuiltinCompressStr
	BuiltinUncompressData
	BuiltinUncompressStr
	BuiltinUrlEncode
	BuiltinUrlEncode1
	BuiltinUrlDecode
	BuiltinOrderedMap
	BuiltinExcel
	BuiltinArrayContains
	BuiltinSortArray
	// BuiltinSortByFunc
	BuiltinShuffle
	BuiltinLimitStr
	BuiltinStrFindDiffPos
	BuiltinStrDiff
	BuiltinStrFindAllSub
	BuiltinRemoveItem
	BuiltinRemoveItems
	BuiltinAppendList
	BuiltinGetRandomInt
	BuiltinGetRandomFloat
	BuiltinGetRandomStr
	BuiltinFormatSQLValue
	BuiltinDbClose
	BuiltinDbQuery
	BuiltinDbQueryOrdered
	BuiltinDbQueryRecs
	BuiltinDbQueryMap
	BuiltinDbQueryMapArray
	BuiltinDbQueryCount
	BuiltinDbQueryFloat
	BuiltinDbQueryString
	BuiltinDbExec
	BuiltinRemoveFile
	BuiltinFileExists
	BuiltinGenJSONResp
	BuiltinUrlExists
	BuiltinParseUrl
	BuiltinParseQuery
	BuiltinErrStrf
	BuiltinErrf
	BuiltinErrToEmpty
	BuiltinCharCode
	BuiltinEvalMachine
	BuiltinJsVm
	//	BuiltinQjsVm
	BuiltinGel
	BuiltinDelegate
	BuiltinGetReqBody
	BuiltinGetReqHeader
	BuiltinGetReqHeaders
	BuiltinWriteRespHeader
	BuiltinSetRespHeader
	BuiltinParseReqForm
	BuiltinParseReqFormEx
	BuiltinWriteResp
	BuiltinMux
	BuiltinMutex
	BuiltinHttpHandler
	BuiltinHttpReq
	BuiltinWebSocket
	BuiltinFatalf
	BuiltinSeq
	BuiltinIsNil
	BuiltinIsNilOrEmpty
	BuiltinIsNilOrErr
	BuiltinGetValue
	BuiltinSetValue
	BuiltinGetMember
	BuiltinSetMember
	BuiltinCallMethod
	BuiltinDumpVar
	BuiltinDebugInfo
	BuiltinMake
	BuiltinDatabase
	BuiltinStatusResult
	BuiltinUnref
	BuiltinSetValueByRef
	BuiltinGetWeb
	BuiltinDownloadFile
	BuiltinGetWebBytes
	BuiltinGetWebBytesWithHeaders
	BuiltinGetWebRespBody
	BuiltinRegFindFirstGroups
	BuiltinReadAllStr
	BuiltinReadAllBytes
	BuiltinReadBytes
	BuiltinWriteStr
	BuiltinWriteBytes
	BuiltinWriteBytesAt
	BuiltinIoCopy
	BuiltinStrSplitLines
	BuiltinNew
	BuiltinStringBuilder
	BuiltinStrReplace
	BuiltinGetErrStrX
	BuiltinFtpList
	BuiltinFtpCreateDir
	BuiltinFtpSize
	BuiltinFtpUpload
	BuiltinFtpUploadFromReader
	BuiltinFtpDownloadBytes
	BuiltinFtpDownloadFile
	BuiltinFtpGetReader
	BuiltinFtpRemoveFile
	BuiltinSshUpload
	BuiltinSshUploadBytes
	BuiltinSshDownload
	BuiltinSshDownloadBytes
	BuiltinSshList
	BuiltinSshIfFileExists
	BuiltinSshGetFileInfo
	BuiltinSshRun
	BuiltinSshRename
	BuiltinSshJoinPath
	BuiltinSshRemoveFile
	BuiltinSshRemoveDir
	BuiltinSshEnsureMakeDirs
	BuiltinArchiveFilesToZip
	BuiltinGetFileListInArchive
	BuiltinGetFileListInArchiveBytes
	BuiltinGetFileListInZip
	BuiltinLoadBytesInArchive
	BuiltinLoadBytesInArchiveBytes
	BuiltinExtractFileInArchive
	BuiltinExtractArchive
	BuiltinIsFileNameUtf8InZipBytes
	BuiltinZipPath
	BuiltinZipPaths
	BuiltinAddPathsToZipFile
	BuiltinUnzipToPath
	BuiltinGetOSName
	BuiltinGetOSArch
	BuiltinGetOSArgs
	BuiltinGetAppDir
	BuiltinGetAppPath
	BuiltinGetCurDir
	BuiltinGetHomeDir
	BuiltinGetTempDir
	BuiltinCreateTempDir
	BuiltinCreateTempFile
	BuiltinChangeDir
	BuiltinLookPath
	BuiltinGetClipText
	BuiltinSetClipText
	BuiltinRegQuote
	BuiltinRegReplace
	BuiltinAny
	BuiltinTrim
	BuiltinTrimErr
	BuiltinStrTrim
	BuiltinStrTrimStart
	BuiltinStrTrimEnd
	BuiltinStrTrimLeft
	BuiltinStrTrimRight
	BuiltinRegFindFirst
	BuiltinRegFindAll
	BuiltinRegFindAllIndex
	BuiltinRegFindAllGroups
	BuiltinCheckErrX
	BuiltinCheckEmpty
	BuiltinLoadText
	BuiltinLoadLines
	BuiltinSaveText
	BuiltinAppendText
	BuiltinJoinPath
	BuiltinJoinUrlPath
	BuiltinGetSysInfo
	BuiltinGetEnv
	BuiltinSetEnv
	BuiltinTypeOfAny
	BuiltinToStr
	BuiltinCallNamedFunc
	BuiltinCallInternalFunc
	BuiltinGetProcessVar
	BuiltinSetProcessVar
	BuiltinDeleteProcessVar
	BuiltinGetNamedValue
	BuiltinNewEx
	BuiltinCallMethodEx
	BuiltinToTime
	// BuiltinNewAny
	BuiltinTime
	BuiltinSleep
	BuiltinExit
	BuiltinSystemCmd
	BuiltinSystemCmdDetached
	BuiltinSystemStart
	BuiltinIsErrX
	BuiltinIsErrStr
	BuiltinToJSON
	BuiltinFromJSON
	BuiltinFormatJson
	BuiltinCompactJson
	BuiltinGetJsonNodeStr
	BuiltinGetJsonNodeStrs
	BuiltinStrsToJson
	BuiltinEncodeSimpleMap
	BuiltinDecodeSimpleMap
	BuiltinPlo
	BuiltinPlt
	BuiltinPlErr
	BuiltinGetParam
	BuiltinGetParams
	BuiltinGetSwitch
	BuiltinGetSwitches
	BuiltinGetIntSwitch
	BuiltinIfSwitchExists
	BuiltinTypeCode
	BuiltinTypeName
	BuiltinPl
	BuiltinPr
	BuiltinPrf
	BuiltinFprf
	BuiltinPlNow
	BuiltinPln
	BuiltinPlv
	BuiltinSpr
	BuiltinSpt
	BuiltinSpln
	BuiltinTestByText
	BuiltinTestByStartsWith
	BuiltinTestByEndsWith
	BuiltinTestByContains
	BuiltinTestByRegContains
	//	BuiltinTestByFunc
	//	BuiltinTestByLineRules
	BuiltinTestByReg
	BuiltinGetSeq
	BuiltinMagic
	BuiltinGetUuid
	BuiltinPass

	BuiltinDelete
	BuiltinGetArrayItem
	BuiltinCopy
	BuiltinCopyBytes
	BuiltinRepeat
	BuiltinContains
	BuiltinLen
	BuiltinSort
	BuiltinSortReverse
	BuiltinError
	BuiltinBool
	BuiltinInt
	BuiltinUint
	BuiltinFloat
	BuiltinChar
	BuiltinByte
	BuiltinString
	BuiltinMutableString
	BuiltinBytes
	BuiltinBytesWithSize
	BuiltinBytesWithCap
	BuiltinChars
	BuiltinPrintf
	BuiltinPrintln
	BuiltinSprintf
	BuiltinGlobals

	BuiltinIsError
	BuiltinIsInt
	BuiltinIsUint
	BuiltinIsFloat
	BuiltinIsChar
	BuiltinIsByte
	BuiltinIsBool
	BuiltinIsString
	BuiltinIsBytes
	BuiltinIsChars
	BuiltinIsMap
	BuiltinIsSyncMap
	BuiltinIsArray
	BuiltinIsUndefined
	BuiltinIsFunction
	BuiltinIsCallable
	BuiltinIsIterable

	BuiltinWrongNumArgumentsError
	BuiltinInvalidOperatorError
	BuiltinIndexOutOfBoundsError
	BuiltinNotIterableError
	BuiltinNotIndexableError
	BuiltinNotIndexAssignableError
	BuiltinNotCallableError
	BuiltinNotImplementedError
	BuiltinZeroDivisionError
	BuiltinTypeError

	BuiltinMakeArray
	BuiltinCap
)

Builtin constants define all available built-in functions. Each constant corresponds to a built-in function implementation in BuiltinObjects.

type Byte 

type Byte byte

func ToByteObject 

func ToByteObject(argA interface{}, defaultA ...byte) Byte

func (Byte) BinaryOp 

func (o Byte) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (Byte) Call 

func (o Byte) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (Byte) CallMethod 

func (o Byte) CallMethod(nameA string, argsA ...Object) (Object, error)

func (Byte) CanCall 

func (o Byte) CanCall() bool

CanCall implements Object interface.

func (Byte) CanIterate 

func (Byte) CanIterate() bool

CanIterate implements Object interface.

func (Byte) Equal 

func (o Byte) Equal(right Object) bool

Equal implements Object interface.

func (Byte) Format 

func (o Byte) Format(s fmt.State, verb rune)

Format implements fmt.Formatter interface.

func (Byte) GetMember 

func (o Byte) GetMember(idxA string) Object

func (Byte) GetValue 

func (o Byte) GetValue() Object

func (Byte) HasMemeber 

func (o Byte) HasMemeber() bool

func (Byte) IndexGet 

func (o Byte) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (Byte) IndexSet 

func (Byte) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (Byte) IsFalsy 

func (o Byte) IsFalsy() bool

IsFalsy implements Object interface.

func (Byte) Iterate 

func (Byte) Iterate() Iterator

Iterate implements Object interface.

func (Byte) SetMember 

func (o Byte) SetMember(idxA string, valueA Object) error

func (Byte) String 

func (o Byte) String() string

String implements Object interface.

func (Byte) TypeCode 

func (Byte) TypeCode() int

func (Byte) TypeName 

func (Byte) TypeName() string

TypeName implements Object interface.

type Bytecode 

type Bytecode struct {
	FileSet          *parser.SourceFileSet
	Main             *CompiledFunction
	Constants        []Object
	NumModules       int
	CompilerOptionsM *CompilerOptions
}

Bytecode holds the compiled functions and constants.

func Compile 

func Compile(script []byte, opts *CompilerOptions) (*Bytecode, error)

Compile compiles given script to Bytecode.

func (*Bytecode) Fprint 

func (bc *Bytecode) Fprint(w io.Writer)

Fprint writes constants and instructions to given Writer in a human readable form.

func (*Bytecode) String 

func (bc *Bytecode) String() string

type Bytes 

type Bytes []byte

Bytes represents byte slice and implements Object interface.

func ToBytes 

func ToBytes(o Object) (v Bytes, ok bool)

ToBytes will try to convert an Object to Charlang bytes value.

func (Bytes) BinaryOp 

func (o Bytes) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (Bytes) Call 

func (o Bytes) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (Bytes) CallMethod 

func (o Bytes) CallMethod(nameA string, argsA ...Object) (Object, error)

func (Bytes) CanCall 

func (o Bytes) CanCall() bool

CanCall implements Object interface.

func (Bytes) CanIterate 

func (Bytes) CanIterate() bool

CanIterate implements Object interface.

func (Bytes) Copy 

func (o Bytes) Copy() Object

Copy implements Copier interface.

func (Bytes) Equal 

func (o Bytes) Equal(right Object) bool

Equal implements Object interface.

func (Bytes) Format 

func (o Bytes) Format(s fmt.State, verb rune)

Format implements fmt.Formatter interface.

func (Bytes) GetMember 

func (o Bytes) GetMember(idxA string) Object

func (Bytes) GetValue 

func (o Bytes) GetValue() Object

func (Bytes) HasMemeber 

func (o Bytes) HasMemeber() bool

func (Bytes) IndexGet 

func (o Bytes) IndexGet(index Object) (Object, error)

IndexGet represents string values and implements Object interface.

func (Bytes) IndexSet 

func (o Bytes) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (Bytes) IsFalsy 

func (o Bytes) IsFalsy() bool

IsFalsy implements Object interface.

func (Bytes) Iterate 

func (o Bytes) Iterate() Iterator

Iterate implements Object interface.

func (Bytes) Len 

func (o Bytes) Len() int

Len implements LengthGetter interface.

func (Bytes) SetMember 

func (o Bytes) SetMember(idxA string, valueA Object) error

func (Bytes) String 

func (o Bytes) String() string

func (Bytes) TypeCode 

func (Bytes) TypeCode() int

func (Bytes) TypeName 

func (Bytes) TypeName() string

TypeName implements Object interface.

type BytesBuffer 

type BytesBuffer struct {
	ObjectImpl
	Value *bytes.Buffer

	Members map[string]Object `json:"-"`
}

BytesBuffer wraps Go's bytes.Buffer for efficient byte manipulation. It provides a mutable buffer for reading and writing byte data.

Type code: 308.

Key characteristics:

  • Wraps Go's bytes.Buffer for efficient byte operations
  • Supports Write, Read, Reset, and Bytes operations via methods
  • Grows dynamically without reallocation (amortized O(1) append)
  • String() returns the buffer content as a string
  • Supports member attachment via Members map

func (*BytesBuffer) BinaryOp 

func (o *BytesBuffer) BinaryOp(tok token.Token, right Object) (Object, error)

func (*BytesBuffer) Call 

func (*BytesBuffer) Call(_ ...Object) (Object, error)

func (*BytesBuffer) CallMethod 

func (o *BytesBuffer) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*BytesBuffer) CanCall 

func (*BytesBuffer) CanCall() bool

func (*BytesBuffer) CanIterate 

func (*BytesBuffer) CanIterate() bool

func (*BytesBuffer) Copy 

func (o *BytesBuffer) Copy() Object

func (*BytesBuffer) Equal 

func (o *BytesBuffer) Equal(right Object) bool

func (*BytesBuffer) GetMember 

func (o *BytesBuffer) GetMember(idxA string) Object

func (*BytesBuffer) GetValue 

func (o *BytesBuffer) GetValue() Object

func (*BytesBuffer) HasMemeber 

func (o *BytesBuffer) HasMemeber() bool

func (*BytesBuffer) IndexGet 

func (o *BytesBuffer) IndexGet(index Object) (value Object, err error)

func (*BytesBuffer) IndexSet 

func (o *BytesBuffer) IndexSet(index, value Object) error

func (*BytesBuffer) IsFalsy 

func (o *BytesBuffer) IsFalsy() bool

func (*BytesBuffer) Iterate 

func (*BytesBuffer) Iterate() Iterator

func (*BytesBuffer) SetMember 

func (o *BytesBuffer) SetMember(idxA string, valueA Object) error

func (*BytesBuffer) String 

func (o *BytesBuffer) String() string

func (*BytesBuffer) TypeCode 

func (o *BytesBuffer) TypeCode() int

func (*BytesBuffer) TypeName 

func (o *BytesBuffer) TypeName() string

type BytesIterator 

type BytesIterator struct {
	V Bytes
	// contains filtered or unexported fields
}

BytesIterator represents an iterator for the bytes.

func (*BytesIterator) Key 

func (it *BytesIterator) Key() Object

Key implements Iterator interface.

func (*BytesIterator) Next 

func (it *BytesIterator) Next() bool

Next implements Iterator interface.

func (*BytesIterator) Value 

func (it *BytesIterator) Value() Object

Value implements Iterator interface.

type Call 

type Call struct {
	Vm    *VM
	This  Object
	Args  []Object
	Vargs []Object
}

Call is a struct to pass arguments to CallEx and CallName methods. It provides VM for various purposes.

Call struct intentionally does not provide access to normal and variadic arguments directly. Using Len() and Get() methods is preferred. It is safe to create Call with a nil VM as long as VM is not required by the callee. Call represents a function call context passed to functions implementing ExCallerObject. It provides access to the VM, 'this' context, arguments, and variadic arguments.

Key characteristics:

  • Passed to functions via ValueEx() method for extended call semantics
  • Supports method calls with 'This' binding for object-oriented patterns
  • Separates regular arguments (Args) from variadic arguments (Vargs)
  • Provides helper methods for argument access, validation, and manipulation

func NewCall 

func NewCall(vm *VM, args []Object, vargs ...Object) Call

NewCall creates a new Call struct with the given arguments.

func (*Call) CheckLen 

func (c *Call) CheckLen(n int) error

CheckLen checks the number of arguments and variadic arguments. If the number of arguments is not equal to n, it returns an error.

func (*Call) Get 

func (c *Call) Get(n int) Object

Get returns the nth argument. If n is greater than the number of arguments, it returns the nth variadic argument. If n is greater than the number of arguments and variadic arguments, it panics!

func (*Call) GetArgs 

func (c *Call) GetArgs() []Object

func (*Call) Len 

func (c *Call) Len() int

Len returns the number of arguments including variadic arguments.

func (*Call) VM 

func (c *Call) VM() *VM

VM returns the VM of the call.

type CallableExFunc 

type CallableExFunc = func(Call) (ret Object, err error)

CallableExFunc is a function signature for a callable function that accepts a Call struct.

type CallableFunc 

type CallableFunc = func(args ...Object) (ret Object, err error)

CallableFunc is a function signature for a callable function.

func CallExAdapter 

func CallExAdapter(fn CallableExFunc) CallableFunc

CallExAdapter converts a CallableExFunc into a CallableFunc.

type Char 

type Char rune

Char represents a rune and implements Object interface.

func ToChar 

func ToChar(o Object) (v Char, ok bool)

ToChar will try to convert an Object to Charlang char value.

func (Char) BinaryOp 

func (o Char) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (Char) Call 

func (o Char) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (Char) CallMethod 

func (o Char) CallMethod(nameA string, argsA ...Object) (Object, error)

func (Char) CanCall 

func (o Char) CanCall() bool

CanCall implements Object interface.

func (Char) CanIterate 

func (Char) CanIterate() bool

CanIterate implements Object interface.

func (Char) Equal 

func (o Char) Equal(right Object) bool

Equal implements Object interface.

func (Char) Format 

func (o Char) Format(s fmt.State, verb rune)

Format implements fmt.Formatter interface.

func (Char) GetMember 

func (o Char) GetMember(idxA string) Object

func (Char) GetValue 

func (o Char) GetValue() Object

func (Char) HasMemeber 

func (o Char) HasMemeber() bool

func (Char) IndexGet 

func (o Char) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (Char) IndexSet 

func (Char) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (Char) IsFalsy 

func (o Char) IsFalsy() bool

IsFalsy implements Object interface.

func (Char) Iterate 

func (Char) Iterate() Iterator

Iterate implements Object interface.

func (Char) SetMember 

func (o Char) SetMember(idxA string, valueA Object) error

func (Char) String 

func (o Char) String() string

String implements Object interface.

func (Char) TypeCode 

func (Char) TypeCode() int

func (Char) TypeName 

func (Char) TypeName() string

TypeName implements Object interface.

type CharCode 

type CharCode struct {
	ObjectImpl
	Source string
	Value  *Bytecode

	CompilerOptions *CompilerOptions

	LastError string

	Members map[string]Object `json:"-"`
}

CharCode object is used for represent thent io.Reader type value CharCode represents compiled Charlang bytecode ready for execution. It stores source code, compiled bytecode, compiler options, and error state.

Type code: 191.

Key characteristics:

  • Holds compiled Bytecode for VM execution
  • Source stores the original source code string
  • CompilerOptions control compilation behavior
  • LastError stores the most recent compilation error
  • Supports member attachment via Members map

func NewCharCode 

func NewCharCode(srcA string, optsA ...*CompilerOptions) *CharCode

func (*CharCode) BinaryOp 

func (o *CharCode) BinaryOp(tok token.Token, right Object) (Object, error)

func (*CharCode) Call 

func (o *CharCode) Call(argsA ...Object) (Object, error)

func (*CharCode) CallMethod 

func (o *CharCode) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*CharCode) CanCall 

func (o *CharCode) CanCall() bool

func (*CharCode) CanIterate 

func (*CharCode) CanIterate() bool

func (*CharCode) Equal 

func (o *CharCode) Equal(right Object) bool

func (*CharCode) GetMember 

func (o *CharCode) GetMember(idxA string) Object

func (*CharCode) GetValue 

func (o *CharCode) GetValue() Object

func (*CharCode) HasMemeber 

func (o *CharCode) HasMemeber() bool

func (*CharCode) IndexGet 

func (o *CharCode) IndexGet(index Object) (Object, error)

func (*CharCode) IndexSet 

func (o *CharCode) IndexSet(index, value Object) error

func (*CharCode) IsFalsy 

func (o *CharCode) IsFalsy() bool

func (*CharCode) Iterate 

func (o *CharCode) Iterate() Iterator

func (*CharCode) SetMember 

func (o *CharCode) SetMember(idxA string, valueA Object) error

func (*CharCode) String 

func (o *CharCode) String() string

func (*CharCode) TypeCode 

func (*CharCode) TypeCode() int

func (*CharCode) TypeName 

func (*CharCode) TypeName() string

TypeName implements Object interface.

type Chars 

type Chars []rune

Chars represents byte slice and implements Object interface.

func (Chars) BinaryOp 

func (o Chars) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (Chars) Call 

func (o Chars) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (Chars) CallMethod 

func (o Chars) CallMethod(nameA string, argsA ...Object) (Object, error)

func (Chars) CanCall 

func (o Chars) CanCall() bool

CanCall implements Object interface.

func (Chars) CanIterate 

func (Chars) CanIterate() bool

CanIterate implements Object interface.

func (Chars) Copy 

func (o Chars) Copy() Object

Copy implements Copier interface.

func (Chars) Equal 

func (o Chars) Equal(right Object) bool

Equal implements Object interface.

func (Chars) Format 

func (o Chars) Format(s fmt.State, verb rune)

Format implements fmt.Formatter interface.

func (Chars) GetMember 

func (o Chars) GetMember(idxA string) Object

func (Chars) GetValue 

func (o Chars) GetValue() Object

func (Chars) HasMemeber 

func (o Chars) HasMemeber() bool

func (Chars) IndexGet 

func (o Chars) IndexGet(index Object) (Object, error)

IndexGet represents string values and implements Object interface.

func (Chars) IndexSet 

func (o Chars) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (Chars) IsFalsy 

func (o Chars) IsFalsy() bool

IsFalsy implements Object interface.

func (Chars) Iterate 

func (o Chars) Iterate() Iterator

Iterate implements Object interface.

func (Chars) Len 

func (o Chars) Len() int

Len implements LengthGetter interface.

func (Chars) SetMember 

func (o Chars) SetMember(idxA string, valueA Object) error

func (Chars) String 

func (o Chars) String() string

func (Chars) TypeCode 

func (Chars) TypeCode() int

func (Chars) TypeName 

func (Chars) TypeName() string

TypeName implements Object interface.

type CharsIterator 

type CharsIterator struct {
	V Chars
	// contains filtered or unexported fields
}

CharsIterator represents an iterator for the chars.

func (*CharsIterator) Key 

func (it *CharsIterator) Key() Object

Key implements Iterator interface.

func (*CharsIterator) Next 

func (it *CharsIterator) Next() bool

Next implements Iterator interface.

func (*CharsIterator) Value 

func (it *CharsIterator) Value() Object

Value implements Iterator interface.

type CompiledFunction 

type CompiledFunction struct {
	// number of parameters
	NumParams int
	// number of local variabls including parameters NumLocals>=NumParams
	NumLocals    int
	Instructions []byte
	Variadic     bool
	Free         []*ObjectPtr
	// SourceMap holds the index of instruction and token's position.
	SourceMap map[int]int

	Members map[string]Object `json:"-"`
}

CompiledFunction holds the constants and instructions to pass VM. CompiledFunction represents a compiled Charlang function for VM execution. It contains bytecode instructions, parameter info, free variables, and source mapping.

Type code: 185.

Key characteristics:

  • Produced by the Charlang compiler from source code
  • NumParams: count of declared parameters
  • NumLocals: count of local variables (including parameters)
  • Instructions: bytecode for the VM to execute
  • Variadic: true if the function accepts variadic arguments
  • Free: captured variables for closure support
  • SourceMap: instruction index to source position mapping for debugging
  • Cannot be called directly; use an Invoker to execute

func (*CompiledFunction) BinaryOp 

func (*CompiledFunction) BinaryOp(token.Token, Object) (Object, error)

BinaryOp implements Object interface.

func (*CompiledFunction) Call 

func (*CompiledFunction) Call(...Object) (Object, error)

Call implements Object interface. CompiledFunction is not directly callable. You should use Invoker to call it with a Virtual Machine. Because of this, it always returns an error.

func (*CompiledFunction) CallMethod 

func (o *CompiledFunction) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*CompiledFunction) CanCall 

func (*CompiledFunction) CanCall() bool

CanCall implements Object interface.

func (*CompiledFunction) CanIterate 

func (*CompiledFunction) CanIterate() bool

CanIterate implements Object interface.

func (*CompiledFunction) Copy 

func (o *CompiledFunction) Copy() Object

Copy implements the Copier interface.

func (*CompiledFunction) Equal 

func (o *CompiledFunction) Equal(right Object) bool

Equal implements Object interface.

func (*CompiledFunction) Fprint 

func (o *CompiledFunction) Fprint(w io.Writer)

Fprint writes constants and instructions to given Writer in a human readable form.

func (*CompiledFunction) GetMember 

func (o *CompiledFunction) GetMember(idxA string) Object

func (*CompiledFunction) GetValue 

func (o *CompiledFunction) GetValue() Object

func (*CompiledFunction) HasMemeber 

func (o *CompiledFunction) HasMemeber() bool

func (*CompiledFunction) IndexGet 

func (o *CompiledFunction) IndexGet(index Object) (Object, error)

IndexGet represents string values and implements Object interface.

func (*CompiledFunction) IndexSet 

func (*CompiledFunction) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (*CompiledFunction) IsFalsy 

func (o *CompiledFunction) IsFalsy() bool

IsFalsy implements Object interface.

func (*CompiledFunction) Iterate 

func (*CompiledFunction) Iterate() Iterator

Iterate implements Object interface.

func (*CompiledFunction) SetMember 

func (o *CompiledFunction) SetMember(idxA string, valueA Object) error

func (*CompiledFunction) SourcePos 

func (o *CompiledFunction) SourcePos(ip int) parser.Pos

SourcePos returns the source position of the instruction at ip.

func (*CompiledFunction) String 

func (o *CompiledFunction) String() string

func (*CompiledFunction) TypeCode 

func (*CompiledFunction) TypeCode() int

func (*CompiledFunction) TypeName 

func (*CompiledFunction) TypeName() string

TypeName implements Object interface

type Compiler 

type Compiler struct {
	// contains filtered or unexported fields
}

Compiler compiles the AST into a bytecode.

func NewCompiler 

func NewCompiler(file *parser.SourceFile, opts CompilerOptions) *Compiler

NewCompiler creates a new Compiler object.

func (*Compiler) Bytecode 

func (c *Compiler) Bytecode() *Bytecode

Bytecode returns compiled Bytecode ready to run in VM.

func (*Compiler) Compile 

func (c *Compiler) Compile(node parser.Node) error

Compile compiles parser.Node and builds Bytecode.

func (*Compiler) SetGlobalSymbolsIndex 

func (c *Compiler) SetGlobalSymbolsIndex()

SetGlobalSymbolsIndex sets index of a global symbol. This is only required when a global symbol is defined in SymbolTable and provided to compiler. Otherwise, caller needs to append the constant to Constants, set the symbol index and provide it to the Compiler. This should be called before Compiler.Compile call.

type CompilerError 

type CompilerError struct {
	FileSet *parser.SourceFileSet
	Node    parser.Node
	Err     error
}

CompilerError represents a compiler error.

func (*CompilerError) Error 

func (e *CompilerError) Error() string

func (*CompilerError) Unwrap 

func (e *CompilerError) Unwrap() error

type CompilerOptions 

type CompilerOptions struct {
	ModuleMap         *ModuleMap
	ModulePath        string
	Constants         []Object
	SymbolTable       *SymbolTable
	Trace             io.Writer
	TraceParser       bool
	TraceCompiler     bool
	TraceOptimizer    bool
	OptimizerMaxCycle int
	OptimizeConst     bool
	OptimizeExpr      bool
	// contains filtered or unexported fields
}

CompilerOptions represents customizable options for Compile(). 

var MainCompilerOptions *CompilerOptions = nil

type Copier 

type Copier interface {
	Copy() Object
}

Copier wraps the Copy method to create a deep copy of the object.

type Database 

type Database struct {
	ObjectImpl
	Value           *sql.DB
	DBType          string
	DBConnectString string

	Members map[string]Object    `json:"-"`
	Methods map[string]*Function `json:"-"`
}

Database wraps sql.DB for database operations. It provides connectivity to SQL databases (MySQL, PostgreSQL, SQLite, etc.).

Type code: 309.

Key characteristics:

  • Wraps Go's sql.DB for database connectivity
  • Supports multiple database types via DBType field
  • DBConnectString stores the connection string
  • Provides methods for query, exec, and transaction operations
  • Methods cache stores dynamically generated function objects
  • Supports member attachment via Members map

func (*Database) BinaryOp 

func (o *Database) BinaryOp(tok token.Token, right Object) (Object, error)

func (*Database) Call 

func (*Database) Call(_ ...Object) (Object, error)

func (*Database) CallMethod 

func (o *Database) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Database) CanCall 

func (*Database) CanCall() bool

func (*Database) CanIterate 

func (*Database) CanIterate() bool

func (Database) Equal 

func (o Database) Equal(right Object) bool

func (*Database) GetMember 

func (o *Database) GetMember(idxA string) Object

func (*Database) GetValue 

func (o *Database) GetValue() Object

func (*Database) HasMemeber 

func (o *Database) HasMemeber() bool

func (*Database) IndexGet 

func (o *Database) IndexGet(index Object) (value Object, err error)

func (*Database) IndexSet 

func (o *Database) IndexSet(index, value Object) error

func (*Database) IsFalsy 

func (o *Database) IsFalsy() bool

func (*Database) Iterate 

func (*Database) Iterate() Iterator

func (*Database) SetMember 

func (o *Database) SetMember(idxA string, valueA Object) error

func (*Database) String 

func (o *Database) String() string

func (*Database) TypeCode 

func (o *Database) TypeCode() int

func (*Database) TypeName 

func (o *Database) TypeName() string

type Delegate 

type Delegate struct {
	// ObjectImpl
	Code  *CharCode
	Value tk.QuickVarDelegate

	Members map[string]Object `json:"-"`
}

Delegate represents an function caller and implements Object interface. Delegate wraps a callback delegate for deferred execution. It combines a CharCode with a delegate function for event handling patterns.

Type code: 601.

Key characteristics:

  • Combines CharCode with tk.QuickVarDelegate for callbacks
  • Used for deferred execution patterns (event handlers, async callbacks)
  • Code field stores the associated compiled code
  • Value field stores the actual delegate function
  • Supports member attachment via Members map

func (*Delegate) BinaryOp 

func (o *Delegate) BinaryOp(tok token.Token, right Object) (Object, error)

func (*Delegate) Call 

func (o *Delegate) Call(argsA ...Object) (Object, error)

func (*Delegate) CallMethod 

func (o *Delegate) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Delegate) CallName 

func (o *Delegate) CallName(nameA string, c Call) (Object, error)

func (*Delegate) CanCall 

func (o *Delegate) CanCall() bool

func (*Delegate) CanIterate 

func (*Delegate) CanIterate() bool

func (*Delegate) Equal 

func (o *Delegate) Equal(right Object) bool

func (*Delegate) GetMember 

func (o *Delegate) GetMember(idxA string) Object

func (*Delegate) GetValue 

func (o *Delegate) GetValue() Object

func (*Delegate) HasMemeber 

func (o *Delegate) HasMemeber() bool

func (*Delegate) IndexGet 

func (o *Delegate) IndexGet(index Object) (Object, error)

func (*Delegate) IndexSet 

func (o *Delegate) IndexSet(index, value Object) error

func (*Delegate) IsFalsy 

func (o *Delegate) IsFalsy() bool

func (*Delegate) Iterate 

func (*Delegate) Iterate() Iterator

func (*Delegate) SetMember 

func (o *Delegate) SetMember(idxA string, valueA Object) error

func (*Delegate) SetValue 

func (o *Delegate) SetValue(valueA Object) error

func (*Delegate) String 

func (o *Delegate) String() string

func (*Delegate) TypeCode 

func (*Delegate) TypeCode() int

func (*Delegate) TypeName 

func (*Delegate) TypeName() string

type Error 

type Error struct {
	Name    string
	Message string
	Cause   error

	Members map[string]Object `json:"-"`
}

Error represents Error Object and implements error and Object interfaces. Error represents a Charlang error object with name, message, and optional cause. It provides structured error handling with member support for additional context.

Type code: 155.

Key characteristics:

  • Implements Go's error interface for seamless integration
  • Supports error chaining via Cause field (Unwrap method)
  • Supports member attachment via Members map
  • Name field identifies the error type (e.g., "TypeError", "ValueError")
  • Message field contains the human-readable error description

func NewArgumentTypeError 

func NewArgumentTypeError(pos, expectType, foundType string) *Error

NewArgumentTypeError creates a new Error from ErrType.

func NewCommonError 

func NewCommonError(formatA string, argsA ...interface{}) *Error

func NewCommonErrorWithPos 

func NewCommonErrorWithPos(c Call, formatA string, argsA ...interface{}) *Error

func NewError 

func NewError(nameA string, formatA string, argsA ...interface{}) *Error

func NewFromError 

func NewFromError(errA error) *Error

func NewIndexTypeError 

func NewIndexTypeError(expectType, foundType string) *Error

NewIndexTypeError creates a new Error from ErrType.

func NewIndexValueTypeError 

func NewIndexValueTypeError(expectType, foundType string) *Error

NewIndexValueTypeError creates a new Error from ErrType.

func NewOperandTypeError 

func NewOperandTypeError(token, leftType, rightType string) *Error

NewOperandTypeError creates a new Error from ErrType.

func WrapError 

func WrapError(errA error) *Error

func (*Error) BinaryOp 

func (o *Error) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (*Error) Call 

func (*Error) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (*Error) CallMethod 

func (o *Error) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Error) CanCall 

func (*Error) CanCall() bool

CanCall implements Object interface.

func (*Error) CanIterate 

func (*Error) CanIterate() bool

CanIterate implements Object interface.

func (*Error) Copy 

func (o *Error) Copy() Object

Copy implements Copier interface.

func (*Error) Equal 

func (o *Error) Equal(right Object) bool

Equal implements Object interface.

func (*Error) Error 

func (o *Error) Error() string

Error implements error interface.

func (*Error) GetMember 

func (o *Error) GetMember(idxA string) Object

func (*Error) GetValue 

func (o *Error) GetValue() Object

func (*Error) HasMemeber 

func (o *Error) HasMemeber() bool

func (*Error) IndexGet 

func (o *Error) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (*Error) IndexSet 

func (o *Error) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (*Error) IsFalsy 

func (o *Error) IsFalsy() bool

IsFalsy implements Object interface.

func (*Error) Iterate 

func (*Error) Iterate() Iterator

Iterate implements Object interface.

func (*Error) NewError 

func (o *Error) NewError(messages ...string) *Error

NewError creates a new Error and sets original Error as its cause which can be unwrapped.

func (*Error) SetMember 

func (o *Error) SetMember(idxA string, valueA Object) error

func (*Error) String 

func (o *Error) String() string

String implements Object interface.

func (*Error) TypeCode 

func (*Error) TypeCode() int

func (*Error) TypeName 

func (*Error) TypeName() string

TypeName implements Object interface.

func (*Error) Unwrap 

func (o *Error) Unwrap() error

type Eval 

type Eval struct {
	Locals       []Object
	Globals      Object
	Opts         CompilerOptions
	VM           *VM
	ModulesCache []Object
}

Eval compiles and runs scripts within same scope. If executed script's return statement has no value to return or return is omitted, it returns last value on stack. Warning: Eval is not safe to use concurrently.

func NewEval 

func NewEval(opts CompilerOptions, globals Object, args ...Object) *Eval

NewEval returns new Eval object.

func NewEvalQuick 

func NewEvalQuick(globalsA map[string]interface{}, optsA *CompilerOptions, localsA ...Object) *Eval

func (*Eval) Run 

func (r *Eval) Run(ctx context.Context, script []byte) (Object, *Bytecode, error)

Run compiles, runs given script and returns last value on stack.

func (*Eval) RunByteCode 

func (r *Eval) RunByteCode(ctx context.Context, byteCodeA *Bytecode) (Object, error)

type EvalMachine 

type EvalMachine struct {
	Value *Eval

	Members map[string]Object `json:"-"`
}

EvalMachine represents an Charlang Virtual Machine could run script once or more EvalMachine wraps Eval for expression evaluation with variable context. It provides a calculator-like evaluation engine with variable storage.

Type code: 888.

Key characteristics:

  • Wraps Eval for mathematical and logical expression evaluation
  • Supports variable assignment and retrieval
  • Provides functions for parsing and evaluating expressions
  • Can be used for dynamic formula evaluation
  • Supports member attachment via Members map

func (*EvalMachine) BinaryOp 

func (o *EvalMachine) BinaryOp(tok token.Token, right Object) (Object, error)

func (*EvalMachine) Call 

func (o *EvalMachine) Call(_ ...Object) (Object, error)

func (*EvalMachine) CallMethod 

func (o *EvalMachine) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*EvalMachine) CallName 

func (o *EvalMachine) CallName(nameA string, c Call) (Object, error)

func (*EvalMachine) CanCall 

func (o *EvalMachine) CanCall() bool

func (*EvalMachine) CanIterate 

func (*EvalMachine) CanIterate() bool

func (*EvalMachine) Equal 

func (o *EvalMachine) Equal(right Object) bool

func (*EvalMachine) GetMember 

func (o *EvalMachine) GetMember(idxA string) Object

func (*EvalMachine) GetValue 

func (o *EvalMachine) GetValue() Object

func (*EvalMachine) HasMemeber 

func (o *EvalMachine) HasMemeber() bool

func (*EvalMachine) IndexGet 

func (o *EvalMachine) IndexGet(index Object) (Object, error)

func (*EvalMachine) IndexSet 

func (o *EvalMachine) IndexSet(index, value Object) error

func (*EvalMachine) IsFalsy 

func (o *EvalMachine) IsFalsy() bool

func (*EvalMachine) Iterate 

func (*EvalMachine) Iterate() Iterator

func (*EvalMachine) SetMember 

func (o *EvalMachine) SetMember(idxA string, valueA Object) error

func (*EvalMachine) SetValue 

func (o *EvalMachine) SetValue(valueA Object) error

func (*EvalMachine) String 

func (o *EvalMachine) String() string

func (*EvalMachine) TypeCode 

func (*EvalMachine) TypeCode() int

func (*EvalMachine) TypeName 

func (*EvalMachine) TypeName() string

type ExCallerObject 

type ExCallerObject interface {
	Object
	CallEx(c Call) (Object, error)
}

ExCallerObject is an interface for objects that can be called with CallEx method. It is an extended version of the Call method that can be used to call an object with a Call struct. Objects implementing this interface is called with CallEx method instead of Call method. Note that CanCall() should return true for objects implementing this interface.

type Excel 

type Excel struct {
	// ObjectImpl
	Value *excelize.File

	Members map[string]Object `json:"-"`
}

Excel represents an Excel(or compatible) file and implements Object interface. Excel wraps excelize.File for Excel spreadsheet operations. It provides reading, writing, and manipulation of .xlsx files.

Type code: 1003.

Key characteristics:

  • Wraps excelize.File for Excel file operations
  • Supports reading, writing, and modifying .xlsx files
  • Provides methods for cell access, formulas, charts, and styling
  • Can create new workbooks or open existing ones
  • Supports member attachment via Members map

func (*Excel) BinaryOp 

func (o *Excel) BinaryOp(tok token.Token, right Object) (Object, error)

func (*Excel) Call 

func (o *Excel) Call(argsA ...Object) (Object, error)

func (*Excel) CallMethod 

func (o *Excel) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Excel) CanCall 

func (o *Excel) CanCall() bool

func (*Excel) CanIterate 

func (*Excel) CanIterate() bool

func (*Excel) Equal 

func (o *Excel) Equal(right Object) bool

func (*Excel) GetMember 

func (o *Excel) GetMember(idxA string) Object

func (*Excel) GetValue 

func (o *Excel) GetValue() Object

func (*Excel) HasMemeber 

func (o *Excel) HasMemeber() bool

func (*Excel) IndexGet 

func (o *Excel) IndexGet(index Object) (Object, error)

func (*Excel) IndexSet 

func (o *Excel) IndexSet(index, value Object) error

func (*Excel) IsFalsy 

func (o *Excel) IsFalsy() bool

func (*Excel) Iterate 

func (*Excel) Iterate() Iterator

func (*Excel) SetMember 

func (o *Excel) SetMember(idxA string, valueA Object) error

func (*Excel) SetValue 

func (o *Excel) SetValue(valueA Object) error

func (*Excel) String 

func (o *Excel) String() string

func (*Excel) TypeCode 

func (*Excel) TypeCode() int

func (*Excel) TypeName 

func (*Excel) TypeName() string

type ExtImporter 

type ExtImporter interface {
	Importable
	// Get returns Extimporter instance which will import a module.
	Get(moduleName string) ExtImporter
	// Name returns the full name of the module e.g. absoule path of a file.
	// Import names are generally relative, this overwrites module name and used
	// as unique key for compiler module cache.
	Name() string
	// Fork returns an ExtImporter instance which will be used to import the
	// modules. Fork will get the result of Name() if it is not empty, otherwise
	// module name will be same with the Get call.
	Fork(moduleName string) ExtImporter
}

ExtImporter wraps methods for a module which will be imported dynamically like a file.

type File 

type File struct {
	ObjectImpl
	Value *os.File

	Members map[string]Object `json:"-"`
}

File object is used for represent os.File type value File wraps os.File for file system operations. It provides read, write, seek, and close operations on files.

Type code: 401.

Key characteristics:

  • Wraps Go's os.File for file I/O operations
  • Supports reading, writing, seeking, and closing
  • Can be used as Reader (via Read method) or Writer (via Write method)
  • Supports member attachment via Members map

func (*File) BinaryOp 

func (o *File) BinaryOp(tok token.Token, right Object) (Object, error)

func (*File) Call 

func (o *File) Call(_ ...Object) (Object, error)

func (*File) CallMethod 

func (o *File) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*File) CallName 

func (o *File) CallName(name string, c Call) (Object, error)

func (*File) CanCall 

func (o *File) CanCall() bool

func (*File) CanIterate 

func (*File) CanIterate() bool

func (*File) Close 

func (o *File) Close() error

comply to io.Closer

func (*File) Equal 

func (o *File) Equal(right Object) bool

func (*File) GetMember 

func (o *File) GetMember(idxA string) Object

func (*File) GetValue 

func (o *File) GetValue() Object

func (*File) HasMemeber 

func (o *File) HasMemeber() bool

func (*File) IndexGet 

func (o *File) IndexGet(index Object) (Object, error)

func (*File) IndexSet 

func (o *File) IndexSet(index, value Object) error

func (*File) IsFalsy 

func (o *File) IsFalsy() bool

func (*File) Iterate 

func (o *File) Iterate() Iterator

func (*File) Read 

func (o *File) Read(p []byte) (n int, err error)

comply to io.Reader

func (*File) SetMember 

func (o *File) SetMember(idxA string, valueA Object) error

func (*File) String 

func (o *File) String() string

func (*File) TypeCode 

func (*File) TypeCode() int

func (*File) TypeName 

func (*File) TypeName() string

TypeName implements Object interface.

func (*File) Write 

func (o *File) Write(p []byte) (n int, err error)

comply to io.Writer

type Float 

type Float float64

Float represents float values and implements Object interface.

func ToFloat 

func ToFloat(o Object) (v Float, ok bool)

ToFloat will try to convert an Object to Charlang float value.

func (Float) BinaryOp 

func (o Float) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (Float) Call 

func (o Float) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (Float) CallMethod 

func (o Float) CallMethod(nameA string, argsA ...Object) (Object, error)

func (Float) CanCall 

func (o Float) CanCall() bool

CanCall implements Object interface.

func (Float) CanIterate 

func (Float) CanIterate() bool

CanIterate implements Object interface.

func (Float) Equal 

func (o Float) Equal(right Object) bool

Equal implements Object interface.

func (Float) Format 

func (o Float) Format(s fmt.State, verb rune)

Format implements fmt.Formatter interface.

func (Float) GetMember 

func (o Float) GetMember(idxA string) Object

func (Float) GetValue 

func (o Float) GetValue() Object

func (Float) HasMemeber 

func (o Float) HasMemeber() bool

func (Float) IndexGet 

func (o Float) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (Float) IndexSet 

func (Float) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (Float) IsFalsy 

func (o Float) IsFalsy() bool

IsFalsy implements Object interface.

func (Float) Iterate 

func (Float) Iterate() Iterator

Iterate implements Object interface.

func (Float) SetMember 

func (o Float) SetMember(idxA string, valueA Object) error

func (Float) String 

func (o Float) String() string

String implements Object interface.

func (Float) TypeCode 

func (Float) TypeCode() int

func (Float) TypeName 

func (Float) TypeName() string

TypeName implements Object interface.

type Function 

type Function struct {
	ObjectImpl
	Name    string
	Value   func(args ...Object) (Object, error)
	ValueEx func(Call) (Object, error)

	Members map[string]Object `json:"-"`
}

Function represents a function object and implements Object interface. Function represents a user-defined or dynamically created function object. It encapsulates a Go function that receives Object arguments and returns an Object.

Type code: 181.

Key characteristics:

  • Implements ExCallerObject interface, supporting extended call context
  • Two call modes: Value (simple args) and ValueEx (full Call access)
  • ValueEx takes precedence if both Value and ValueEx are set
  • Supports member attachment via Members map
  • Name field identifies the function for debugging/error messages

Usage: 

fn := &Function{
    Name: "myFunc",
    Value: func(args ...Object) (Object, error) {
        return &Int{Value: 42}, nil
    },
}

func (*Function) BinaryOp 

func (*Function) BinaryOp(token.Token, Object) (Object, error)

func (*Function) Call 

func (o *Function) Call(args ...Object) (Object, error)

Call implements Object interface.

func (*Function) CallEx 

func (o *Function) CallEx(call Call) (Object, error)

func (*Function) CallMethod 

func (o *Function) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Function) CanCall 

func (*Function) CanCall() bool

CanCall implements Object interface.

func (*Function) CanIterate 

func (o *Function) CanIterate() bool

func (*Function) Copy 

func (o *Function) Copy() Object

Copy implements Copier interface.

func (*Function) Equal 

func (o *Function) Equal(right Object) bool

Equal implements Object interface.

func (*Function) GetMember 

func (o *Function) GetMember(idxA string) Object

func (*Function) GetValue 

func (o *Function) GetValue() Object

func (*Function) HasMemeber 

func (o *Function) HasMemeber() bool

func (*Function) IndexGet 

func (o *Function) IndexGet(index Object) (Object, error)

func (*Function) IndexSet 

func (*Function) IndexSet(index, value Object) error

func (*Function) IsFalsy 

func (o *Function) IsFalsy() bool

IsFalsy implements Object interface.

func (*Function) Iterate 

func (o *Function) Iterate() Iterator

Iterate implements Iterable interface.

func (*Function) SetMember 

func (o *Function) SetMember(idxA string, valueA Object) error

func (*Function) String 

func (o *Function) String() string

String implements Object interface.

func (*Function) TypeCode 

func (*Function) TypeCode() int

func (*Function) TypeName 

func (*Function) TypeName() string

TypeName implements Object interface.

type Gel 

type Gel struct {
	ObjectImpl
	// Source string
	Value *CharCode

	Members map[string]Object `json:"-"`
}

Gel object is like modules based on CharCode object Gel wraps CharCode for compiled code execution with VM. It provides a convenient interface for running compiled scripts.

Type code: 193.

Key characteristics:

  • Wraps CharCode for script execution
  • Provides Run methods for executing compiled code
  • Can be created from source code string
  • Supports member attachment via Members map

func (*Gel) BinaryOp 

func (o *Gel) BinaryOp(tok token.Token, right Object) (Object, error)

func (*Gel) Call 

func (o *Gel) Call(_ ...Object) (Object, error)

func (*Gel) CallMethod 

func (o *Gel) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Gel) CanCall 

func (o *Gel) CanCall() bool

func (*Gel) CanIterate 

func (*Gel) CanIterate() bool

func (*Gel) Equal 

func (o *Gel) Equal(right Object) bool

func (*Gel) GetMember 

func (o *Gel) GetMember(idxA string) Object

func (*Gel) GetValue 

func (o *Gel) GetValue() Object

func (*Gel) HasMemeber 

func (o *Gel) HasMemeber() bool

func (*Gel) IndexGet 

func (o *Gel) IndexGet(index Object) (Object, error)

func (*Gel) IndexSet 

func (o *Gel) IndexSet(index, value Object) error

func (*Gel) IsFalsy 

func (o *Gel) IsFalsy() bool

func (*Gel) Iterate 

func (o *Gel) Iterate() Iterator

func (*Gel) SetMember 

func (o *Gel) SetMember(idxA string, valueA Object) error

func (*Gel) String 

func (o *Gel) String() string

func (*Gel) TypeCode 

func (*Gel) TypeCode() int

func (*Gel) TypeName 

func (*Gel) TypeName() string

TypeName implements Object interface.

type GlobalContext 

type GlobalContext struct {
	SyncMap   tk.SyncMap
	SyncQueue tk.SyncQueue
	SyncStack tk.SyncStack

	SyncSeq tk.Seq

	Vars map[string]interface{}

	Regs []interface{}

	VerboseLevel int
}
var GlobalsG *GlobalContext

type HttpHandler 

type HttpHandler struct {
	// ObjectImpl
	Value func(http.ResponseWriter, *http.Request)

	Members map[string]Object `json:"-"`
}

HttpHandler object is used to represent the http response HttpHandler wraps an HTTP handler function for use with Mux routing. It encapsulates a function that handles HTTP requests.

Type code: 325.

Key characteristics:

  • Wraps http.HandlerFunc for HTTP request handling
  • Used with Mux.Handle() for route registration
  • Function signature: func(http.ResponseWriter, *http.Request)
  • Supports member attachment via Members map

func (*HttpHandler) BinaryOp 

func (o *HttpHandler) BinaryOp(tok token.Token, right Object) (Object, error)

func (*HttpHandler) Call 

func (o *HttpHandler) Call(_ ...Object) (Object, error)

func (*HttpHandler) CallMethod 

func (o *HttpHandler) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*HttpHandler) CanCall 

func (o *HttpHandler) CanCall() bool

func (*HttpHandler) CanIterate 

func (*HttpHandler) CanIterate() bool

func (*HttpHandler) Equal 

func (o *HttpHandler) Equal(right Object) bool

func (*HttpHandler) GetMember 

func (o *HttpHandler) GetMember(idxA string) Object

func (*HttpHandler) GetValue 

func (o *HttpHandler) GetValue() Object

func (*HttpHandler) HasMemeber 

func (o *HttpHandler) HasMemeber() bool

func (*HttpHandler) IndexGet 

func (o *HttpHandler) IndexGet(index Object) (Object, error)

func (*HttpHandler) IndexSet 

func (o *HttpHandler) IndexSet(index, value Object) error

func (*HttpHandler) IsFalsy 

func (o *HttpHandler) IsFalsy() bool

func (*HttpHandler) Iterate 

func (o *HttpHandler) Iterate() Iterator

func (*HttpHandler) SetMember 

func (o *HttpHandler) SetMember(idxA string, valueA Object) error

func (*HttpHandler) String 

func (o *HttpHandler) String() string

func (*HttpHandler) TypeCode 

func (*HttpHandler) TypeCode() int

func (*HttpHandler) TypeName 

func (*HttpHandler) TypeName() string

TypeName implements Object interface.

type HttpReq 

type HttpReq struct {
	ObjectImpl
	Value *http.Request

	Members map[string]Object `json:"-"`
}

HttpReq object is used to represent the http request HttpReq wraps http.Request for HTTP request handling. It provides access to request method, URL, headers, body, and parameters.

Type code: 321.

Key characteristics:

  • Wraps Go's http.Request for HTTP request data access
  • Provides methods for accessing query params, form data, headers
  • Supports body reading via io.Reader interface
  • Used in HTTP handler functions with HttpResp
  • Supports member attachment via Members map

func (*HttpReq) BinaryOp 

func (o *HttpReq) BinaryOp(tok token.Token, right Object) (Object, error)

func (*HttpReq) Call 

func (o *HttpReq) Call(_ ...Object) (Object, error)

func (*HttpReq) CallMethod 

func (o *HttpReq) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*HttpReq) CanCall 

func (o *HttpReq) CanCall() bool

func (*HttpReq) CanIterate 

func (*HttpReq) CanIterate() bool

func (*HttpReq) Equal 

func (o *HttpReq) Equal(right Object) bool

func (*HttpReq) GetMember 

func (o *HttpReq) GetMember(idxA string) Object

func (*HttpReq) GetValue 

func (o *HttpReq) GetValue() Object

func (*HttpReq) HasMemeber 

func (o *HttpReq) HasMemeber() bool

func (*HttpReq) IndexGet 

func (o *HttpReq) IndexGet(index Object) (Object, error)

func (*HttpReq) IndexSet 

func (o *HttpReq) IndexSet(index, value Object) error

func (*HttpReq) IsFalsy 

func (o *HttpReq) IsFalsy() bool

func (*HttpReq) Iterate 

func (o *HttpReq) Iterate() Iterator

func (*HttpReq) SetMember 

func (o *HttpReq) SetMember(idxA string, valueA Object) error

func (*HttpReq) String 

func (o *HttpReq) String() string

func (*HttpReq) TypeCode 

func (*HttpReq) TypeCode() int

func (*HttpReq) TypeName 

func (*HttpReq) TypeName() string

TypeName implements Object interface.

type HttpResp 

type HttpResp struct {
	ObjectImpl
	Value http.ResponseWriter

	Members map[string]Object `json:"-"`
}

HttpResp object is used to represent the http response HttpResp wraps http.ResponseWriter for HTTP response handling. It provides methods for writing response data, headers, and status codes.

Type code: 323.

Key characteristics:

  • Wraps Go's http.ResponseWriter for HTTP response writing
  • Implements io.Writer interface for direct writing
  • Provides methods for setting headers, status codes, and cookies
  • Used in HTTP handler functions with HttpReq
  • Supports member attachment via Members map

func (*HttpResp) BinaryOp 

func (o *HttpResp) BinaryOp(tok token.Token, right Object) (Object, error)

func (*HttpResp) Call 

func (o *HttpResp) Call(_ ...Object) (Object, error)

func (*HttpResp) CallMethod 

func (o *HttpResp) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*HttpResp) CanCall 

func (o *HttpResp) CanCall() bool

func (*HttpResp) CanIterate 

func (*HttpResp) CanIterate() bool

func (*HttpResp) Equal 

func (o *HttpResp) Equal(right Object) bool

func (*HttpResp) GetMember 

func (o *HttpResp) GetMember(idxA string) Object

func (*HttpResp) GetValue 

func (o *HttpResp) GetValue() Object

func (*HttpResp) HasMemeber 

func (o *HttpResp) HasMemeber() bool

func (*HttpResp) IndexGet 

func (o *HttpResp) IndexGet(index Object) (Object, error)

func (*HttpResp) IndexSet 

func (o *HttpResp) IndexSet(index, value Object) error

func (*HttpResp) IsFalsy 

func (o *HttpResp) IsFalsy() bool

func (*HttpResp) Iterate 

func (o *HttpResp) Iterate() Iterator

func (*HttpResp) SetMember 

func (o *HttpResp) SetMember(idxA string, valueA Object) error

func (*HttpResp) String 

func (o *HttpResp) String() string

func (*HttpResp) TypeCode 

func (*HttpResp) TypeCode() int

func (*HttpResp) TypeName 

func (*HttpResp) TypeName() string

TypeName implements Object interface.

func (*HttpResp) Write 

func (o *HttpResp) Write(p []byte) (n int, err error)

comply to io.Writer

type Image 

type Image struct {
	Value image.Image

	Members map[string]Object `json:"-"`
}

Image represents an image and implements Object interface. Image wraps image.Image for image processing operations. It provides access to pixel data, dimensions, and format information.

Type code: 501.

Key characteristics:

  • Wraps Go's image.Image for image data handling
  • Supports various image formats (PNG, JPEG, GIF, etc.)
  • Provides methods for accessing pixel data and dimensions
  • Can be created from file, bytes, or decoded data
  • Supports member attachment via Members map

func (*Image) BinaryOp 

func (o *Image) BinaryOp(tok token.Token, right Object) (Object, error)

func (*Image) Call 

func (o *Image) Call(_ ...Object) (Object, error)

func (*Image) CallMethod 

func (o *Image) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Image) CallName 

func (o *Image) CallName(nameA string, c Call) (Object, error)

func (*Image) CanCall 

func (o *Image) CanCall() bool

func (*Image) CanIterate 

func (*Image) CanIterate() bool

func (*Image) Equal 

func (o *Image) Equal(right Object) bool

func (*Image) GetMember 

func (o *Image) GetMember(idxA string) Object

func (*Image) GetValue 

func (o *Image) GetValue() Object

func (*Image) HasMemeber 

func (o *Image) HasMemeber() bool

func (*Image) IndexGet 

func (o *Image) IndexGet(index Object) (Object, error)

func (*Image) IndexSet 

func (o *Image) IndexSet(index, value Object) error

func (*Image) IsFalsy 

func (o *Image) IsFalsy() bool

func (*Image) Iterate 

func (*Image) Iterate() Iterator

func (*Image) SetMember 

func (o *Image) SetMember(idxA string, valueA Object) error

func (*Image) SetValue 

func (o *Image) SetValue(valueA Object) error

func (*Image) String 

func (o *Image) String() string

func (*Image) TypeCode 

func (*Image) TypeCode() int

func (*Image) TypeName 

func (*Image) TypeName() string

type Importable 

type Importable interface {
	// Import should return either an Object or module source code ([]byte).
	Import(moduleName string) (interface{}, error)
}

Importable interface represents importable module instance.

type IndexDeleter 

type IndexDeleter interface {
	IndexDelete(Object) error
}

IndexDeleter wraps the IndexDelete method to delete an index of an object.

type Int 

type Int int64

Int represents signed integer values and implements Object interface.

func ToInt 

func ToInt(o Object) (v Int, ok bool)

ToInt will try to convert an Object to Charlang int value.

func ToIntObject 

func ToIntObject(argA interface{}, defaultA ...int) Int

func (Int) BinaryOp 

func (o Int) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (Int) Call 

func (o Int) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (Int) CallMethod 

func (o Int) CallMethod(nameA string, argsA ...Object) (Object, error)

func (Int) CanCall 

func (o Int) CanCall() bool

CanCall implements Object interface.

func (Int) CanIterate 

func (Int) CanIterate() bool

CanIterate implements Object interface.

func (Int) Equal 

func (o Int) Equal(right Object) bool

Equal implements Object interface.

func (Int) Format 

func (o Int) Format(s fmt.State, verb rune)

Format implements fmt.Formatter interface.

func (Int) GetMember 

func (o Int) GetMember(idxA string) Object

func (Int) GetValue 

func (o Int) GetValue() Object

func (Int) HasMemeber 

func (o Int) HasMemeber() bool

func (Int) IndexGet 

func (o Int) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (Int) IndexSet 

func (Int) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (Int) IsFalsy 

func (o Int) IsFalsy() bool

IsFalsy implements Object interface.

func (Int) Iterate 

func (o Int) Iterate() Iterator

Iterate implements Object interface.

func (Int) SetMember 

func (o Int) SetMember(idxA string, valueA Object) error

func (Int) String 

func (o Int) String() string

String implements Object interface.

func (Int) TypeCode 

func (Int) TypeCode() int

func (Int) TypeName 

func (Int) TypeName() string

TypeName implements Object interface.

type IntIterator 

type IntIterator struct {
	V Int
	// contains filtered or unexported fields
}

IntIterator represents an iterator for the Int.

func (*IntIterator) Key 

func (it *IntIterator) Key() Object

Key implements Iterator interface.

func (*IntIterator) Next 

func (it *IntIterator) Next() bool

Next implements Iterator interface.

func (*IntIterator) Value 

func (it *IntIterator) Value() Object

Value implements Iterator interface.

type Invoker 

type Invoker struct {
	// contains filtered or unexported fields
}

Invoker invokes a given callee object (either a CompiledFunction or any other callable object) with the given arguments.

Invoker creates a new VM instance if the callee is a CompiledFunction, otherwise it runs the callee directly. Every Invoker call checks if the VM is aborted. If it is, it returns ErrVMAborted.

Invoker is not safe for concurrent use by multiple goroutines.

Acquire and Release methods are used to acquire and release a VM from the pool. So it is possible to reuse a VM instance for multiple Invoke calls. This is useful when you want to execute multiple functions in a single VM. For example, you can use Acquire and Release to execute multiple functions in a single VM instance. Note that you should call Release after Acquire, if you want to reuse the VM. If you don't want to use the pool, you can just call Invoke method. It is unsafe to hold a reference to the VM after Release is called. Using VM pool is about three times faster than creating a new VM for each Invoke call.

func NewInvoker 

func NewInvoker(vm *VM, callee Object) *Invoker

NewInvoker creates a new Invoker object.

func (*Invoker) Acquire 

func (inv *Invoker) Acquire()

Acquire acquires a VM from the pool.

func (*Invoker) Invoke 

func (inv *Invoker) Invoke(args ...Object) (Object, error)

Invoke invokes the callee object with the given arguments.

func (*Invoker) Release 

func (inv *Invoker) Release()

Release releases the VM back to the pool if it was acquired from the pool.

type Iterator 

type Iterator interface {
	// Next returns true if there are more elements to iterate.
	Next() bool

	// Key returns the key or index value of the current element.
	Key() Object

	// Value returns the value of the current element.
	Value() Object
}

Iterator wraps the methods required to iterate Objects in VM.

type JsVm 

type JsVm struct {
	Value *goja.Runtime

	Members map[string]Object `json:"-"`
}

JsVm represents an JavaScript Virtual Machine could run script once or more JsVm wraps goja.Runtime for JavaScript execution within Charlang. It provides a JavaScript VM for running JS code alongside Charlang.

Type code: 711.

Key characteristics:

  • Wraps goja.Runtime for JavaScript execution
  • Supports running JavaScript code from Charlang
  • Can exchange data between Charlang and JavaScript contexts
  • Provides methods for setting/getting JS variables and calling functions
  • Supports member attachment via Members map

func (*JsVm) BinaryOp 

func (o *JsVm) BinaryOp(tok token.Token, right Object) (Object, error)

func (*JsVm) Call 

func (o *JsVm) Call(_ ...Object) (Object, error)

func (*JsVm) CallMethod 

func (o *JsVm) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*JsVm) CallName 

func (o *JsVm) CallName(nameA string, c Call) (Object, error)

func (*JsVm) CanCall 

func (o *JsVm) CanCall() bool

func (*JsVm) CanIterate 

func (*JsVm) CanIterate() bool

func (*JsVm) Equal 

func (o *JsVm) Equal(right Object) bool

func (*JsVm) GetMember 

func (o *JsVm) GetMember(idxA string) Object

func (*JsVm) GetValue 

func (o *JsVm) GetValue() Object

func (*JsVm) HasMemeber 

func (o *JsVm) HasMemeber() bool

func (*JsVm) IndexGet 

func (o *JsVm) IndexGet(index Object) (Object, error)

func (*JsVm) IndexSet 

func (o *JsVm) IndexSet(index, value Object) error

func (*JsVm) IsFalsy 

func (o *JsVm) IsFalsy() bool

func (*JsVm) Iterate 

func (*JsVm) Iterate() Iterator

func (*JsVm) SetMember 

func (o *JsVm) SetMember(idxA string, valueA Object) error

func (*JsVm) SetValue 

func (o *JsVm) SetValue(valueA Object) error

func (*JsVm) String 

func (o *JsVm) String() string

func (*JsVm) TypeCode 

func (*JsVm) TypeCode() int

func (*JsVm) TypeName 

func (*JsVm) TypeName() string

type LengthGetter 

type LengthGetter interface {
	Len() int
}

LengthGetter wraps the Len method to get the number of elements of an object.

type Location 

type Location struct {
	ObjectImpl
	Value *time.Location

	Members map[string]Object `json:"-"`
}

Location represents a timezone location for time operations. It wraps Go's time.Location and is used with Time objects for timezone conversions.

Type code: 313.

Key characteristics:

  • Wraps Go's time.Location for timezone handling
  • Loaded by IANA timezone identifiers (e.g., "UTC", "America/New_York")
  • Used with Time objects for timezone-aware operations
  • Supports member attachment via Members map

func ToLocation 

func ToLocation(o Object) (ret *Location, ok bool)

ToLocation will try to convert given Object to *Location value.

func (*Location) CallMethod 

func (o *Location) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Location) Equal 

func (o *Location) Equal(right Object) bool

Equal implements Object interface.

func (*Location) GetMember 

func (o *Location) GetMember(idxA string) Object

func (*Location) GetValue 

func (o *Location) GetValue() Object

func (*Location) HasMemeber 

func (o *Location) HasMemeber() bool

func (*Location) IsFalsy 

func (o *Location) IsFalsy() bool

IsFalsy implements Object interface.

func (*Location) SetMember 

func (o *Location) SetMember(idxA string, valueA Object) error

func (*Location) String 

func (o *Location) String() string

String implements Object interface.

func (*Location) TypeCode 

func (*Location) TypeCode() int

func (*Location) TypeName 

func (*Location) TypeName() string

TypeName implements Object interface.

type Map 

type Map map[string]Object

Map represents map of objects and implements Object interface.

func NewBaseEnv 

func NewBaseEnv(varsA map[string]interface{}, additionsA ...Object) *Map

func ToMap 

func ToMap(o Object) (v Map, ok bool)

ToMap will try to convert an Object to Charlang map value.

func (Map) BinaryOp 

func (o Map) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (Map) Call 

func (Map) Call(...Object) (Object, error)

Call implements Object interface.

func (Map) CallMethod 

func (o Map) CallMethod(nameA string, argsA ...Object) (Object, error)

func (Map) CallName 

func (o Map) CallName(nameA string, c Call) (Object, error)

func (Map) CanCall 

func (Map) CanCall() bool

CanCall implements Object interface.

func (Map) CanIterate 

func (Map) CanIterate() bool

CanIterate implements Object interface.

func (Map) Copy 

func (o Map) Copy() Object

Copy implements Copier interface.

func (Map) Equal 

func (o Map) Equal(right Object) bool

Equal implements Object interface.

func (Map) GetMember 

func (o Map) GetMember(idxA string) Object

func (Map) GetValue 

func (o Map) GetValue() Object

func (Map) HasMemeber 

func (o Map) HasMemeber() bool

func (Map) IndexDelete 

func (o Map) IndexDelete(key Object) error

IndexDelete tries to delete the string value of key from the map. IndexDelete implements IndexDeleter interface.

func (Map) IndexGet 

func (o Map) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (Map) IndexSet 

func (o Map) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (Map) IsFalsy 

func (o Map) IsFalsy() bool

IsFalsy implements Object interface.

func (Map) Iterate 

func (o Map) Iterate() Iterator

Iterate implements Iterable interface.

func (Map) Len 

func (o Map) Len() int

Len implements LengthGetter interface.

func (Map) SetMember 

func (o Map) SetMember(idxA string, valueA Object) error

func (Map) String 

func (o Map) String() string

String implements Object interface.

func (Map) TypeCode 

func (Map) TypeCode() int

func (Map) TypeName 

func (Map) TypeName() string

TypeName implements Object interface.

type MapArray 

type MapArray struct {
	Value *tk.SimpleFlexObject
}

MapArray represents an SimpleFlexObject which is an array with some items have keys MapArray wraps tk.SimpleFlexObject for hybrid map-array storage. It combines the features of both map and array for flexible data access.

Type code: 136.

Key characteristics:

  • Wraps tk.SimpleFlexObject for hybrid map/array operations
  • Supports both indexed (array-like) and keyed (map-like) access
  • Provides flexible data structure for dynamic content
  • Useful for JSON-like data with mixed access patterns

func (*MapArray) BinaryOp 

func (o *MapArray) BinaryOp(tok token.Token, right Object) (Object, error)

func (*MapArray) Call 

func (o *MapArray) Call(_ ...Object) (Object, error)

func (*MapArray) CallMethod 

func (o *MapArray) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*MapArray) CallName 

func (o *MapArray) CallName(nameA string, c Call) (Object, error)

func (*MapArray) CanCall 

func (o *MapArray) CanCall() bool

func (*MapArray) CanIterate 

func (*MapArray) CanIterate() bool

func (*MapArray) Equal 

func (o *MapArray) Equal(right Object) bool

func (*MapArray) GetMember 

func (o *MapArray) GetMember(idxA string) Object

func (*MapArray) GetValue 

func (o *MapArray) GetValue() Object

func (*MapArray) HasMemeber 

func (o *MapArray) HasMemeber() bool

func (*MapArray) IndexGet 

func (o *MapArray) IndexGet(index Object) (Object, error)

func (*MapArray) IndexSet 

func (o *MapArray) IndexSet(index, value Object) error

func (*MapArray) IsFalsy 

func (o *MapArray) IsFalsy() bool

func (*MapArray) Iterate 

func (o *MapArray) Iterate() Iterator

func (*MapArray) Len 

func (o *MapArray) Len() int

Len implements LengthGetter interface.

func (*MapArray) SetMember 

func (o *MapArray) SetMember(idxA string, valueA Object) error

func (*MapArray) SetValue 

func (o *MapArray) SetValue(valueA Object) error

func (*MapArray) String 

func (o *MapArray) String() string

func (*MapArray) TypeCode 

func (*MapArray) TypeCode() int

func (*MapArray) TypeName 

func (*MapArray) TypeName() string

type MapArrayIterator 

type MapArrayIterator struct {
	V *MapArray
	// contains filtered or unexported fields
}

MapArrayIterator represents an iterator for the array.

func (*MapArrayIterator) Key 

func (it *MapArrayIterator) Key() Object

Key implements Iterator interface.

func (*MapArrayIterator) Next 

func (it *MapArrayIterator) Next() bool

Next implements Iterator interface.

func (*MapArrayIterator) Value 

func (it *MapArrayIterator) Value() Object

Value implements Iterator interface.

type MapIterator 

type MapIterator struct {
	V Map
	// contains filtered or unexported fields
}

MapIterator represents an iterator for the map.

func (*MapIterator) Key 

func (it *MapIterator) Key() Object

Key implements Iterator interface.

func (*MapIterator) Next 

func (it *MapIterator) Next() bool

Next implements Iterator interface.

func (*MapIterator) Value 

func (it *MapIterator) Value() Object

Value implements Iterator interface.

type ModuleMap 

type ModuleMap struct {
	// contains filtered or unexported fields
}

ModuleMap represents a set of named modules. Use NewModuleMap to create a new module map.

func NewModuleMap 

func NewModuleMap() *ModuleMap

NewModuleMap creates a new module map.

func (*ModuleMap) Add 

func (m *ModuleMap) Add(name string, module Importable) *ModuleMap

Add adds an importable module.

func (*ModuleMap) AddBuiltinModule 

func (m *ModuleMap) AddBuiltinModule(
	name string,
	attrs map[string]Object,
) *ModuleMap

AddBuiltinModule adds a builtin module.

func (*ModuleMap) AddSourceModule 

func (m *ModuleMap) AddSourceModule(name string, src []byte) *ModuleMap

AddSourceModule adds a source module.

func (*ModuleMap) Copy 

func (m *ModuleMap) Copy() *ModuleMap

Copy creates a copy of the module map.

func (*ModuleMap) Fork 

func (m *ModuleMap) Fork(moduleName string) *ModuleMap

Fork creates a new ModuleMap instance if ModuleMap has an ExtImporter to make ExtImporter preseve state.

func (*ModuleMap) Get 

func (m *ModuleMap) Get(name string) Importable

Get returns an import module identified by name. It returns nil if the name is not found.

func (*ModuleMap) Remove 

func (m *ModuleMap) Remove(name string)

Remove removes a named module.

func (*ModuleMap) SetExtImporter 

func (m *ModuleMap) SetExtImporter(im ExtImporter) *ModuleMap

SetExtImporter sets an ExtImporter to ModuleMap, which will be used to import modules dynamically.

type MutableString 

type MutableString struct {
	ObjectImpl
	Value string

	Members map[string]Object `json:"-"`
}

MutableString represents string values and implements Object interface, compare to String, it supports setValue method. MutableString represents a mutable string that can be modified in place. Unlike String (immutable), MutableString allows character-level modification.

Type code: 106.

Key characteristics:

  • Mutable counterpart to the immutable String type
  • Supports index-based read and write of characters
  • Implements LengthGetter and ValueSetter interfaces
  • String() returns the current string value
  • Supports member attachment via Members map

func ToMutableStringObject 

func ToMutableStringObject(argA interface{}) *MutableString

func (*MutableString) BinaryOp 

func (o *MutableString) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (*MutableString) Call 

func (o *MutableString) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (*MutableString) CallMethod 

func (o *MutableString) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*MutableString) CallName 

func (o *MutableString) CallName(nameA string, c Call) (Object, error)

func (*MutableString) CanCall 

func (o *MutableString) CanCall() bool

CanCall implements Object interface.

func (*MutableString) CanIterate 

func (*MutableString) CanIterate() bool

CanIterate implements Object interface.

func (*MutableString) Copy 

func (o *MutableString) Copy() Object

func (*MutableString) Equal 

func (o *MutableString) Equal(right Object) bool

Equal implements Object interface.

func (*MutableString) Format 

func (o *MutableString) Format(s fmt.State, verb rune)

Format implements fmt.Formatter interface.

func (*MutableString) GetMember 

func (o *MutableString) GetMember(idxA string) Object

func (*MutableString) GetValue 

func (o *MutableString) GetValue() Object

func (*MutableString) HasMemeber 

func (o *MutableString) HasMemeber() bool

func (*MutableString) IndexGet 

func (o *MutableString) IndexGet(index Object) (Object, error)

IndexGet represents string values and implements Object interface.

func (*MutableString) IndexSet 

func (o *MutableString) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (*MutableString) IsFalsy 

func (o *MutableString) IsFalsy() bool

IsFalsy implements Object interface.

func (*MutableString) Iterate 

func (o *MutableString) Iterate() Iterator

Iterate implements Object interface.

func (*MutableString) Len 

func (o *MutableString) Len() int

Len implements LengthGetter interface.

func (*MutableString) MarshalJSON 

func (o *MutableString) MarshalJSON() ([]byte, error)

func (*MutableString) SetMember 

func (o *MutableString) SetMember(idxA string, valueA Object) error

func (*MutableString) SetValue 

func (o *MutableString) SetValue(valueA Object) error

func (*MutableString) String 

func (o *MutableString) String() string

func (*MutableString) TypeCode 

func (*MutableString) TypeCode() int

func (*MutableString) TypeName 

func (*MutableString) TypeName() string

TypeName implements Object interface.

type MutableStringIterator 

type MutableStringIterator struct {
	V *MutableString
	// contains filtered or unexported fields
}

MutableStringIterator represents an iterator for the string.

func (*MutableStringIterator) Key 

func (it *MutableStringIterator) Key() Object

Key implements Iterator interface.

func (*MutableStringIterator) Next 

func (it *MutableStringIterator) Next() bool

Next implements Iterator interface.

func (*MutableStringIterator) Value 

func (it *MutableStringIterator) Value() Object

Value implements Iterator interface.

type Mutex 

type Mutex struct {
	ObjectImpl
	Value *(sync.RWMutex)

	Members map[string]Object `json:"-"`
}

Mutex object is used for thread-safe actions note that the members set/get operations are not thread-safe Mutex wraps sync.RWMutex for thread-safe mutual exclusion. It provides Lock, Unlock, RLock, RUnlock operations for concurrency control.

Type code: 317.

Key characteristics:

  • Wraps Go's sync.RWMutex for reader-writer locking
  • Supports exclusive (Lock/Unlock) and shared (RLock/RUnlock) access
  • Essential for protecting shared resources in concurrent code
  • Supports member attachment via Members map

func NewMutex 

func NewMutex(argsA ...Object) *Mutex

func (*Mutex) BinaryOp 

func (o *Mutex) BinaryOp(tok token.Token, right Object) (Object, error)

func (*Mutex) Call 

func (o *Mutex) Call(_ ...Object) (Object, error)

func (*Mutex) CallMethod 

func (o *Mutex) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Mutex) CanCall 

func (o *Mutex) CanCall() bool

func (*Mutex) CanIterate 

func (*Mutex) CanIterate() bool

func (*Mutex) Equal 

func (o *Mutex) Equal(right Object) bool

func (*Mutex) GetMember 

func (o *Mutex) GetMember(idxA string) Object

func (*Mutex) GetValue 

func (o *Mutex) GetValue() Object

func (*Mutex) HasMemeber 

func (o *Mutex) HasMemeber() bool

func (*Mutex) IndexGet 

func (o *Mutex) IndexGet(index Object) (Object, error)

func (*Mutex) IndexSet 

func (o *Mutex) IndexSet(index, value Object) error

func (*Mutex) IsFalsy 

func (o *Mutex) IsFalsy() bool

func (*Mutex) Iterate 

func (o *Mutex) Iterate() Iterator

func (*Mutex) SetMember 

func (o *Mutex) SetMember(idxA string, valueA Object) error

func (*Mutex) String 

func (o *Mutex) String() string

func (*Mutex) TypeCode 

func (*Mutex) TypeCode() int

func (*Mutex) TypeName 

func (*Mutex) TypeName() string

TypeName implements Object interface.

type Mux 

type Mux struct {
	ObjectImpl
	Value *http.ServeMux

	Members map[string]Object `json:"-"`
}

Mux object is used for http handlers Mux wraps http.ServeMux for HTTP request routing. It provides pattern-based routing for HTTP server handlers.

Type code: 319.

Key characteristics:

  • Wraps Go's http.ServeMux for HTTP routing
  • Supports Handle and HandleFunc methods for route registration
  • Used with HttpHandler and HttpServer for HTTP services
  • Supports member attachment via Members map

func NewMux 

func NewMux(argsA ...Object) *Mux

func (*Mux) BinaryOp 

func (o *Mux) BinaryOp(tok token.Token, right Object) (Object, error)

func (*Mux) Call 

func (o *Mux) Call(_ ...Object) (Object, error)

func (*Mux) CallMethod 

func (o *Mux) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Mux) CanCall 

func (o *Mux) CanCall() bool

func (*Mux) CanIterate 

func (*Mux) CanIterate() bool

func (*Mux) Equal 

func (o *Mux) Equal(right Object) bool

func (*Mux) GetMember 

func (o *Mux) GetMember(idxA string) Object

func (*Mux) GetValue 

func (o *Mux) GetValue() Object

func (*Mux) HasMemeber 

func (o *Mux) HasMemeber() bool

func (*Mux) IndexGet 

func (o *Mux) IndexGet(index Object) (Object, error)

func (*Mux) IndexSet 

func (o *Mux) IndexSet(index, value Object) error

func (*Mux) IsFalsy 

func (o *Mux) IsFalsy() bool

func (*Mux) Iterate 

func (o *Mux) Iterate() Iterator

func (*Mux) SetMember 

func (o *Mux) SetMember(idxA string, valueA Object) error

func (*Mux) String 

func (o *Mux) String() string

func (*Mux) TypeCode 

func (*Mux) TypeCode() int

func (*Mux) TypeName 

func (*Mux) TypeName() string

TypeName implements Object interface.

type NameCallerObject 

type NameCallerObject interface {
	Object
	CallName(name string, c Call) (Object, error)
}

NameCallerObject is an interface for objects that can be called with CallName method to call a method of an object. Objects implementing this interface can reduce allocations by not creating a callable object for each method call.

type Object 

type Object interface {
	// TypeName should return the name of the type.
	TypeName() string

	// TypeCode should return the code of the type.
	TypeCode() int

	// String should return a string of the type's value.
	String() string

	// BinaryOp handles +,-,*,/,%,<<,>>,<=,>=,<,> operators.
	// Returned error stops VM execution if not handled with an error handler
	// and VM.Run returns the same error as wrapped.
	BinaryOp(tok token.Token, right Object) (Object, error)

	// IsFalsy returns true if value is falsy otherwise false.
	IsFalsy() bool

	// Equal checks equality of objects.
	Equal(right Object) bool

	// Call is called from VM if CanCall() returns true. Check the number of
	// arguments provided and their types in the method. Returned error stops VM
	// execution if not handled with an error handler and VM.Run returns the
	// same error as wrapped.
	Call(args ...Object) (Object, error)

	// CanCall returns true if type can be called with Call() method.
	// VM returns an error if one tries to call a noncallable object.
	CanCall() bool

	// Iterate should return an Iterator for the type.
	Iterate() Iterator

	// CanIterate should return whether the Object can be Iterated.
	CanIterate() bool

	// IndexGet should take an index Object and return a result Object or an
	// error for indexable objects. Indexable is an object that can take an
	// index and return an object. Returned error stops VM execution if not
	// handled with an error handler and VM.Run returns the same error as
	// wrapped. If Object is not indexable, ErrNotIndexable should be returned
	// as error.
	IndexGet(index Object) (value Object, err error)

	// IndexSet should take an index Object and a value Object for index
	// assignable objects. Index assignable is an object that can take an index
	// and a value on the left-hand side of the assignment statement. If Object
	// is not index assignable, ErrNotIndexAssignable should be returned as
	// error. Returned error stops VM execution if not handled with an error
	// handler and VM.Run returns the same error as wrapped.
	IndexSet(index, value Object) error

	GetValue() Object
	HasMemeber() bool
	GetMember(string) Object
	SetMember(string, Object) error
	CallMethod(string, ...Object) (Object, error)
}

Object represents an object in the VM. 

var (
	// Undefined represents undefined value.
	Undefined Object = &UndefinedType{}
)

func BuiltinDbCloseFunc 

func BuiltinDbCloseFunc(c Call) (Object, error)

BuiltinDbCloseFunc closes a database connection. It should be called after completing database operations to release resources. Failing to close database connections may lead to resource leaks.

Parameters:

  • db: The database connection object (*Database)

Returns: 

nil on success, or an error if the close operation fails.

Examples: 

db := dbConnect("sqlite3", "test.db")
// ... perform database operations ...
dbClose(db)

func BuiltinDealStrFunc 

func BuiltinDealStrFunc(c Call) (Object, error)

BuiltinDealStrFunc decodes/decrypts tagged string formats.

func BuiltinDelegateFunc 

func BuiltinDelegateFunc(c Call) (Object, error)

BuiltinDelegateFunc creates a Delegate object.

func BuiltinFuzzyFindFunc 

func BuiltinFuzzyFindFunc(c Call) (Object, error)

BuiltinFuzzyFindFunc performs fuzzy search on string or string list.

func CallObjectMethodFunc 

func CallObjectMethodFunc(o Object, idxA string, argsA ...Object) (Object, error)

func ConvertToObject 

func ConvertToObject(vA interface{}) Object

func GenStatusResult 

func GenStatusResult(args ...Object) (Object, error)

func GetObjectMethodFunc 

func GetObjectMethodFunc(o Object, idxA string) (Object, error)

func NewBigFloat 

func NewBigFloat(c Call) (Object, error)

func NewBigInt 

func NewBigInt(c Call) (Object, error)

func NewBytesBuffer 

func NewBytesBuffer(c Call) (Object, error)

func NewDelegate 

func NewDelegate(c Call) (Object, error)

func NewEvalMachine 

func NewEvalMachine(c Call) (Object, error)

func NewExcel 

func NewExcel(c Call) (Object, error)

func NewExternalDelegate 

func NewExternalDelegate(funcA func(...interface{}) interface{}) Object

func NewFile 

func NewFile(c Call) (Object, error)

func NewGel 

func NewGel(argsA ...Object) (Object, error)

func NewHttpHandler 

func NewHttpHandler(c Call) (Object, error)

func NewHttpReq 

func NewHttpReq(c Call) (Object, error)

func NewImage 

func NewImage(c Call) (Object, error)

func NewJsVm 

func NewJsVm(c Call) (Object, error)

func NewMapArray 

func NewMapArray(c Call) (Object, error)

func NewOrderedMap 

func NewOrderedMap(argsA ...Object) (Object, error)

func NewQueue 

func NewQueue(c Call) (Object, error)

func NewReader 

func NewReader(c Call) (Object, error)

func NewStack 

func NewStack(c Call) (Object, error)

func NewWebSocket 

func NewWebSocket(c Call) (Object, error)

func NewWriter 

func NewWriter(c Call) (Object, error)

func ToObject 

func ToObject(v interface{}) (ret Object, err error)

ToObject will try to convert an interface{} v to an Object.

func ToObjectAlt 

func ToObjectAlt(v interface{}) (ret Object, err error)

ToObjectAlt is analogous to ToObject but it will always convert signed integers to Int and unsigned integers to Uint. It is an alternative to ToObject. Note that, this function is subject to change in the future.

type ObjectImpl 

type ObjectImpl struct {
}

ObjectImpl is the basic Object implementation and it does not nothing, and helps to implement Object interface by embedding and overriding methods in custom implementations. String and TypeName must be implemented otherwise calling these methods causes panic. ObjectImpl provides a basic Object implementation that does nothing. It can be embedded in custom types to partially implement the Object interface. Types embedding ObjectImpl must override TypeName() and String() methods, otherwise calling these methods will panic with ErrNotImplemented.

Type code: N/A (base implementation, not instantiable as standalone type).

Key characteristics:

  • Provides default implementations for all Object interface methods
  • TypeCode(), TypeName(), String() panic with ErrNotImplemented
  • HasMemeber() returns false, IsFalsy() returns true
  • CanCall() returns false, CanIterate() returns false
  • Equal() returns false, IndexGet/Set return appropriate errors
  • BinaryOp() returns ErrInvalidOperator

func (ObjectImpl) BinaryOp 

func (ObjectImpl) BinaryOp(_ token.Token, _ Object) (Object, error)

BinaryOp implements Object interface.

func (ObjectImpl) Call 

func (ObjectImpl) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (ObjectImpl) CallMethod 

func (o ObjectImpl) CallMethod(nameA string, argsA ...Object) (Object, error)

func (ObjectImpl) CanCall 

func (ObjectImpl) CanCall() bool

CanCall implements Object interface.

func (ObjectImpl) CanIterate 

func (ObjectImpl) CanIterate() bool

CanIterate implements Object interface.

func (ObjectImpl) Equal 

func (ObjectImpl) Equal(Object) bool

Equal implements Object interface.

func (ObjectImpl) GetMember 

func (o ObjectImpl) GetMember(idxA string) Object

func (ObjectImpl) GetValue 

func (o ObjectImpl) GetValue() Object

func (ObjectImpl) HasMemeber 

func (o ObjectImpl) HasMemeber() bool

func (ObjectImpl) IndexGet 

func (o ObjectImpl) IndexGet(index Object) (value Object, err error)

IndexGet implements Object interface.

func (ObjectImpl) IndexSet 

func (o ObjectImpl) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (ObjectImpl) IsFalsy 

func (ObjectImpl) IsFalsy() bool

IsFalsy implements Object interface.

func (ObjectImpl) Iterate 

func (ObjectImpl) Iterate() Iterator

Iterate implements Object interface.

func (ObjectImpl) SetMember 

func (o ObjectImpl) SetMember(idxA string, valueA Object) error

func (ObjectImpl) String 

func (o ObjectImpl) String() string

String implements Object interface.

func (ObjectImpl) TypeCode 

func (ObjectImpl) TypeCode() int

func (ObjectImpl) TypeName 

func (ObjectImpl) TypeName() string

TypeName implements Object interface.

type ObjectPtr 

type ObjectPtr struct {
	ObjectImpl
	Value *Object

	Members map[string]Object `json:"-"`
}

ObjectPtr represents a pointer to an Object, enabling pass-by-reference semantics. It allows modification of shared objects across different contexts.

Type code: 151.

Key characteristics:

  • Internal use only; for common purpose, use ObjectRef instead
  • Holds a pointer to an Object (*Object), not the Object itself
  • Enables pass-by-reference semantics in Charlang
  • "value" method dereferences and returns the pointed-to object
  • Supports member attachment via Members map

func (*ObjectPtr) BinaryOp 

func (o *ObjectPtr) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (*ObjectPtr) Call 

func (o *ObjectPtr) Call(args ...Object) (Object, error)

Call implements Object interface.

func (*ObjectPtr) CallMethod 

func (o *ObjectPtr) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*ObjectPtr) CanCall 

func (o *ObjectPtr) CanCall() bool

CanCall implements Object interface.

func (*ObjectPtr) Copy 

func (o *ObjectPtr) Copy() Object

Copy implements Copier interface.

func (*ObjectPtr) Equal 

func (o *ObjectPtr) Equal(x Object) bool

Equal implements Object interface.

func (*ObjectPtr) GetMember 

func (o *ObjectPtr) GetMember(idxA string) Object

func (*ObjectPtr) GetValue 

func (o *ObjectPtr) GetValue() Object

func (*ObjectPtr) HasMemeber 

func (o *ObjectPtr) HasMemeber() bool

func (*ObjectPtr) IsFalsy 

func (o *ObjectPtr) IsFalsy() bool

IsFalsy implements Object interface.

func (*ObjectPtr) SetMember 

func (o *ObjectPtr) SetMember(idxA string, valueA Object) error

func (*ObjectPtr) String 

func (o *ObjectPtr) String() string

String implements Object interface.

func (*ObjectPtr) TypeCode 

func (o *ObjectPtr) TypeCode() int

func (*ObjectPtr) TypeName 

func (o *ObjectPtr) TypeName() string

TypeName implements Object interface.

type ObjectRef 

type ObjectRef struct {
	ObjectImpl
	Value *Object

	Members map[string]Object `json:"-"`
}

ObjectRef represents a reference variable. always refer to an Object(i.e. *Object) ObjectRef represents a reference variable that points to another Object. It wraps a pointer to an Object (*Object) allowing indirect access and modification.

Type code: 152.

Key characteristics:

  • Wraps a pointer to Object (*Object) for reference semantics
  • Delegates operations (BinaryOp, CanCall, Call) to the referenced object
  • Copier interface returns self (references are not deep-copied)
  • "value" method dereferences and returns the pointed-to object
  • Supports member attachment via Members map

func (*ObjectRef) BinaryOp 

func (o *ObjectRef) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (*ObjectRef) Call 

func (o *ObjectRef) Call(args ...Object) (Object, error)

Call implements Object interface.

func (*ObjectRef) CallMethod 

func (o *ObjectRef) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*ObjectRef) CanCall 

func (o *ObjectRef) CanCall() bool

CanCall implements Object interface.

func (*ObjectRef) Copy 

func (o *ObjectRef) Copy() Object

Copy implements Copier interface.

func (*ObjectRef) Equal 

func (o *ObjectRef) Equal(x Object) bool

Equal implements Object interface.

func (*ObjectRef) GetMember 

func (o *ObjectRef) GetMember(idxA string) Object

func (*ObjectRef) GetValue 

func (o *ObjectRef) GetValue() Object

func (*ObjectRef) HasMemeber 

func (o *ObjectRef) HasMemeber() bool

func (*ObjectRef) IsFalsy 

func (o *ObjectRef) IsFalsy() bool

IsFalsy implements Object interface.

func (*ObjectRef) SetMember 

func (o *ObjectRef) SetMember(idxA string, valueA Object) error

func (*ObjectRef) String 

func (o *ObjectRef) String() string

String implements Object interface.

func (*ObjectRef) TypeCode 

func (o *ObjectRef) TypeCode() int

func (*ObjectRef) TypeName 

func (o *ObjectRef) TypeName() string

TypeName implements Object interface.

type Opcode 

type Opcode = byte

Opcode represents a single byte operation code for the VM. 

const (
	// OpNoOp is a no-operation instruction.
	OpNoOp Opcode = iota

	// OpConstant pushes a constant from the constant pool onto the stack.
	// Operands: [2] - constant index (0-65535)
	OpConstant

	// OpCall calls a function with the specified number of arguments.
	// Operands: [1, 1] - argument count, flags
	OpCall

	// OpGetGlobal retrieves a global variable by name and pushes it onto the stack.
	// Operands: [2] - constant index (variable name)
	OpGetGlobal

	// OpSetGlobal sets a global variable by name to the value on top of stack.
	// Operands: [2] - constant index (variable name)
	OpSetGlobal

	// OpGetLocal retrieves a local variable by index and pushes it onto the stack.
	// Operands: [1] - local variable index
	OpGetLocal

	// OpSetLocal sets a local variable by index to the value on top of stack.
	// Operands: [1] - local variable index
	OpSetLocal

	// OpGetBuiltin retrieves a built-in function by index and pushes it onto the stack.
	// Operands: [2] - builtin function index
	OpGetBuiltin

	// OpBinaryOp performs a binary operation on the top two stack values.
	// Operands: [1] - operator token
	OpBinaryOp

	// OpUnary performs a unary operation on the top stack value.
	// Operands: [1] - operator token
	OpUnary

	// OpEqual checks equality of the top two stack values and pushes the result.
	OpEqual

	// OpNotEqual checks inequality of the top two stack values and pushes the result.
	OpNotEqual

	// OpJump unconditionally jumps to the specified instruction position.
	// Operands: [2] - instruction position
	OpJump

	// OpJumpFalsy jumps to the specified position if the top of stack is falsy.
	// Operands: [2] - instruction position
	OpJumpFalsy

	// OpAndJump implements short-circuit AND: jumps if top of stack is falsy.
	// Operands: [2] - instruction position
	OpAndJump

	// OpOrJump implements short-circuit OR: jumps if top of stack is truthy.
	// Operands: [2] - instruction position
	OpOrJump

	// OpMap creates a new map with the specified number of key-value pairs.
	// Operands: [2] - number of pairs
	OpMap

	// OpArray creates a new array with the specified number of elements.
	// Operands: [2] - number of elements
	OpArray

	// OpSliceIndex performs a slice operation [start:end] on the top value.
	OpSliceIndex

	// OpGetIndex retrieves a value by index from the collection on the stack.
	// Operands: [1] - number of selectors (for chained access)
	OpGetIndex

	// OpSetIndex sets a value by index in the collection on the stack.
	OpSetIndex

	// OpNull pushes Undefined onto the stack.
	OpNull

	// OpPop removes and discards the top value from the stack.
	OpPop

	// OpGetFree retrieves a free variable (from enclosing scope) by index.
	// Operands: [1] - free variable index
	OpGetFree

	// OpSetFree sets a free variable by index to the value on top of stack.
	// Operands: [1] - free variable index
	OpSetFree

	// OpGetLocalPtr gets a pointer to a local variable for reference semantics.
	// Operands: [1] - local variable index
	OpGetLocalPtr

	// OpGetFreePtr gets a pointer to a free variable for reference semantics.
	// Operands: [1] - free variable index
	OpGetFreePtr

	// OpClosure creates a closure from a compiled function with captured variables.
	// Operands: [2, 1] - constant index (function), number of free variables
	OpClosure

	// OpIterInit initializes an iterator for the collection on top of stack.
	OpIterInit

	// OpIterNext advances the iterator and pushes the next value (or null if done).
	OpIterNext

	// OpIterKey pushes the current key from the iterator onto the stack.
	OpIterKey

	// OpIterValue pushes the current value from the iterator onto the stack.
	OpIterValue

	// OpLoadModule loads a module by name and pushes it onto the stack.
	// Operands: [2, 2] - constant index (module name), module index
	OpLoadModule

	// OpStoreModule stores the top of stack as a module with the given name.
	// Operands: [2] - constant index (module name)
	OpStoreModule

	// OpSetupTry sets up a try block for exception handling.
	// Operands: [2, 2] - catch position, finally position
	OpSetupTry

	// OpSetupCatch sets up a catch block to handle exceptions.
	OpSetupCatch

	// OpSetupFinally sets up a finally block for cleanup code.
	OpSetupFinally

	// OpThrow throws an exception (re-throws if operand is 0).
	// Operands: [1] - 0 for re-throw, 1 for throw expression
	OpThrow

	// OpFinalizer handles cleanup after exception handling.
	// Operands: [1] - error handler index
	OpFinalizer

	// OpReturn returns from the current function with the top of stack.
	// Operands: [1] - number of return values (0 or 1)
	OpReturn

	// OpDefineLocal defines a new local variable at the specified index.
	// Operands: [1] - local variable index
	OpDefineLocal

	// OpTrue pushes the boolean value true onto the stack.
	OpTrue

	// OpFalse pushes the boolean value false onto the stack.
	OpFalse

	// OpCallName calls a method by name on the object on top of stack.
	// Operands: [1, 1] - argument count, flags
	OpCallName
)

List of opcodes. Each opcode is a single byte value. See OpcodeOperands for the operand specification of each opcode.

type OptimizerError 

type OptimizerError struct {
	FilePos parser.SourceFilePos
	Node    parser.Node
	Err     error
}

OptimizerError represents an optimizer error.

func (*OptimizerError) Error 

func (e *OptimizerError) Error() string

func (*OptimizerError) Unwrap 

func (e *OptimizerError) Unwrap() error

type OrderedMap 

type OrderedMap struct {
	ObjectImpl
	Value *tk.OrderedMap
}

OrderedMap represents map of objects but has order(in the order of push-in) and implements Object interface. OrderedMap wraps tk.OrderedMap for ordered key-value storage. Unlike Map, OrderedMap preserves insertion order during iteration.

Type code: 195.

Key characteristics:

  • Wraps tk.OrderedMap for order-preserving map operations
  • Maintains insertion order during iteration
  • Implements IndexDeleter, Copier, and LengthGetter interfaces
  • Keys are strings; values are Objects

func (*OrderedMap) BinaryOp 

func (o *OrderedMap) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (*OrderedMap) Call 

func (*OrderedMap) Call(...Object) (Object, error)

Call implements Object interface.

func (*OrderedMap) CallMethod 

func (o *OrderedMap) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*OrderedMap) CallName 

func (o *OrderedMap) CallName(nameA string, c Call) (Object, error)

func (*OrderedMap) CanCall 

func (*OrderedMap) CanCall() bool

CanCall implements Object interface.

func (*OrderedMap) CanIterate 

func (*OrderedMap) CanIterate() bool

CanIterate implements Object interface.

func (*OrderedMap) Copy 

func (o *OrderedMap) Copy() Object

Copy implements Copier interface.

func (*OrderedMap) Equal 

func (o *OrderedMap) Equal(right Object) bool

Equal implements Object interface.

func (*OrderedMap) GetMember 

func (o *OrderedMap) GetMember(idxA string) Object

func (*OrderedMap) GetValue 

func (o *OrderedMap) GetValue() Object

func (*OrderedMap) HasMemeber 

func (o *OrderedMap) HasMemeber() bool

func (*OrderedMap) IndexDelete 

func (o *OrderedMap) IndexDelete(key Object) error

IndexDelete tries to delete the string value of key from the map. IndexDelete implements IndexDeleter interface.

func (*OrderedMap) IndexGet 

func (o *OrderedMap) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (*OrderedMap) IndexSet 

func (o *OrderedMap) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (*OrderedMap) IsFalsy 

func (o *OrderedMap) IsFalsy() bool

IsFalsy implements Object interface.

func (*OrderedMap) Iterate 

func (o *OrderedMap) Iterate() Iterator

Iterate implements Iterable interface.

func (*OrderedMap) Len 

func (o *OrderedMap) Len() int

Len implements LengthGetter interface.

func (*OrderedMap) SetMember 

func (o *OrderedMap) SetMember(idxA string, valueA Object) error

func (*OrderedMap) String 

func (o *OrderedMap) String() string

String implements Object interface.

func (*OrderedMap) TypeCode 

func (*OrderedMap) TypeCode() int

func (*OrderedMap) TypeName 

func (*OrderedMap) TypeName() string

TypeName implements Object interface.

type OrderedMapIterator 

type OrderedMapIterator struct {
	V *OrderedMap
	// contains filtered or unexported fields
}

OrderedMapIterator represents an iterator for the map.

func (*OrderedMapIterator) Key 

func (it *OrderedMapIterator) Key() Object

Key implements Iterator interface.

func (*OrderedMapIterator) Next 

func (it *OrderedMapIterator) Next() bool

Next implements Iterator interface.

func (*OrderedMapIterator) Value 

func (it *OrderedMapIterator) Value() Object

Value implements Iterator interface.

type Queue 

type Queue struct {
	ObjectImpl
	Value *tk.AnyQueue

	Members map[string]Object `json:"-"`
}

Queue represents a generic FIFO queue object and implements Object interface. Queue wraps tk.AnyQueue for FIFO (First-In-First-Out) data structure. It provides enqueue, dequeue, and peek operations for queue-based algorithms.

Type code: 323.

Key characteristics:

  • Wraps tk.AnyQueue for FIFO operations
  • Implements LengthGetter interface for size queries
  • Supports Enqueue, Dequeue, Peek, and Clear operations
  • Generic container for Object values
  • Supports member attachment via Members map

func (*Queue) BinaryOp 

func (o *Queue) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (*Queue) Call 

func (*Queue) Call(...Object) (Object, error)

Call implements Object interface.

func (*Queue) CallMethod 

func (o *Queue) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Queue) CanCall 

func (*Queue) CanCall() bool

CanCall implements Object interface.

func (*Queue) CanIterate 

func (*Queue) CanIterate() bool

CanIterate implements Object interface.

func (*Queue) GetMember 

func (o *Queue) GetMember(idxA string) Object

func (*Queue) GetValue 

func (o *Queue) GetValue() Object

func (*Queue) HasMemeber 

func (o *Queue) HasMemeber() bool

func (*Queue) IndexGet 

func (o *Queue) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (*Queue) IndexSet 

func (o *Queue) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (*Queue) IsFalsy 

func (o *Queue) IsFalsy() bool

IsFalsy implements Object interface.

func (*Queue) Iterate 

func (o *Queue) Iterate() Iterator

Iterate implements Iterable interface.

func (*Queue) Len 

func (o *Queue) Len() int

Len implements LengthGetter interface.

func (*Queue) SetMember 

func (o *Queue) SetMember(idxA string, valueA Object) error

func (*Queue) String 

func (o *Queue) String() string

String implements Object interface.

func (*Queue) TypeCode 

func (*Queue) TypeCode() int

func (*Queue) TypeName 

func (*Queue) TypeName() string

TypeName implements Object interface.

type QueueIterator 

type QueueIterator struct {
	V *Queue
	// contains filtered or unexported fields
}

QueueIterator represents an iterator for the Queue.

func (*QueueIterator) Key 

func (it *QueueIterator) Key() Object

Key implements Iterator interface.

func (*QueueIterator) Next 

func (it *QueueIterator) Next() bool

Next implements Iterator interface.

func (*QueueIterator) Value 

func (it *QueueIterator) Value() Object

Value implements Iterator interface.

type RSAEncryption 

type RSAEncryption struct {
	// contains filtered or unexported fields
}

func (*RSAEncryption) Encrypt 

func (r *RSAEncryption) Encrypt(plainText string) (string, error)

Encrypt encrypts plaintext using RSA-OAEP and returns URL-escaped base64 text.

type Reader 

type Reader struct {
	ObjectImpl
	Value     io.Reader
	SizeM     int // may be not set
	CloseDele tk.QuickVarDelegate

	Members map[string]Object `json:"-"`
}

Reader object is used for represent io.Reader type value Reader wraps io.Reader for reading data from various sources. It implements io.ReadCloser interface for stream-based reading.

Type code: 331.

Key characteristics:

  • Wraps any io.Reader (files, network connections, buffers, etc.)
  • Implements io.ReadCloser interface
  • SizeM field optionally stores expected content size
  • CloseDele provides optional close callback delegate
  • Supports member attachment via Members map

func (*Reader) BinaryOp 

func (o *Reader) BinaryOp(tok token.Token, right Object) (Object, error)

func (*Reader) Call 

func (o *Reader) Call(_ ...Object) (Object, error)

func (*Reader) CallMethod 

func (o *Reader) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Reader) CallName 

func (o *Reader) CallName(nameA string, c Call) (Object, error)

func (*Reader) CanCall 

func (o *Reader) CanCall() bool

func (*Reader) CanIterate 

func (*Reader) CanIterate() bool

func (*Reader) Close 

func (o *Reader) Close() error

comply to io.Closer

func (*Reader) Equal 

func (o *Reader) Equal(right Object) bool

func (*Reader) GetMember 

func (o *Reader) GetMember(idxA string) Object

func (*Reader) GetValue 

func (o *Reader) GetValue() Object

func (*Reader) HasMemeber 

func (o *Reader) HasMemeber() bool

func (*Reader) IndexGet 

func (o *Reader) IndexGet(index Object) (Object, error)

func (*Reader) IndexSet 

func (o *Reader) IndexSet(index, value Object) error

func (*Reader) IsFalsy 

func (o *Reader) IsFalsy() bool

func (*Reader) Iterate 

func (o *Reader) Iterate() Iterator

func (*Reader) Read 

func (o *Reader) Read(p []byte) (n int, err error)

comply to io.Reader

func (*Reader) SetMember 

func (o *Reader) SetMember(idxA string, valueA Object) error

func (*Reader) SetSize 

func (o *Reader) SetSize(sizeA int)

func (*Reader) Size 

func (o *Reader) Size() int

func (*Reader) String 

func (o *Reader) String() string

func (*Reader) TypeCode 

func (*Reader) TypeCode() int

func (*Reader) TypeName 

func (*Reader) TypeName() string

TypeName implements Object interface.

type RuntimeError 

type RuntimeError struct {
	Err *Error

	Trace []parser.Pos

	Members map[string]Object `json:"-"`
	// contains filtered or unexported fields
}

RuntimeError represents a runtime error that wraps Error and includes trace information. RuntimeError represents a Charlang runtime error with stack trace information. It wraps an Error with source position tracking for debugging.

Type code: 157.

Key characteristics:

  • Wraps an Error with source file set and position trace
  • Provides stack trace for debugging via Trace field
  • fileSet enables resolution of positions to file:line:column
  • Supports member attachment via Members map
  • TypeName() returns "error" (same as Error for type checking)

func (*RuntimeError) BinaryOp 

func (o *RuntimeError) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (*RuntimeError) Call 

func (*RuntimeError) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (*RuntimeError) CallMethod 

func (o *RuntimeError) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*RuntimeError) CanCall 

func (*RuntimeError) CanCall() bool

CanCall implements Object interface.

func (*RuntimeError) CanIterate 

func (*RuntimeError) CanIterate() bool

CanIterate implements Object interface.

func (*RuntimeError) Copy 

func (o *RuntimeError) Copy() Object

Copy implements Copier interface.

func (*RuntimeError) Equal 

func (o *RuntimeError) Equal(right Object) bool

Equal implements Object interface.

func (*RuntimeError) Error 

func (o *RuntimeError) Error() string

Error implements error interface.

func (*RuntimeError) Format 

func (o *RuntimeError) Format(s fmt.State, verb rune)

Format implements fmt.Formater interface.

func (*RuntimeError) GetMember 

func (o *RuntimeError) GetMember(idxA string) Object

func (*RuntimeError) GetValue 

func (o *RuntimeError) GetValue() Object

func (*RuntimeError) HasMemeber 

func (o *RuntimeError) HasMemeber() bool

func (*RuntimeError) IndexGet 

func (o *RuntimeError) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (*RuntimeError) IndexSet 

func (o *RuntimeError) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (*RuntimeError) IsFalsy 

func (o *RuntimeError) IsFalsy() bool

IsFalsy implements Object interface.

func (*RuntimeError) Iterate 

func (*RuntimeError) Iterate() Iterator

Iterate implements Object interface.

func (*RuntimeError) NewError 

func (o *RuntimeError) NewError(messages ...string) *RuntimeError

NewError creates a new Error and sets original Error as its cause which can be unwrapped.

func (*RuntimeError) SetMember 

func (o *RuntimeError) SetMember(idxA string, valueA Object) error

func (*RuntimeError) StackTrace 

func (o *RuntimeError) StackTrace() StackTrace

StackTrace returns stack trace if set otherwise returns nil.

func (*RuntimeError) String 

func (o *RuntimeError) String() string

String implements Object interface.

func (*RuntimeError) TypeCode 

func (*RuntimeError) TypeCode() int

func (*RuntimeError) TypeName 

func (*RuntimeError) TypeName() string

TypeName implements Object interface.

func (*RuntimeError) Unwrap 

func (o *RuntimeError) Unwrap() error

type Seq 

type Seq struct {
	ObjectImpl
	Value *(tk.Seq)

	Members map[string]Object `json:"-"`
}

Seq object is used for generate unique sequence number(integer) Seq wraps tk.Seq for sequence/generator operations. It provides lazy evaluation of infinite or finite sequences.

Type code: 315.

Key characteristics:

  • Wraps tk.Seq for sequence generation and manipulation
  • Supports lazy evaluation of sequence elements
  • Provides methods for filtering, mapping, and reducing
  • Implements ValueSetter interface
  • Supports member attachment via Members map

func NewSeq 

func NewSeq(argsA ...Object) *Seq

func (*Seq) BinaryOp 

func (o *Seq) BinaryOp(tok token.Token, right Object) (Object, error)

func (*Seq) Call 

func (o *Seq) Call(_ ...Object) (Object, error)

func (*Seq) CallMethod 

func (o *Seq) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Seq) CanCall 

func (o *Seq) CanCall() bool

func (*Seq) CanIterate 

func (*Seq) CanIterate() bool

func (*Seq) Equal 

func (o *Seq) Equal(right Object) bool

func (*Seq) GetCurrentValue 

func (o *Seq) GetCurrentValue() Object

func (*Seq) GetMember 

func (o *Seq) GetMember(idxA string) Object

func (*Seq) GetValue 

func (o *Seq) GetValue() Object

func (*Seq) HasMemeber 

func (o *Seq) HasMemeber() bool

func (*Seq) IndexGet 

func (o *Seq) IndexGet(index Object) (Object, error)

func (*Seq) IndexSet 

func (o *Seq) IndexSet(index, value Object) error

func (*Seq) IsFalsy 

func (o *Seq) IsFalsy() bool

func (*Seq) Iterate 

func (o *Seq) Iterate() Iterator

func (*Seq) SetMember 

func (o *Seq) SetMember(idxA string, valueA Object) error

func (*Seq) SetValue 

func (o *Seq) SetValue(valueA Object) error

func (*Seq) String 

func (o *Seq) String() string

func (*Seq) TypeCode 

func (*Seq) TypeCode() int

func (*Seq) TypeName 

func (*Seq) TypeName() string

TypeName implements Object interface.

type SimpleOptimizer 

type SimpleOptimizer struct {
	// contains filtered or unexported fields
}

SimpleOptimizer optimizes given parsed file by evaluating constants and expressions. It is not safe to call methods concurrently.

func NewOptimizer 

func NewOptimizer(
	file *parser.File,
	base *SymbolTable,
	opts CompilerOptions,
) *SimpleOptimizer

NewOptimizer creates an Optimizer object.

func (*SimpleOptimizer) Optimize 

func (so *SimpleOptimizer) Optimize() error

Optimize optimizes ast tree by simple constant folding and evaluating simple expressions.

func (*SimpleOptimizer) Total 

func (so *SimpleOptimizer) Total() int

Total returns total number of evaluated constants and expressions.

type SourceModule 

type SourceModule struct {
	Src []byte
}

SourceModule is an importable module that's written in Charlang.

func (*SourceModule) Import 

func (m *SourceModule) Import(_ string) (interface{}, error)

Import returns a module source code.

type Stack 

type Stack struct {
	ObjectImpl
	Value *tk.SimpleStack

	Members map[string]Object `json:"-"`
}

Stack represents a generic stack object and implements Object interface. Stack wraps tk.SimpleStack for LIFO (Last-In-First-Out) data structure. It provides push, pop, and peek operations for stack-based algorithms.

Type code: 321.

Key characteristics:

  • Wraps tk.SimpleStack for LIFO operations
  • Implements LengthGetter interface for size queries
  • Supports Push, Pop, Peek, and Clear operations
  • Generic container for Object values
  • Supports member attachment via Members map

func (*Stack) BinaryOp 

func (o *Stack) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (*Stack) Call 

func (*Stack) Call(...Object) (Object, error)

Call implements Object interface.

func (*Stack) CallMethod 

func (o *Stack) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Stack) CanCall 

func (*Stack) CanCall() bool

CanCall implements Object interface.

func (*Stack) CanIterate 

func (*Stack) CanIterate() bool

CanIterate implements Object interface.

func (*Stack) Equal 

func (o *Stack) Equal(right Object) bool

Equal implements Object interface.

func (*Stack) GetMember 

func (o *Stack) GetMember(idxA string) Object

func (*Stack) GetValue 

func (o *Stack) GetValue() Object

func (*Stack) HasMemeber 

func (o *Stack) HasMemeber() bool

func (*Stack) IndexGet 

func (o *Stack) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (*Stack) IndexSet 

func (o *Stack) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (*Stack) IsFalsy 

func (o *Stack) IsFalsy() bool

IsFalsy implements Object interface.

func (*Stack) Iterate 

func (o *Stack) Iterate() Iterator

Iterate implements Iterable interface.

func (*Stack) Len 

func (o *Stack) Len() int

Len implements LengthGetter interface.

func (*Stack) Queue 

func (o *Stack) Queue(right Object) bool

Equal implements Object interface.

func (*Stack) SetMember 

func (o *Stack) SetMember(idxA string, valueA Object) error

func (*Stack) String 

func (o *Stack) String() string

String implements Object interface.

func (*Stack) TypeCode 

func (*Stack) TypeCode() int

func (*Stack) TypeName 

func (*Stack) TypeName() string

TypeName implements Object interface.

type StackIterator 

type StackIterator struct {
	V *Stack
	// contains filtered or unexported fields
}

StackIterator represents an iterator for the Stack.

func (*StackIterator) Key 

func (it *StackIterator) Key() Object

Key implements Iterator interface.

func (*StackIterator) Next 

func (it *StackIterator) Next() bool

Next implements Iterator interface.

func (*StackIterator) Value 

func (it *StackIterator) Value() Object

Value implements Iterator interface.

type StackTrace 

type StackTrace []parser.SourceFilePos

StackTrace is the stack of source file positions.

func (StackTrace) Format 

func (st StackTrace) Format(s fmt.State, verb rune)

Format formats the StackTrace to the fmt.Formatter interface.

type StatusResult 

type StatusResult struct {
	ObjectImpl
	Status  string
	Value   string
	Objects interface{}

	Members map[string]Object    `json:"-"`
	Methods map[string]*Function `json:"-"`
}

StatusResult represents an operation result with status and value. It provides a standardized result format for operations that may succeed or fail.

Type code: 303.

Key characteristics:

  • Standardized result format: Status ("success", "fail", ""), Value, Objects
  • Status indicates operation outcome
  • Value stores the result message or primary return value
  • Objects stores additional structured data (optional)
  • Pre-defined constants: StatusResultSuccess, StatusResultFail, StatusResultInvalid
  • Methods cache stores dynamically generated function objects
  • Supports member attachment via Members map

func (*StatusResult) BinaryOp 

func (o *StatusResult) BinaryOp(tok token.Token, right Object) (Object, error)

func (*StatusResult) Call 

func (*StatusResult) Call(_ ...Object) (Object, error)

func (*StatusResult) CallMethod 

func (o *StatusResult) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*StatusResult) Equal 

func (o *StatusResult) Equal(right Object) bool

func (*StatusResult) GetMember 

func (o *StatusResult) GetMember(idxA string) Object

func (*StatusResult) GetValue 

func (o *StatusResult) GetValue() Object

func (*StatusResult) HasMemeber 

func (o *StatusResult) HasMemeber() bool

func (*StatusResult) IndexGet 

func (o *StatusResult) IndexGet(index Object) (Object, error)

func (*StatusResult) IndexSet 

func (o *StatusResult) IndexSet(key, value Object) error

func (*StatusResult) SetMember 

func (o *StatusResult) SetMember(idxA string, valueA Object) error

func (*StatusResult) String 

func (o *StatusResult) String() string

func (*StatusResult) TypeCode 

func (o *StatusResult) TypeCode() int

func (*StatusResult) TypeName 

func (o *StatusResult) TypeName() string

type String 

type String string

String represents string values and implements Object interface.

func ToString 

func ToString(o Object) (v String, ok bool)

ToString will try to convert an Object to Charlang string value.

func ToStringObject 

func ToStringObject(argA interface{}) String

ToStringObject converts any Object to string representation. Parameters:

  • argA: The Object to convert (any type)

Returns:

  • A String object containing string representation of object

Examples: 

ToStringObject(42)  // Returns: String("42")
ToStringObject("hello")  // Returns: String("hello")
ToStringObject([1, 2, 3])  // Returns: String("1, 2, 3")

func (String) BinaryOp 

func (o String) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (String) Call 

func (o String) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (String) CallMethod 

func (o String) CallMethod(nameA string, argsA ...Object) (Object, error)

func (String) CallName 

func (o String) CallName(nameA string, c Call) (Object, error)

func (String) CanCall 

func (o String) CanCall() bool

CanCall implements Object interface.

func (String) CanIterate 

func (String) CanIterate() bool

CanIterate implements Object interface.

func (String) Copy 

func (o String) Copy() Object

func (String) Equal 

func (o String) Equal(right Object) bool

Equal implements Object interface.

func (String) Format 

func (o String) Format(s fmt.State, verb rune)

Format implements fmt.Formatter interface.

func (String) GetMember 

func (o String) GetMember(idxA string) Object

func (String) GetValue 

func (o String) GetValue() Object

func (String) HasMemeber 

func (o String) HasMemeber() bool

func (String) IndexGet 

func (o String) IndexGet(index Object) (Object, error)

IndexGet represents string values and implements Object interface.

func (String) IndexSet 

func (o String) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (String) IsFalsy 

func (o String) IsFalsy() bool

IsFalsy implements Object interface.

func (String) Iterate 

func (o String) Iterate() Iterator

Iterate implements Object interface.

func (String) Len 

func (o String) Len() int

Len implements LengthGetter interface.

func (String) MarshalJSON 

func (o String) MarshalJSON() ([]byte, error)

func (String) SetMember 

func (o String) SetMember(idxA string, valueA Object) error

func (String) String 

func (o String) String() string

func (String) TypeCode 

func (String) TypeCode() int

func (String) TypeName 

func (String) TypeName() string

TypeName implements Object interface.

type StringBuilder 

type StringBuilder struct {
	ObjectImpl
	Value *strings.Builder

	Members map[string]Object `json:"-"`
}

StringBuilder wraps Go's strings.Builder for efficient string concatenation. It provides a mutable buffer for building strings without allocations.

Type code: 307.

Key characteristics:

  • Wraps Go's strings.Builder for efficient string building
  • Supports WriteString, Write, and Reset operations via methods
  • Grows dynamically without reallocation (amortized O(1) append)
  • String() returns the accumulated string content
  • Supports member attachment via Members map

func (*StringBuilder) BinaryOp 

func (o *StringBuilder) BinaryOp(tok token.Token, right Object) (Object, error)

func (*StringBuilder) Call 

func (*StringBuilder) Call(_ ...Object) (Object, error)

func (*StringBuilder) CallMethod 

func (o *StringBuilder) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*StringBuilder) CallName 

func (o *StringBuilder) CallName(nameA string, c Call) (Object, error)

func (*StringBuilder) CanCall 

func (*StringBuilder) CanCall() bool

func (*StringBuilder) CanIterate 

func (*StringBuilder) CanIterate() bool

func (*StringBuilder) Copy 

func (o *StringBuilder) Copy() Object

func (*StringBuilder) Equal 

func (o *StringBuilder) Equal(right Object) bool

func (*StringBuilder) GetMember 

func (o *StringBuilder) GetMember(idxA string) Object

func (*StringBuilder) GetValue 

func (o *StringBuilder) GetValue() Object

func (*StringBuilder) HasMemeber 

func (o *StringBuilder) HasMemeber() bool

func (*StringBuilder) IndexGet 

func (o *StringBuilder) IndexGet(index Object) (value Object, err error)

func (*StringBuilder) IndexSet 

func (o *StringBuilder) IndexSet(index, value Object) error

func (*StringBuilder) IsFalsy 

func (o *StringBuilder) IsFalsy() bool

func (*StringBuilder) Iterate 

func (*StringBuilder) Iterate() Iterator

func (*StringBuilder) SetMember 

func (o *StringBuilder) SetMember(idxA string, valueA Object) error

func (*StringBuilder) String 

func (o *StringBuilder) String() string

func (*StringBuilder) TypeCode 

func (o *StringBuilder) TypeCode() int

func (*StringBuilder) TypeName 

func (o *StringBuilder) TypeName() string

type StringIterator 

type StringIterator struct {
	V String
	// contains filtered or unexported fields
}

StringIterator represents an iterator for the string.

func (*StringIterator) Key 

func (it *StringIterator) Key() Object

Key implements Iterator interface.

func (*StringIterator) Next 

func (it *StringIterator) Next() bool

Next implements Iterator interface.

func (*StringIterator) Value 

func (it *StringIterator) Value() Object

Value implements Iterator interface.

type Symbol 

type Symbol struct {
	Name     string
	Index    int
	Scope    SymbolScope
	Assigned bool
	Constant bool
	Original *Symbol
}

Symbol represents a symbol in the symbol table.

func (*Symbol) String 

func (s *Symbol) String() string

type SymbolScope 

type SymbolScope string

SymbolScope represents a symbol scope. 

const (
	ScopeGlobal  SymbolScope = "GLOBAL"
	ScopeLocal   SymbolScope = "LOCAL"
	ScopeBuiltin SymbolScope = "BUILTIN"
	ScopeFree    SymbolScope = "FREE"
)

List of symbol scopes

type SymbolTable 

type SymbolTable struct {
	// contains filtered or unexported fields
}

SymbolTable represents a symbol table.

func NewSymbolTable 

func NewSymbolTable() *SymbolTable

NewSymbolTable creates new symbol table object.

func (*SymbolTable) DefineGlobal 

func (st *SymbolTable) DefineGlobal(name string) (*Symbol, error)

DefineGlobal adds a new symbol with ScopeGlobal in the current scope.

func (*SymbolTable) DefineLocal 

func (st *SymbolTable) DefineLocal(name string) (*Symbol, bool)

DefineLocal adds a new symbol with ScopeLocal in the current scope.

func (*SymbolTable) DisableBuiltin 

func (st *SymbolTable) DisableBuiltin(names ...string) *SymbolTable

DisableBuiltin disables given builtin name(s). Compiler returns `Compile Error: unresolved reference "builtin name"` if a disabled builtin is used.

func (*SymbolTable) DisabledBuiltins 

func (st *SymbolTable) DisabledBuiltins() []string

DisabledBuiltins returns disabled builtin names.

func (*SymbolTable) EnableParams 

func (st *SymbolTable) EnableParams(v bool) *SymbolTable

EnableParams enables or disables definition of parameters.

func (*SymbolTable) Fork 

func (st *SymbolTable) Fork(block bool) *SymbolTable

Fork creates a new symbol table for a new scope.

func (*SymbolTable) FreeSymbols 

func (st *SymbolTable) FreeSymbols() []*Symbol

FreeSymbols returns registered free symbols for the scope.

func (*SymbolTable) InBlock 

func (st *SymbolTable) InBlock() bool

InBlock returns true if symbol table belongs to a block.

func (*SymbolTable) MaxSymbols 

func (st *SymbolTable) MaxSymbols() int

MaxSymbols returns the total number of symbols defined in the scope.

func (*SymbolTable) NextIndex 

func (st *SymbolTable) NextIndex() int

NextIndex returns the next symbol index.

func (*SymbolTable) NumParams 

func (st *SymbolTable) NumParams() int

NumParams returns number of parameters for the scope.

func (*SymbolTable) Parent 

func (st *SymbolTable) Parent(skipBlock bool) *SymbolTable

Parent returns the outer scope of the current symbol table.

func (*SymbolTable) Resolve 

func (st *SymbolTable) Resolve(name string) (symbol *Symbol, ok bool)

Resolve resolves a symbol with a given name.

func (*SymbolTable) SetParams 

func (st *SymbolTable) SetParams(params ...string) error

SetParams sets parameters defined in the scope. This can be called only once.

func (*SymbolTable) ShadowedBuiltins 

func (st *SymbolTable) ShadowedBuiltins() []string

ShadowedBuiltins returns all shadowed builtin names including parent symbol tables'. Returing slice may contain duplicate names.

func (*SymbolTable) Symbols 

func (st *SymbolTable) Symbols() []*Symbol

Symbols returns registered symbols for the scope.

type SyncIterator 

type SyncIterator struct {
	Iterator
	// contains filtered or unexported fields
}

SyncIterator represents an iterator for the SyncMap.

func (*SyncIterator) Key 

func (it *SyncIterator) Key() Object

Key implements Iterator interface.

func (*SyncIterator) Next 

func (it *SyncIterator) Next() bool

Next implements Iterator interface.

func (*SyncIterator) Value 

func (it *SyncIterator) Value() Object

Value implements Iterator interface.

type SyncMap 

type SyncMap struct {
	Value Map

	Members map[string]Object `json:"-"`
	// contains filtered or unexported fields
}

SyncMap represents a thread-safe map with read-write locking. It wraps a Map with sync.RWMutex for concurrent access safety.

Type code: 153.

Key characteristics:

  • Thread-safe map implementation using sync.RWMutex
  • Provides RLock/RLock/Unlock methods for explicit locking
  • Implements IndexDeleter and LengthGetter interfaces
  • All operations are protected by the internal mutex
  • Supports member attachment via Members map

func ToSyncMap 

func ToSyncMap(o Object) (v *SyncMap, ok bool)

ToSyncMap will try to convert an Object to Charlang syncMap value.

func (*SyncMap) BinaryOp 

func (o *SyncMap) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (*SyncMap) Call 

func (*SyncMap) Call(...Object) (Object, error)

Call implements Object interface.

func (*SyncMap) CallMethod 

func (o *SyncMap) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*SyncMap) CanCall 

func (*SyncMap) CanCall() bool

CanCall implements Object interface.

func (*SyncMap) CanIterate 

func (o *SyncMap) CanIterate() bool

CanIterate implements Object interface.

func (*SyncMap) Copy 

func (o *SyncMap) Copy() Object

Copy implements Copier interface.

func (*SyncMap) Equal 

func (o *SyncMap) Equal(right Object) bool

Equal implements Object interface.

func (*SyncMap) Get 

func (o *SyncMap) Get(index string) (value Object, exists bool)

Get returns Object in map if exists.

func (*SyncMap) GetMember 

func (o *SyncMap) GetMember(idxA string) Object

func (*SyncMap) GetValue 

func (o *SyncMap) GetValue() Object

func (*SyncMap) HasMemeber 

func (o *SyncMap) HasMemeber() bool

func (*SyncMap) IndexDelete 

func (o *SyncMap) IndexDelete(key Object) error

IndexDelete tries to delete the string value of key from the map.

func (*SyncMap) IndexGet 

func (o *SyncMap) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (*SyncMap) IndexSet 

func (o *SyncMap) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (*SyncMap) IsFalsy 

func (o *SyncMap) IsFalsy() bool

IsFalsy implements Object interface.

func (*SyncMap) Iterate 

func (o *SyncMap) Iterate() Iterator

Iterate implements Iterable interface.

func (*SyncMap) Len 

func (o *SyncMap) Len() int

Len returns the number of items in the map. Len implements LengthGetter interface.

func (*SyncMap) Lock 

func (o *SyncMap) Lock()

Lock locks the underlying mutex for writing.

func (*SyncMap) RLock 

func (o *SyncMap) RLock()

RLock locks the underlying mutex for reading.

func (*SyncMap) RUnlock 

func (o *SyncMap) RUnlock()

RUnlock unlocks the underlying mutex for reading.

func (*SyncMap) SetMember 

func (o *SyncMap) SetMember(idxA string, valueA Object) error

func (*SyncMap) String 

func (o *SyncMap) String() string

String implements Object interface.

func (*SyncMap) TypeCode 

func (*SyncMap) TypeCode() int

func (*SyncMap) TypeName 

func (*SyncMap) TypeName() string

TypeName implements Object interface.

func (*SyncMap) Unlock 

func (o *SyncMap) Unlock()

Unlock unlocks the underlying mutex for writing.

type Time 

type Time struct {
	Value time.Time

	Members map[string]Object `json:"-"`
}

Time represents time values and implements Object interface. Time represents a time value wrapping Go's time.Time. It supports arithmetic operations with duration (int) and comparison with other times.

Type code: 311.

Key characteristics:

  • Wraps Go's time.Time for full-featured datetime operations
  • Supports binary operations: addition/subtraction with duration (Int)
  • Supports comparison operations with other Time objects
  • Provides formatting, parsing, and timezone conversion methods
  • Can be created from Unix timestamp (Int) or RFC3339 string (String)
  • Implements NameCallerObject interface for efficient method dispatch

func ToTime 

func ToTime(o Object) (ret *Time, ok bool)

ToTime will try to convert given given Object to *Time value.

func (*Time) BinaryOp 

func (o *Time) BinaryOp(tok token.Token,
	right Object) (Object, error)

BinaryOp implements Object interface.

func (*Time) Call 

func (*Time) Call(args ...Object) (Object, error)

Call implements Object interface.

func (*Time) CallMethod 

func (o *Time) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Time) CallName 

func (o *Time) CallName(name string, c Call) (Object, error)

func (*Time) CanCall 

func (*Time) CanCall() bool

CanCall implements Object interface.

func (*Time) CanIterate 

func (*Time) CanIterate() bool

CanIterate implements Object interface.

func (*Time) Copy 

func (o *Time) Copy() Object

func (*Time) Equal 

func (o *Time) Equal(right Object) bool

Equal implements Object interface.

func (*Time) GetMember 

func (o *Time) GetMember(idxA string) Object

func (*Time) GetValue 

func (o *Time) GetValue() Object

func (*Time) HasMemeber 

func (o *Time) HasMemeber() bool

func (*Time) IndexGet 

func (o *Time) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (*Time) IndexSet 

func (o *Time) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (*Time) IsFalsy 

func (o *Time) IsFalsy() bool

IsFalsy implements Object interface.

func (*Time) Iterate 

func (*Time) Iterate() Iterator

Iterate implements Object interface.

func (*Time) MarshalBinary 

func (o *Time) MarshalBinary() ([]byte, error)

MarshalBinary implements encoding.BinaryMarshaler interface.

func (*Time) MarshalJSON 

func (o *Time) MarshalJSON() ([]byte, error)

MarshalJSON implements json.JSONMarshaler interface.

func (*Time) SetMember 

func (o *Time) SetMember(idxA string, valueA Object) error

func (*Time) String 

func (o *Time) String() string

String implements Object interface.

func (*Time) TypeCode 

func (*Time) TypeCode() int

func (*Time) TypeName 

func (*Time) TypeName() string

TypeName implements Object interface.

func (*Time) UnmarshalBinary 

func (o *Time) UnmarshalBinary(data []byte) error

UnmarshalBinary implements encoding.BinaryUnmarshaler interface.

func (*Time) UnmarshalJSON 

func (o *Time) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.JSONUnmarshaler interface.

type Uint 

type Uint uint64

Uint represents unsigned integer values and implements Object interface.

func ToUint 

func ToUint(o Object) (v Uint, ok bool)

ToUint will try to convert an Object to Charlang uint value.

func (Uint) BinaryOp 

func (o Uint) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (Uint) Call 

func (o Uint) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (Uint) CallMethod 

func (o Uint) CallMethod(nameA string, argsA ...Object) (Object, error)

func (Uint) CanCall 

func (o Uint) CanCall() bool

CanCall implements Object interface.

func (Uint) CanIterate 

func (Uint) CanIterate() bool

CanIterate implements Object interface.

func (Uint) Equal 

func (o Uint) Equal(right Object) bool

Equal implements Object interface.

func (Uint) Format 

func (o Uint) Format(s fmt.State, verb rune)

Format implements fmt.Formatter interface.

func (Uint) GetMember 

func (o Uint) GetMember(idxA string) Object

func (Uint) GetValue 

func (o Uint) GetValue() Object

func (Uint) HasMemeber 

func (o Uint) HasMemeber() bool

func (Uint) IndexGet 

func (o Uint) IndexGet(index Object) (Object, error)

IndexGet implements Object interface.

func (Uint) IndexSet 

func (Uint) IndexSet(index, value Object) error

IndexSet implements Object interface.

func (Uint) IsFalsy 

func (o Uint) IsFalsy() bool

IsFalsy implements Object interface.

func (Uint) Iterate 

func (o Uint) Iterate() Iterator

Iterate implements Object interface.

func (Uint) SetMember 

func (o Uint) SetMember(idxA string, valueA Object) error

func (Uint) String 

func (o Uint) String() string

String implements Object interface.

func (Uint) TypeCode 

func (Uint) TypeCode() int

func (Uint) TypeName 

func (Uint) TypeName() string

TypeName implements Object interface.

type UintIterator 

type UintIterator struct {
	V Uint
	// contains filtered or unexported fields
}

UintIterator represents an iterator for the Int.

func (*UintIterator) Key 

func (it *UintIterator) Key() Object

Key implements Iterator interface.

func (*UintIterator) Next 

func (it *UintIterator) Next() bool

Next implements Iterator interface.

func (*UintIterator) Value 

func (it *UintIterator) Value() Object

Value implements Iterator interface.

type UndefinedType 

type UndefinedType struct {
	ObjectImpl
}

UndefinedType represents the type of global Undefined Object. One should use the UndefinedType in type switches only. UndefinedType represents the type of the global Undefined singleton. It should only be used in type switches; use the Undefined variable for values.

Type code: 0.

Key characteristics:

  • Singleton pattern: only one instance exists (global Undefined variable)
  • Represents absence of value, similar to JavaScript's undefined
  • IsFalsy() returns true (undefined is falsy in boolean context)
  • GetMember() returns Undefined for any member access (safe navigation)
  • Cannot be called, indexed, or iterated
  • Equal() returns true only when compared with Undefined itself

func (*UndefinedType) BinaryOp 

func (o *UndefinedType) BinaryOp(tok token.Token, right Object) (Object, error)

BinaryOp implements Object interface.

func (*UndefinedType) Call 

func (*UndefinedType) Call(_ ...Object) (Object, error)

Call implements Object interface.

func (*UndefinedType) CallMethod 

func (o *UndefinedType) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*UndefinedType) Equal 

func (o *UndefinedType) Equal(right Object) bool

Equal implements Object interface.

func (*UndefinedType) GetMember 

func (o *UndefinedType) GetMember(idxA string) Object

func (*UndefinedType) GetValue 

func (o *UndefinedType) GetValue() Object

func (*UndefinedType) HasMemeber 

func (o *UndefinedType) HasMemeber() bool

func (*UndefinedType) IndexGet 

func (*UndefinedType) IndexGet(key Object) (Object, error)

IndexGet implements Object interface.

func (*UndefinedType) IndexSet 

func (*UndefinedType) IndexSet(key, value Object) error

IndexSet implements Object interface.

func (*UndefinedType) SetMember 

func (o *UndefinedType) SetMember(idxA string, valueA Object) error

func (*UndefinedType) String 

func (o *UndefinedType) String() string

String implements Object interface.

func (*UndefinedType) TypeCode 

func (o *UndefinedType) TypeCode() int

func (*UndefinedType) TypeName 

func (o *UndefinedType) TypeName() string

TypeName implements Object interface.

type VM 

type VM struct {
	LeBuf     []string
	LeSshInfo map[string]string
	// contains filtered or unexported fields
}

VM executes the instructions in Bytecode. It is a stack-based virtual machine with frame-based function calls.

Key fields:

  • abort: Atomic flag to signal execution abort
  • sp: Stack pointer - points to next free slot in value stack
  • ip: Instruction pointer - current instruction offset in curInsts
  • curInsts: Current instruction slice being executed
  • constants: Constant pool from bytecode (literals, functions)
  • stack: Value stack for operands and intermediate results
  • frames: Call frame stack for function calls
  • curFrame: Current active frame
  • bytecode: The bytecode being executed
  • globals: Global variables accessible to all functions
  • pool: VM pool for instance reuse

func NewVM 

func NewVM(bc *Bytecode) *VM

NewVM creates a VM object.

func (*VM) Abort 

func (vm *VM) Abort()

Abort aborts the VM execution. It is safe to call this method from another goroutine.

func (*VM) Aborted 

func (vm *VM) Aborted() bool

Aborted reports whether VM is aborted. It is safe to call this method from another goroutine.

func (*VM) Clear 

func (vm *VM) Clear() *VM

Clear clears stack by setting nil to stack indexes and removes modules cache.

func (*VM) GetBytecode 

func (vm *VM) GetBytecode() *Bytecode

func (*VM) GetBytecodeInfo 

func (vm *VM) GetBytecodeInfo() string

func (*VM) GetCompilerOptions 

func (vm *VM) GetCompilerOptions() *CompilerOptions

func (*VM) GetCurFunc 

func (vm *VM) GetCurFunc() Object

func (*VM) GetCurInstr 

func (vm *VM) GetCurInstr() Object

func (*VM) GetGlobals 

func (vm *VM) GetGlobals() Object

GetGlobals returns global variables.

func (*VM) GetLocals 

func (vm *VM) GetLocals(locals []Object) []Object

GetLocals returns variables from stack up to the NumLocals of given Bytecode. This must be called after Run() before Clear().

func (*VM) GetLocalsQuick 

func (vm *VM) GetLocalsQuick() []Object

func (*VM) GetSrcPos 

func (vm *VM) GetSrcPos() parser.Pos

func (*VM) Run 

func (vm *VM) Run(globals Object, args ...Object) (Object, error)

Run runs VM and executes the instructions until the OpReturn Opcode or Abort call.

func (*VM) RunCompiledFunction 

func (vm *VM) RunCompiledFunction(
	f *CompiledFunction,
	globals Object,
	args ...Object,
) (Object, error)

RunCompiledFunction runs given CompiledFunction as if it is Main function. Bytecode must be set before calling this method, because Fileset and Constants are copied.

func (*VM) SetBytecode 

func (vm *VM) SetBytecode(bc *Bytecode) *VM

SetBytecode enables to set a new Bytecode.

func (*VM) SetRecover 

func (vm *VM) SetRecover(v bool) *VM

SetRecover recovers panic when Run panics and returns panic as an error. If error handler is present `try-catch-finally`, VM continues to run from catch/finally.

type ValueSetter 

type ValueSetter interface {
	SetValue(Object) error
}

type WebSocket 

type WebSocket struct {
	ObjectImpl
	Value *websocket.Conn
}

WebSocket object is used to represent the WebSocket connection WebSocket wraps websocket.Conn for WebSocket communication. It provides real-time bidirectional communication over TCP.

Type code: 701.

Key characteristics:

  • Wraps gorilla/websocket.Conn for WebSocket protocol
  • Supports both client (dial) and server (upgrade) modes
  • Provides methods for sending/receiving text and binary messages
  • Enables real-time bidirectional communication

func (*WebSocket) BinaryOp 

func (o *WebSocket) BinaryOp(tok token.Token, right Object) (Object, error)

func (*WebSocket) Call 

func (o *WebSocket) Call(_ ...Object) (Object, error)

func (*WebSocket) CallMethod 

func (o *WebSocket) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*WebSocket) CallName 

func (o *WebSocket) CallName(nameA string, c Call) (Object, error)

func (*WebSocket) CanCall 

func (o *WebSocket) CanCall() bool

func (*WebSocket) CanIterate 

func (*WebSocket) CanIterate() bool

func (*WebSocket) Close 

func (o *WebSocket) Close() error

comply to io.Closer

func (*WebSocket) Equal 

func (o *WebSocket) Equal(right Object) bool

func (*WebSocket) GetMember 

func (o *WebSocket) GetMember(idxA string) Object

func (*WebSocket) GetValue 

func (o *WebSocket) GetValue() Object

func (*WebSocket) HasMemeber 

func (o *WebSocket) HasMemeber() bool

func (*WebSocket) IndexGet 

func (o *WebSocket) IndexGet(index Object) (Object, error)

func (*WebSocket) IndexSet 

func (o *WebSocket) IndexSet(index, value Object) error

func (*WebSocket) IsFalsy 

func (o *WebSocket) IsFalsy() bool

func (*WebSocket) Iterate 

func (o *WebSocket) Iterate() Iterator

func (*WebSocket) SetMember 

func (o *WebSocket) SetMember(idxA string, valueA Object) error

func (*WebSocket) String 

func (o *WebSocket) String() string

func (*WebSocket) TypeCode 

func (*WebSocket) TypeCode() int

func (*WebSocket) TypeName 

func (*WebSocket) TypeName() string

TypeName implements Object interface.

type Writer 

type Writer struct {
	ObjectImpl
	Value io.Writer

	Members map[string]Object `json:"-"`
}

Writer object is used for represent io.Writer type value Writer wraps io.Writer for writing data to various destinations. It implements io.WriteCloser interface for stream-based writing.

Type code: 333.

Key characteristics:

  • Wraps any io.Writer (files, network connections, buffers, etc.)
  • Implements io.WriteCloser interface
  • Provides unified interface for writing to different targets
  • Supports member attachment via Members map

func (*Writer) BinaryOp 

func (o *Writer) BinaryOp(tok token.Token, right Object) (Object, error)

func (*Writer) Call 

func (o *Writer) Call(_ ...Object) (Object, error)

func (*Writer) CallMethod 

func (o *Writer) CallMethod(nameA string, argsA ...Object) (Object, error)

func (*Writer) CallName 

func (o *Writer) CallName(nameA string, c Call) (Object, error)

func (*Writer) CanCall 

func (o *Writer) CanCall() bool

func (*Writer) CanIterate 

func (*Writer) CanIterate() bool

func (*Writer) Close 

func (o *Writer) Close() error

comply to io.Closer

func (*Writer) Equal 

func (o *Writer) Equal(right Object) bool

func (*Writer) GetMember 

func (o *Writer) GetMember(idxA string) Object

func (*Writer) GetValue 

func (o *Writer) GetValue() Object

func (*Writer) HasMemeber 

func (o *Writer) HasMemeber() bool

func (*Writer) IndexGet 

func (o *Writer) IndexGet(index Object) (Object, error)

func (*Writer) IndexSet 

func (o *Writer) IndexSet(index, value Object) error

func (*Writer) IsFalsy 

func (o *Writer) IsFalsy() bool

func (*Writer) Iterate 

func (o *Writer) Iterate() Iterator

func (*Writer) SetMember 

func (o *Writer) SetMember(idxA string, valueA Object) error

func (*Writer) String 

func (o *Writer) String() string

func (*Writer) TypeCode 

func (*Writer) TypeCode() int

func (*Writer) TypeName 

func (*Writer) TypeName() string

TypeName implements Object interface.

func (*Writer) Write 

func (o *Writer) Write(p []byte) (n int, err error)

comply to io.Writer

Source Files

View all Source files

Directories

Path Synopsis
cmd
char module
dll module
docs
benchmark command
Go 斐波那契性能测试
 Go 斐波那契性能测试
internal
compat
Package parser implements a parser for Charlang source code.
 Package parser implements a parser for Charlang source code.
ex
Package ex provides ex module implementing some extra functions.
 Package ex provides ex module implementing some extra functions.
fmt
json
strings
Package strings provides strings module implementing simple functions to manipulate UTF-8 encoded strings for Charlang script language.
 Package strings provides strings module implementing simple functions to manipulate UTF-8 encoded strings for Charlang script language.
test1 module
Package token defines lexical tokens for the Charlang language.
 Package token defines lexical tokens for the Charlang language.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.