7555d1c063
Adds features to support default file descriptor redirects for the target process: 1. A new command line flag '--redirect' and '-r' are added to specify file redirects for the target process 2. New syntax is added to the 'restart' command to specify file redirects. 3. Interactive instances will check if stdin/stdout and stderr are terminals and print a helpful error message if they aren't.
1284 lines
44 KiB
Go
1284 lines
44 KiB
Go
// DO NOT EDIT: auto-generated using _scripts/gen-starlark-bindings.go
|
|
|
|
package starbind
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/go-delve/delve/service/api"
|
|
"github.com/go-delve/delve/service/rpc2"
|
|
"go.starlark.net/starlark"
|
|
)
|
|
|
|
func (env *Env) starlarkPredeclare() starlark.StringDict {
|
|
r := starlark.StringDict{}
|
|
|
|
r["amend_breakpoint"] = starlark.NewBuiltin("amend_breakpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.AmendBreakpointIn
|
|
var rpcRet rpc2.AmendBreakpointOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Breakpoint, "Breakpoint")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Breakpoint":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Breakpoint, "Breakpoint")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("AmendBreakpoint", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["ancestors"] = starlark.NewBuiltin("ancestors", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.AncestorsIn
|
|
var rpcRet rpc2.AncestorsOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.GoroutineID, "GoroutineID")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.NumAncestors, "NumAncestors")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 2 && args[2] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[2], &rpcArgs.Depth, "Depth")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "GoroutineID":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.GoroutineID, "GoroutineID")
|
|
case "NumAncestors":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.NumAncestors, "NumAncestors")
|
|
case "Depth":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Depth, "Depth")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("Ancestors", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["attached_to_existing_process"] = starlark.NewBuiltin("attached_to_existing_process", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.AttachedToExistingProcessIn
|
|
var rpcRet rpc2.AttachedToExistingProcessOut
|
|
err := env.ctx.Client().CallAPI("AttachedToExistingProcess", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["cancel_next"] = starlark.NewBuiltin("cancel_next", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.CancelNextIn
|
|
var rpcRet rpc2.CancelNextOut
|
|
err := env.ctx.Client().CallAPI("CancelNext", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["checkpoint"] = starlark.NewBuiltin("checkpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.CheckpointIn
|
|
var rpcRet rpc2.CheckpointOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Where, "Where")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Where":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Where, "Where")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("Checkpoint", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["clear_breakpoint"] = starlark.NewBuiltin("clear_breakpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ClearBreakpointIn
|
|
var rpcRet rpc2.ClearBreakpointOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Id, "Id")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.Name, "Name")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Id":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Id, "Id")
|
|
case "Name":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Name, "Name")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("ClearBreakpoint", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["clear_checkpoint"] = starlark.NewBuiltin("clear_checkpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ClearCheckpointIn
|
|
var rpcRet rpc2.ClearCheckpointOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.ID, "ID")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "ID":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.ID, "ID")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("ClearCheckpoint", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["raw_command"] = starlark.NewBuiltin("raw_command", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs api.DebuggerCommand
|
|
var rpcRet rpc2.CommandOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Name, "Name")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.ThreadID, "ThreadID")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 2 && args[2] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[2], &rpcArgs.GoroutineID, "GoroutineID")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 3 && args[3] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[3], &rpcArgs.ReturnInfoLoadConfig, "ReturnInfoLoadConfig")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
} else {
|
|
cfg := env.ctx.LoadConfig()
|
|
rpcArgs.ReturnInfoLoadConfig = &cfg
|
|
}
|
|
if len(args) > 4 && args[4] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[4], &rpcArgs.Expr, "Expr")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 5 && args[5] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[5], &rpcArgs.UnsafeCall, "UnsafeCall")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Name":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Name, "Name")
|
|
case "ThreadID":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.ThreadID, "ThreadID")
|
|
case "GoroutineID":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.GoroutineID, "GoroutineID")
|
|
case "ReturnInfoLoadConfig":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.ReturnInfoLoadConfig, "ReturnInfoLoadConfig")
|
|
case "Expr":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Expr, "Expr")
|
|
case "UnsafeCall":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.UnsafeCall, "UnsafeCall")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("Command", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["create_breakpoint"] = starlark.NewBuiltin("create_breakpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.CreateBreakpointIn
|
|
var rpcRet rpc2.CreateBreakpointOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Breakpoint, "Breakpoint")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Breakpoint":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Breakpoint, "Breakpoint")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("CreateBreakpoint", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["detach"] = starlark.NewBuiltin("detach", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.DetachIn
|
|
var rpcRet rpc2.DetachOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Kill, "Kill")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Kill":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Kill, "Kill")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("Detach", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["disassemble"] = starlark.NewBuiltin("disassemble", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.DisassembleIn
|
|
var rpcRet rpc2.DisassembleOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
} else {
|
|
rpcArgs.Scope = env.ctx.Scope()
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.StartPC, "StartPC")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 2 && args[2] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[2], &rpcArgs.EndPC, "EndPC")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 3 && args[3] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[3], &rpcArgs.Flavour, "Flavour")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Scope":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
|
|
case "StartPC":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.StartPC, "StartPC")
|
|
case "EndPC":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.EndPC, "EndPC")
|
|
case "Flavour":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Flavour, "Flavour")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("Disassemble", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["eval"] = starlark.NewBuiltin("eval", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.EvalIn
|
|
var rpcRet rpc2.EvalOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
} else {
|
|
rpcArgs.Scope = env.ctx.Scope()
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.Expr, "Expr")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 2 && args[2] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[2], &rpcArgs.Cfg, "Cfg")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
} else {
|
|
cfg := env.ctx.LoadConfig()
|
|
rpcArgs.Cfg = &cfg
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Scope":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
|
|
case "Expr":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Expr, "Expr")
|
|
case "Cfg":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Cfg, "Cfg")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("Eval", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["examine_memory"] = starlark.NewBuiltin("examine_memory", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ExamineMemoryIn
|
|
var rpcRet rpc2.ExaminedMemoryOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Address, "Address")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.Length, "Length")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Address":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Address, "Address")
|
|
case "Length":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Length, "Length")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("ExamineMemory", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["find_location"] = starlark.NewBuiltin("find_location", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.FindLocationIn
|
|
var rpcRet rpc2.FindLocationOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
} else {
|
|
rpcArgs.Scope = env.ctx.Scope()
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.Loc, "Loc")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 2 && args[2] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[2], &rpcArgs.IncludeNonExecutableLines, "IncludeNonExecutableLines")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Scope":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
|
|
case "Loc":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Loc, "Loc")
|
|
case "IncludeNonExecutableLines":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.IncludeNonExecutableLines, "IncludeNonExecutableLines")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("FindLocation", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["function_return_locations"] = starlark.NewBuiltin("function_return_locations", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.FunctionReturnLocationsIn
|
|
var rpcRet rpc2.FunctionReturnLocationsOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.FnName, "FnName")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "FnName":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.FnName, "FnName")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("FunctionReturnLocations", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["get_breakpoint"] = starlark.NewBuiltin("get_breakpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.GetBreakpointIn
|
|
var rpcRet rpc2.GetBreakpointOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Id, "Id")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.Name, "Name")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Id":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Id, "Id")
|
|
case "Name":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Name, "Name")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("GetBreakpoint", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["get_thread"] = starlark.NewBuiltin("get_thread", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.GetThreadIn
|
|
var rpcRet rpc2.GetThreadOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Id, "Id")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Id":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Id, "Id")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("GetThread", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["is_multiclient"] = starlark.NewBuiltin("is_multiclient", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.IsMulticlientIn
|
|
var rpcRet rpc2.IsMulticlientOut
|
|
err := env.ctx.Client().CallAPI("IsMulticlient", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["last_modified"] = starlark.NewBuiltin("last_modified", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.LastModifiedIn
|
|
var rpcRet rpc2.LastModifiedOut
|
|
err := env.ctx.Client().CallAPI("LastModified", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["breakpoints"] = starlark.NewBuiltin("breakpoints", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListBreakpointsIn
|
|
var rpcRet rpc2.ListBreakpointsOut
|
|
err := env.ctx.Client().CallAPI("ListBreakpoints", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["checkpoints"] = starlark.NewBuiltin("checkpoints", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListCheckpointsIn
|
|
var rpcRet rpc2.ListCheckpointsOut
|
|
err := env.ctx.Client().CallAPI("ListCheckpoints", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["dynamic_libraries"] = starlark.NewBuiltin("dynamic_libraries", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListDynamicLibrariesIn
|
|
var rpcRet rpc2.ListDynamicLibrariesOut
|
|
err := env.ctx.Client().CallAPI("ListDynamicLibraries", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["function_args"] = starlark.NewBuiltin("function_args", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListFunctionArgsIn
|
|
var rpcRet rpc2.ListFunctionArgsOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
} else {
|
|
rpcArgs.Scope = env.ctx.Scope()
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.Cfg, "Cfg")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
} else {
|
|
rpcArgs.Cfg = env.ctx.LoadConfig()
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Scope":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
|
|
case "Cfg":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Cfg, "Cfg")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("ListFunctionArgs", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["functions"] = starlark.NewBuiltin("functions", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListFunctionsIn
|
|
var rpcRet rpc2.ListFunctionsOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Filter, "Filter")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Filter":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Filter, "Filter")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("ListFunctions", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["goroutines"] = starlark.NewBuiltin("goroutines", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListGoroutinesIn
|
|
var rpcRet rpc2.ListGoroutinesOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Start, "Start")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.Count, "Count")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Start":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Start, "Start")
|
|
case "Count":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Count, "Count")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("ListGoroutines", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["local_vars"] = starlark.NewBuiltin("local_vars", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListLocalVarsIn
|
|
var rpcRet rpc2.ListLocalVarsOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
} else {
|
|
rpcArgs.Scope = env.ctx.Scope()
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.Cfg, "Cfg")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
} else {
|
|
rpcArgs.Cfg = env.ctx.LoadConfig()
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Scope":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
|
|
case "Cfg":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Cfg, "Cfg")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("ListLocalVars", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["package_vars"] = starlark.NewBuiltin("package_vars", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListPackageVarsIn
|
|
var rpcRet rpc2.ListPackageVarsOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Filter, "Filter")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.Cfg, "Cfg")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
} else {
|
|
rpcArgs.Cfg = env.ctx.LoadConfig()
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Filter":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Filter, "Filter")
|
|
case "Cfg":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Cfg, "Cfg")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("ListPackageVars", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["packages_build_info"] = starlark.NewBuiltin("packages_build_info", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListPackagesBuildInfoIn
|
|
var rpcRet rpc2.ListPackagesBuildInfoOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.IncludeFiles, "IncludeFiles")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "IncludeFiles":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.IncludeFiles, "IncludeFiles")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("ListPackagesBuildInfo", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["registers"] = starlark.NewBuiltin("registers", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListRegistersIn
|
|
var rpcRet rpc2.ListRegistersOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.ThreadID, "ThreadID")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.IncludeFp, "IncludeFp")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 2 && args[2] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[2], &rpcArgs.Scope, "Scope")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
} else {
|
|
scope := env.ctx.Scope()
|
|
rpcArgs.Scope = &scope
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "ThreadID":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.ThreadID, "ThreadID")
|
|
case "IncludeFp":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.IncludeFp, "IncludeFp")
|
|
case "Scope":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("ListRegisters", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["sources"] = starlark.NewBuiltin("sources", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListSourcesIn
|
|
var rpcRet rpc2.ListSourcesOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Filter, "Filter")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Filter":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Filter, "Filter")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("ListSources", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["threads"] = starlark.NewBuiltin("threads", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListThreadsIn
|
|
var rpcRet rpc2.ListThreadsOut
|
|
err := env.ctx.Client().CallAPI("ListThreads", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["types"] = starlark.NewBuiltin("types", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ListTypesIn
|
|
var rpcRet rpc2.ListTypesOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Filter, "Filter")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Filter":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Filter, "Filter")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("ListTypes", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["process_pid"] = starlark.NewBuiltin("process_pid", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.ProcessPidIn
|
|
var rpcRet rpc2.ProcessPidOut
|
|
err := env.ctx.Client().CallAPI("ProcessPid", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["recorded"] = starlark.NewBuiltin("recorded", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.RecordedIn
|
|
var rpcRet rpc2.RecordedOut
|
|
err := env.ctx.Client().CallAPI("Recorded", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["restart"] = starlark.NewBuiltin("restart", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.RestartIn
|
|
var rpcRet rpc2.RestartOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Position, "Position")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.ResetArgs, "ResetArgs")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 2 && args[2] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[2], &rpcArgs.NewArgs, "NewArgs")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 3 && args[3] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[3], &rpcArgs.Rerecord, "Rerecord")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 4 && args[4] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[4], &rpcArgs.Rebuild, "Rebuild")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 5 && args[5] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[5], &rpcArgs.NewRedirects, "NewRedirects")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Position":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Position, "Position")
|
|
case "ResetArgs":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.ResetArgs, "ResetArgs")
|
|
case "NewArgs":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.NewArgs, "NewArgs")
|
|
case "Rerecord":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Rerecord, "Rerecord")
|
|
case "Rebuild":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Rebuild, "Rebuild")
|
|
case "NewRedirects":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.NewRedirects, "NewRedirects")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("Restart", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["set_expr"] = starlark.NewBuiltin("set_expr", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.SetIn
|
|
var rpcRet rpc2.SetOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
} else {
|
|
rpcArgs.Scope = env.ctx.Scope()
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.Symbol, "Symbol")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 2 && args[2] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[2], &rpcArgs.Value, "Value")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Scope":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
|
|
case "Symbol":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Symbol, "Symbol")
|
|
case "Value":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Value, "Value")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("Set", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["stacktrace"] = starlark.NewBuiltin("stacktrace", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.StacktraceIn
|
|
var rpcRet rpc2.StacktraceOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.Id, "Id")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 1 && args[1] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[1], &rpcArgs.Depth, "Depth")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 2 && args[2] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[2], &rpcArgs.Full, "Full")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 3 && args[3] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[3], &rpcArgs.Defers, "Defers")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 4 && args[4] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[4], &rpcArgs.Opts, "Opts")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
if len(args) > 5 && args[5] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[5], &rpcArgs.Cfg, "Cfg")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "Id":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Id, "Id")
|
|
case "Depth":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Depth, "Depth")
|
|
case "Full":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Full, "Full")
|
|
case "Defers":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Defers, "Defers")
|
|
case "Opts":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Opts, "Opts")
|
|
case "Cfg":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.Cfg, "Cfg")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("Stacktrace", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
r["state"] = starlark.NewBuiltin("state", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
|
|
if err := isCancelled(thread); err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
var rpcArgs rpc2.StateIn
|
|
var rpcRet rpc2.StateOut
|
|
if len(args) > 0 && args[0] != starlark.None {
|
|
err := unmarshalStarlarkValue(args[0], &rpcArgs.NonBlocking, "NonBlocking")
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
for _, kv := range kwargs {
|
|
var err error
|
|
switch kv[0].(starlark.String) {
|
|
case "NonBlocking":
|
|
err = unmarshalStarlarkValue(kv[1], &rpcArgs.NonBlocking, "NonBlocking")
|
|
default:
|
|
err = fmt.Errorf("unknown argument %q", kv[0])
|
|
}
|
|
if err != nil {
|
|
return starlark.None, decorateError(thread, err)
|
|
}
|
|
}
|
|
err := env.ctx.Client().CallAPI("State", &rpcArgs, &rpcRet)
|
|
if err != nil {
|
|
return starlark.None, err
|
|
}
|
|
return env.interfaceToStarlarkValue(rpcRet), nil
|
|
})
|
|
return r
|
|
}
|