runtime/js: js for emscripten
This commit is contained in:
visualfc
707
runtime/js/js.go
Normal file
707
runtime/js/js.go
Normal file
@@ -0,0 +1,707 @@
|
||||
// Copyright 2018 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
//go:build js && wasm
|
||||
// +build js,wasm
|
||||
|
||||
// Package js gives access to the WebAssembly host environment when using the js/wasm architecture.
|
||||
// Its API is based on JavaScript semantics.
|
||||
//
|
||||
// This package is EXPERIMENTAL. Its current scope is only to allow tests to run, but not yet to provide a
|
||||
// comprehensive API for users. It is exempt from the Go compatibility promise.
|
||||
package js
|
||||
|
||||
import (
|
||||
"unsafe"
|
||||
|
||||
c "github.com/goplus/llgo/runtime/internal/clite"
|
||||
)
|
||||
|
||||
// Value represents a JavaScript value. The zero value is the JavaScript value "undefined".
|
||||
// Values can be checked for equality with the Equal method.
|
||||
type Value struct {
|
||||
ref uintptr
|
||||
}
|
||||
|
||||
func floatValue(f float64) Value {
|
||||
if f == 0 {
|
||||
return valueZero
|
||||
}
|
||||
if f != f {
|
||||
return valueNaN
|
||||
}
|
||||
return emval_new_double(f)
|
||||
}
|
||||
|
||||
func intValue(i int) Value {
|
||||
if i == 0 {
|
||||
return valueZero
|
||||
}
|
||||
return emval_new_double(float64(i))
|
||||
}
|
||||
|
||||
// Error wraps a JavaScript error.
|
||||
type Error struct {
|
||||
// Value is the underlying JavaScript error value.
|
||||
Value
|
||||
}
|
||||
|
||||
// Error implements the error interface.
|
||||
func (e Error) Error() string {
|
||||
return "JavaScript error: " + e.Get("message").String()
|
||||
}
|
||||
|
||||
/*
|
||||
var (
|
||||
valueUndefined = Value{ref: 0}
|
||||
valueNaN = predefValue(0, typeFlagNone)
|
||||
valueZero = predefValue(1, typeFlagNone)
|
||||
valueNull = predefValue(2, typeFlagNone)
|
||||
valueTrue = predefValue(3, typeFlagNone)
|
||||
valueFalse = predefValue(4, typeFlagNone)
|
||||
valueGlobal = predefValue(5, typeFlagObject)
|
||||
jsGo = predefValue(6, typeFlagObject) // instance of the Go class in JavaScript
|
||||
|
||||
objectConstructor = valueGlobal.Get("Object")
|
||||
arrayConstructor = valueGlobal.Get("Array")
|
||||
)
|
||||
*/
|
||||
|
||||
// Equal reports whether v and w are equal according to JavaScript's === operator.
|
||||
func (v Value) Equal(w Value) bool {
|
||||
return emval_equals(v, w) && v.ref != valueNaN.ref
|
||||
}
|
||||
|
||||
// Undefined returns the JavaScript value "undefined".
|
||||
func Undefined() Value {
|
||||
return valueUndefined
|
||||
}
|
||||
|
||||
// IsUndefined reports whether v is the JavaScript value "undefined".
|
||||
func (v Value) IsUndefined() bool {
|
||||
return v.ref == valueUndefined.ref
|
||||
}
|
||||
|
||||
// Null returns the JavaScript value "null".
|
||||
func Null() Value {
|
||||
return valueNull
|
||||
}
|
||||
|
||||
// IsNull reports whether v is the JavaScript value "null".
|
||||
func (v Value) IsNull() bool {
|
||||
return v.ref == valueNull.ref
|
||||
}
|
||||
|
||||
// IsNaN reports whether v is the JavaScript value "NaN".
|
||||
func (v Value) IsNaN() bool {
|
||||
return v.ref == valueNaN.ref
|
||||
}
|
||||
|
||||
// Global returns the JavaScript global object, usually "window" or "global".
|
||||
func Global() Value {
|
||||
return valueGlobal
|
||||
}
|
||||
|
||||
// ValueOf returns x as a JavaScript value:
|
||||
//
|
||||
// | Go | JavaScript |
|
||||
// | ---------------------- | ---------------------- |
|
||||
// | js.Value | [its value] |
|
||||
// | js.Func | function |
|
||||
// | nil | null |
|
||||
// | bool | boolean |
|
||||
// | integers and floats | number |
|
||||
// | string | string |
|
||||
// | []interface{} | new array |
|
||||
// | map[string]interface{} | new object |
|
||||
//
|
||||
// Panics if x is not one of the expected types.
|
||||
func ValueOf(x any) Value {
|
||||
switch x := x.(type) {
|
||||
case Value:
|
||||
return x
|
||||
case Func:
|
||||
return x.Value
|
||||
case nil:
|
||||
return valueNull
|
||||
case bool:
|
||||
if x {
|
||||
return valueTrue
|
||||
} else {
|
||||
return valueFalse
|
||||
}
|
||||
case int:
|
||||
return floatValue(float64(x))
|
||||
case int8:
|
||||
return floatValue(float64(x))
|
||||
case int16:
|
||||
return floatValue(float64(x))
|
||||
case int32:
|
||||
return floatValue(float64(x))
|
||||
case int64:
|
||||
return floatValue(float64(x))
|
||||
case uint:
|
||||
return floatValue(float64(x))
|
||||
case uint8:
|
||||
return floatValue(float64(x))
|
||||
case uint16:
|
||||
return floatValue(float64(x))
|
||||
case uint32:
|
||||
return floatValue(float64(x))
|
||||
case uint64:
|
||||
return floatValue(float64(x))
|
||||
case uintptr:
|
||||
return floatValue(float64(x))
|
||||
case unsafe.Pointer:
|
||||
return floatValue(float64(uintptr(x)))
|
||||
case float32:
|
||||
return floatValue(float64(x))
|
||||
case float64:
|
||||
return floatValue(x)
|
||||
case string:
|
||||
return stringVal(x)
|
||||
case []any:
|
||||
a := arrayConstructor.New(len(x))
|
||||
for i, s := range x {
|
||||
a.SetIndex(i, s)
|
||||
}
|
||||
return a
|
||||
case map[string]any:
|
||||
o := objectConstructor.New()
|
||||
for k, v := range x {
|
||||
o.Set(k, v)
|
||||
}
|
||||
return o
|
||||
default:
|
||||
panic("ValueOf: invalid value")
|
||||
}
|
||||
}
|
||||
|
||||
func stringVal(x string) Value {
|
||||
return emval_new_string(c.AllocaCStr(x))
|
||||
}
|
||||
|
||||
// Type represents the JavaScript type of a Value.
|
||||
type Type int
|
||||
|
||||
const (
|
||||
TypeUndefined Type = iota
|
||||
TypeNull
|
||||
TypeBoolean
|
||||
TypeNumber
|
||||
TypeString
|
||||
TypeSymbol
|
||||
TypeObject
|
||||
TypeFunction
|
||||
)
|
||||
|
||||
func (t Type) String() string {
|
||||
switch t {
|
||||
case TypeUndefined:
|
||||
return "undefined"
|
||||
case TypeNull:
|
||||
return "null"
|
||||
case TypeBoolean:
|
||||
return "boolean"
|
||||
case TypeNumber:
|
||||
return "number"
|
||||
case TypeString:
|
||||
return "string"
|
||||
case TypeSymbol:
|
||||
return "symbol"
|
||||
case TypeObject:
|
||||
return "object"
|
||||
case TypeFunction:
|
||||
return "function"
|
||||
default:
|
||||
panic("bad type")
|
||||
}
|
||||
}
|
||||
|
||||
func (t Type) isObject() bool {
|
||||
return t == TypeObject || t == TypeFunction
|
||||
}
|
||||
|
||||
// Type returns the JavaScript type of the value v. It is similar to JavaScript's typeof operator,
|
||||
// except that it returns TypeNull instead of TypeObject for null.
|
||||
func (v Value) Type() Type {
|
||||
switch v.ref {
|
||||
case valueUndefined.ref:
|
||||
return TypeUndefined
|
||||
case valueNull.ref:
|
||||
return TypeNull
|
||||
case valueTrue.ref, valueFalse.ref:
|
||||
return TypeBoolean
|
||||
}
|
||||
if emval_is_number(v) {
|
||||
return TypeNumber
|
||||
} else if emval_is_string(v) {
|
||||
return TypeString
|
||||
}
|
||||
switch emval_as_string(emval_typeof(v)) {
|
||||
case "object":
|
||||
return TypeObject
|
||||
case "symbol":
|
||||
return TypeSymbol
|
||||
case "function":
|
||||
return TypeFunction
|
||||
default:
|
||||
panic("bad type")
|
||||
}
|
||||
}
|
||||
|
||||
// Get returns the JavaScript property p of value v.
|
||||
// It panics if v is not a JavaScript object.
|
||||
func (v Value) Get(p string) Value {
|
||||
if vType := v.Type(); !vType.isObject() {
|
||||
panic(&ValueError{"Value.Get", vType})
|
||||
}
|
||||
return emval_get_property(v, stringVal(p))
|
||||
// r := makeValue(valueGet(v.ref, p))
|
||||
// runtime.KeepAlive(v)
|
||||
// return r
|
||||
}
|
||||
|
||||
// Set sets the JavaScript property p of value v to ValueOf(x).
|
||||
// It panics if v is not a JavaScript object.
|
||||
func (v Value) Set(p string, x any) {
|
||||
if vType := v.Type(); !vType.isObject() {
|
||||
panic(&ValueError{"Value.Set", vType})
|
||||
}
|
||||
// xv := ValueOf(x)
|
||||
emval_set_property(v, stringVal(p), ValueOf(x))
|
||||
// valueSet(v.ref, p, xv.ref)
|
||||
// runtime.KeepAlive(v)
|
||||
// runtime.KeepAlive(xv)
|
||||
}
|
||||
|
||||
// // valueSet sets property p of ref v to ref x.
|
||||
// //
|
||||
// // Using go:noescape is safe because no references are maintained to the
|
||||
// // Go string p after the syscall returns.
|
||||
// //
|
||||
// //go:wasmimport gojs syscall/js.valueSet
|
||||
// //go:noescape
|
||||
// func valueSet(v ref, p string, x ref)
|
||||
|
||||
// Delete deletes the JavaScript property p of value v.
|
||||
// It panics if v is not a JavaScript object.
|
||||
func (v Value) Delete(p string) {
|
||||
if vType := v.Type(); !vType.isObject() {
|
||||
panic(&ValueError{"Value.Delete", vType})
|
||||
}
|
||||
emval_delete(v, ValueOf(p))
|
||||
//valueDelete(v.ref, p)
|
||||
//runtime.KeepAlive(v)
|
||||
}
|
||||
|
||||
// // valueDelete deletes the JavaScript property p of ref v.
|
||||
// //
|
||||
// // Using go:noescape is safe because no references are maintained to the
|
||||
// // Go string p after the syscall returns.
|
||||
// //
|
||||
// //go:wasmimport gojs syscall/js.valueDelete
|
||||
// //go:noescape
|
||||
// func valueDelete(v ref, p string)
|
||||
|
||||
// Index returns JavaScript index i of value v.
|
||||
// It panics if v is not a JavaScript object.
|
||||
func (v Value) Index(i int) Value {
|
||||
if vType := v.Type(); !vType.isObject() {
|
||||
panic(&ValueError{"Value.Index", vType})
|
||||
}
|
||||
return emval_get_property(v, intValue(i))
|
||||
// r := makeValue(valueIndex(v.ref, i))
|
||||
// runtime.KeepAlive(v)
|
||||
// return r
|
||||
}
|
||||
|
||||
// //go:wasmimport gojs syscall/js.valueIndex
|
||||
// func valueIndex(v ref, i int) ref
|
||||
|
||||
// SetIndex sets the JavaScript index i of value v to ValueOf(x).
|
||||
// It panics if v is not a JavaScript object.
|
||||
func (v Value) SetIndex(i int, x any) {
|
||||
if vType := v.Type(); !vType.isObject() {
|
||||
panic(&ValueError{"Value.SetIndex", vType})
|
||||
}
|
||||
emval_set_property(v, intValue(i), ValueOf(x))
|
||||
// xv := ValueOf(x)
|
||||
// valueSetIndex(v.ref, i, xv.ref)
|
||||
// runtime.KeepAlive(v)
|
||||
// runtime.KeepAlive(xv)
|
||||
}
|
||||
|
||||
// //go:wasmimport gojs syscall/js.valueSetIndex
|
||||
// func valueSetIndex(v ref, i int, x ref)
|
||||
|
||||
// makeArgSlices makes two slices to hold JavaScript arg data.
|
||||
// It can be paired with storeArgs to make-and-store JavaScript arg slices.
|
||||
// However, the two functions are separated to ensure makeArgSlices is inlined
|
||||
// which will prevent the slices from being heap allocated for small (<=16)
|
||||
// numbers of args.
|
||||
// func makeArgSlices(size int) (argVals []Value, argRefs []ref) {
|
||||
// // value chosen for being power of two, and enough to handle all web APIs
|
||||
// // in particular, note that WebGL2's texImage2D takes up to 10 arguments
|
||||
// const maxStackArgs = 16
|
||||
// if size <= maxStackArgs {
|
||||
// // as long as makeArgs is inlined, these will be stack-allocated
|
||||
// argVals = make([]Value, size, maxStackArgs)
|
||||
// argRefs = make([]ref, size, maxStackArgs)
|
||||
// } else {
|
||||
// // allocates on the heap, but exceeding maxStackArgs should be rare
|
||||
// argVals = make([]Value, size)
|
||||
// argRefs = make([]ref, size)
|
||||
// }
|
||||
// return
|
||||
// }
|
||||
|
||||
// storeArgs maps input args onto respective Value and ref slices.
|
||||
// It can be paired with makeArgSlices to make-and-store JavaScript arg slices.
|
||||
// func storeArgs(args []any, argValsDst []Value, argRefsDst []ref) {
|
||||
// // would go in makeArgs if the combined func was simple enough to inline
|
||||
// for i, arg := range args {
|
||||
// v := ValueOf(arg)
|
||||
// argValsDst[i] = v
|
||||
// argRefsDst[i] = v.ref
|
||||
// }
|
||||
// }
|
||||
|
||||
// Length returns the JavaScript property "length" of v.
|
||||
// It panics if v is not a JavaScript object.
|
||||
func (v Value) Length() int {
|
||||
if vType := v.Type(); !vType.isObject() {
|
||||
panic(&ValueError{"Value.SetIndex", vType})
|
||||
}
|
||||
return emval_get_property(v, emval_new_string(c.Str("length"))).Int()
|
||||
//r := valueLength(v.ref)
|
||||
//runtime.KeepAlive(v)
|
||||
//return r
|
||||
}
|
||||
|
||||
// //go:wasmimport gojs syscall/js.valueLength
|
||||
// func valueLength(v ref) int
|
||||
|
||||
// Call does a JavaScript call to the method m of value v with the given arguments.
|
||||
// It panics if v has no method m.
|
||||
// The arguments get mapped to JavaScript values according to the ValueOf function.
|
||||
func (v Value) Call(m string, args ...any) (res Value) {
|
||||
var err c.Int
|
||||
if len(args) == 0 {
|
||||
res = emval_method_call(v, c.AllocaCStr(m), nil, 0, &err)
|
||||
} else {
|
||||
vargs := make([]Value, len(args))
|
||||
for i := 0; i < len(args); i++ {
|
||||
vargs[i] = ValueOf(args[i])
|
||||
}
|
||||
res = emval_method_call(v, c.AllocaCStr(m), *(**Value)(unsafe.Pointer(&vargs)), c.Int(len(args)), &err)
|
||||
}
|
||||
if err != 0 {
|
||||
if vType := v.Type(); !vType.isObject() { // check here to avoid overhead in success case
|
||||
panic(&ValueError{"Value.Call", vType})
|
||||
}
|
||||
if propType := v.Get(m).Type(); propType != TypeFunction {
|
||||
panic("syscall/js: Value.Call: property " + m + " is not a function, got " + propType.String())
|
||||
}
|
||||
panic(Error{res})
|
||||
}
|
||||
return res
|
||||
// argVals, argRefs := makeArgSlices(len(args))
|
||||
// storeArgs(args, argVals, argRefs)
|
||||
// res, ok := valueCall(v.ref, m, argRefs)
|
||||
// runtime.KeepAlive(v)
|
||||
// runtime.KeepAlive(argVals)
|
||||
// if !ok {
|
||||
// if vType := v.Type(); !vType.isObject() { // check here to avoid overhead in success case
|
||||
// panic(&ValueError{"Value.Call", vType})
|
||||
// }
|
||||
// if propType := v.Get(m).Type(); propType != TypeFunction {
|
||||
// panic("syscall/js: Value.Call: property " + m + " is not a function, got " + propType.String())
|
||||
// }
|
||||
// panic(Error{makeValue(res)})
|
||||
// }
|
||||
// return makeValue(res)
|
||||
}
|
||||
|
||||
// // valueCall does a JavaScript call to the method name m of ref v with the given arguments.
|
||||
// //
|
||||
// // Using go:noescape is safe because no references are maintained to the
|
||||
// // Go string m after the syscall returns. Additionally, the args slice
|
||||
// // is only used temporarily to collect the JavaScript objects for
|
||||
// // the JavaScript method invocation.
|
||||
// //
|
||||
// //go:wasmimport gojs syscall/js.valueCall
|
||||
// //go:nosplit
|
||||
// //go:noescape
|
||||
// func valueCall(v ref, m string, args []ref) (ref, bool)
|
||||
|
||||
// Invoke does a JavaScript call of the value v with the given arguments.
|
||||
// It panics if v is not a JavaScript function.
|
||||
// The arguments get mapped to JavaScript values according to the ValueOf function.
|
||||
func (v Value) Invoke(args ...any) (res Value) {
|
||||
var err c.Int
|
||||
if len(args) == 0 {
|
||||
res = emval_call(v, nil, 0, 0, &err)
|
||||
} else {
|
||||
vargs := make([]Value, len(args))
|
||||
for i := 0; i < len(args); i++ {
|
||||
vargs[i] = ValueOf(args[i])
|
||||
}
|
||||
res = emval_call(v, *(**Value)(unsafe.Pointer(&vargs)), c.Int(len(args)), 0, &err)
|
||||
}
|
||||
if err != 0 {
|
||||
if vType := v.Type(); vType != TypeFunction { // check here to avoid overhead in success case
|
||||
panic(&ValueError{"Value.Invoke", vType})
|
||||
}
|
||||
panic(Error{res})
|
||||
}
|
||||
return
|
||||
|
||||
// argVals, argRefs := makeArgSlices(len(args))
|
||||
// storeArgs(args, argVals, argRefs)
|
||||
// res, ok := valueInvoke(v.ref, argRefs)
|
||||
// runtime.KeepAlive(v)
|
||||
// runtime.KeepAlive(argVals)
|
||||
// if !ok {
|
||||
// if vType := v.Type(); vType != TypeFunction { // check here to avoid overhead in success case
|
||||
// panic(&ValueError{"Value.Invoke", vType})
|
||||
// }
|
||||
// panic(Error{makeValue(res)})
|
||||
// }
|
||||
// return makeValue(res)
|
||||
}
|
||||
|
||||
// valueInvoke does a JavaScript call to value v with the given arguments.
|
||||
//
|
||||
// Using go:noescape is safe because the args slice is only used temporarily
|
||||
// to collect the JavaScript objects for the JavaScript method
|
||||
// invocation.
|
||||
//
|
||||
// //go:wasmimport gojs syscall/js.valueInvoke
|
||||
// //go:noescape
|
||||
// func valueInvoke(v ref, args []ref) (ref, bool)
|
||||
|
||||
// New uses JavaScript's "new" operator with value v as constructor and the given arguments.
|
||||
// It panics if v is not a JavaScript function.
|
||||
// The arguments get mapped to JavaScript values according to the ValueOf function.
|
||||
func (v Value) New(args ...any) (res Value) {
|
||||
var err c.Int
|
||||
if len(args) == 0 {
|
||||
res = emval_call(v, nil, 0, 1, &err)
|
||||
} else {
|
||||
vargs := make([]Value, len(args))
|
||||
for i := 0; i < len(args); i++ {
|
||||
vargs[i] = ValueOf(args[i])
|
||||
}
|
||||
res = emval_call(v, *(**Value)(unsafe.Pointer(&vargs)), c.Int(len(args)), 1, &err)
|
||||
}
|
||||
if err != 0 {
|
||||
if vType := v.Type(); vType != TypeFunction { // check here to avoid overhead in success case
|
||||
panic(&ValueError{"Value.Invoke", vType})
|
||||
}
|
||||
panic(Error{res})
|
||||
}
|
||||
return
|
||||
|
||||
// argVals, argRefs := makeArgSlices(len(args))
|
||||
// storeArgs(args, argVals, argRefs)
|
||||
// res, ok := valueNew(v.ref, argRefs)
|
||||
// runtime.KeepAlive(v)
|
||||
// runtime.KeepAlive(argVals)
|
||||
// if !ok {
|
||||
// if vType := v.Type(); vType != TypeFunction { // check here to avoid overhead in success case
|
||||
// panic(&ValueError{"Value.Invoke", vType})
|
||||
// }
|
||||
// panic(Error{makeValue(res)})
|
||||
// }
|
||||
// return makeValue(res)
|
||||
}
|
||||
|
||||
// valueNew uses JavaScript's "new" operator with value v as a constructor and the given arguments.
|
||||
//
|
||||
// Using go:noescape is safe because the args slice is only used temporarily
|
||||
// to collect the JavaScript objects for the constructor execution.
|
||||
//
|
||||
// //go:wasmimport gojs syscall/js.valueNew
|
||||
// //go:noescape
|
||||
// func valueNew(v ref, args []ref) (ref, bool)
|
||||
|
||||
func (v Value) isNumber() bool {
|
||||
return v.ref == valueZero.ref ||
|
||||
v.ref == valueNaN.ref ||
|
||||
(v.ref != valueUndefined.ref && emval_is_number(v))
|
||||
}
|
||||
|
||||
func (v Value) float(method string) float64 {
|
||||
if !v.isNumber() {
|
||||
panic(&ValueError{method, v.Type()})
|
||||
}
|
||||
if v.ref == valueZero.ref {
|
||||
return 0
|
||||
}
|
||||
return emval_as_double(v)
|
||||
//return *(*float64)(unsafe.Pointer(&v.ref))
|
||||
}
|
||||
|
||||
// Float returns the value v as a float64.
|
||||
// It panics if v is not a JavaScript number.
|
||||
func (v Value) Float() float64 {
|
||||
return v.float("Value.Float")
|
||||
}
|
||||
|
||||
// Int returns the value v truncated to an int.
|
||||
// It panics if v is not a JavaScript number.
|
||||
func (v Value) Int() int {
|
||||
return int(v.float("Value.Int"))
|
||||
}
|
||||
|
||||
// Bool returns the value v as a bool.
|
||||
// It panics if v is not a JavaScript boolean.
|
||||
func (v Value) Bool() bool {
|
||||
switch v.ref {
|
||||
case valueTrue.ref:
|
||||
return true
|
||||
case valueFalse.ref:
|
||||
return false
|
||||
default:
|
||||
panic(&ValueError{"Value.Bool", v.Type()})
|
||||
}
|
||||
}
|
||||
|
||||
// Truthy returns the JavaScript "truthiness" of the value v. In JavaScript,
|
||||
// false, 0, "", null, undefined, and NaN are "falsy", and everything else is
|
||||
// "truthy". See https://developer.mozilla.org/en-US/docs/Glossary/Truthy.
|
||||
func (v Value) Truthy() bool {
|
||||
switch v.Type() {
|
||||
case TypeUndefined, TypeNull:
|
||||
return false
|
||||
case TypeBoolean:
|
||||
return v.Bool()
|
||||
case TypeNumber:
|
||||
return v.ref != valueNaN.ref && v.ref != valueZero.ref
|
||||
case TypeString:
|
||||
return v.String() != ""
|
||||
case TypeSymbol, TypeFunction, TypeObject:
|
||||
return true
|
||||
default:
|
||||
panic("bad type")
|
||||
}
|
||||
}
|
||||
|
||||
// String returns the value v as a string.
|
||||
// String is a special case because of Go's String method convention. Unlike the other getters,
|
||||
// it does not panic if v's Type is not TypeString. Instead, it returns a string of the form "<T>"
|
||||
// or "<T: V>" where T is v's type and V is a string representation of v's value.
|
||||
func (v Value) String() string {
|
||||
switch v.Type() {
|
||||
case TypeString:
|
||||
return jsString(v)
|
||||
case TypeUndefined:
|
||||
return "<undefined>"
|
||||
case TypeNull:
|
||||
return "<null>"
|
||||
case TypeBoolean:
|
||||
return "<boolean: " + jsString(v) + ">"
|
||||
case TypeNumber:
|
||||
return "<number: " + jsString(v) + ">"
|
||||
case TypeSymbol:
|
||||
return "<symbol>"
|
||||
case TypeObject:
|
||||
return "<object>"
|
||||
case TypeFunction:
|
||||
return "<function>"
|
||||
default:
|
||||
panic("bad type")
|
||||
}
|
||||
}
|
||||
|
||||
func jsString(v Value) string {
|
||||
return emval_as_string(v)
|
||||
// str, length := valuePrepareString(v.ref)
|
||||
// runtime.KeepAlive(v)
|
||||
// b := make([]byte, length)
|
||||
// valueLoadString(str, b)
|
||||
// finalizeRef(str)
|
||||
// return string(b)
|
||||
}
|
||||
|
||||
// //go:wasmimport gojs syscall/js.valuePrepareString
|
||||
// func valuePrepareString(v ref) (ref, int)
|
||||
|
||||
// valueLoadString loads string data located at ref v into byte slice b.
|
||||
//
|
||||
// Using go:noescape is safe because the byte slice is only used as a destination
|
||||
// for storing the string data and references to it are not maintained.
|
||||
//
|
||||
// //go:wasmimport gojs syscall/js.valueLoadString
|
||||
// //go:noescape
|
||||
// func valueLoadString(v ref, b []byte)
|
||||
|
||||
// InstanceOf reports whether v is an instance of type t according to JavaScript's instanceof operator.
|
||||
func (v Value) InstanceOf(t Value) bool {
|
||||
return emval_instanceof(v, t)
|
||||
// r := valueInstanceOf(v.ref, t.ref)
|
||||
// runtime.KeepAlive(v)
|
||||
// runtime.KeepAlive(t)
|
||||
// return r
|
||||
}
|
||||
|
||||
// //go:wasmimport gojs syscall/js.valueInstanceOf
|
||||
// func valueInstanceOf(v ref, t ref) bool
|
||||
|
||||
// A ValueError occurs when a Value method is invoked on
|
||||
// a Value that does not support it. Such cases are documented
|
||||
// in the description of each method.
|
||||
type ValueError struct {
|
||||
Method string
|
||||
Type Type
|
||||
}
|
||||
|
||||
func (e *ValueError) Error() string {
|
||||
return "syscall/js: call of " + e.Method + " on " + e.Type.String()
|
||||
}
|
||||
|
||||
// CopyBytesToGo copies bytes from src to dst.
|
||||
// It panics if src is not a Uint8Array or Uint8ClampedArray.
|
||||
// It returns the number of bytes copied, which will be the minimum of the lengths of src and dst.
|
||||
func CopyBytesToGo(dst []byte, src Value) int {
|
||||
return 0
|
||||
// n, ok := copyBytesToGo(dst, src.ref)
|
||||
// runtime.KeepAlive(src)
|
||||
// if !ok {
|
||||
// panic("syscall/js: CopyBytesToGo: expected src to be a Uint8Array or Uint8ClampedArray")
|
||||
// }
|
||||
// return n
|
||||
}
|
||||
|
||||
// copyBytesToGo copies bytes from src to dst.
|
||||
//
|
||||
// Using go:noescape is safe because the dst byte slice is only used as a dst
|
||||
// copy buffer and no references to it are maintained.
|
||||
//
|
||||
// //go:wasmimport gojs syscall/js.copyBytesToGo
|
||||
// //go:noescape
|
||||
// func copyBytesToGo(dst []byte, src ref) (int, bool)
|
||||
|
||||
// CopyBytesToJS copies bytes from src to dst.
|
||||
// It panics if dst is not a Uint8Array or Uint8ClampedArray.
|
||||
// It returns the number of bytes copied, which will be the minimum of the lengths of src and dst.
|
||||
func CopyBytesToJS(dst Value, src []byte) int {
|
||||
return 0
|
||||
// n, ok := copyBytesToJS(dst.ref, src)
|
||||
// runtime.KeepAlive(dst)
|
||||
// if !ok {
|
||||
// panic("syscall/js: CopyBytesToJS: expected dst to be a Uint8Array or Uint8ClampedArray")
|
||||
// }
|
||||
// return n
|
||||
}
|
||||
|
||||
// copyBytesToJS copies bytes from src to dst.
|
||||
//
|
||||
// Using go:noescape is safe because the src byte slice is only used as a src
|
||||
// copy buffer and no references to it are maintained.
|
||||
//
|
||||
// //go:wasmimport gojs syscall/js.copyBytesToJS
|
||||
// //go:noescape
|
||||
// func copyBytesToJS(dst ref, src []byte) (int, bool)
|
||||
Reference in New Issue
Block a user