95e7cafd0c
* terminal/command: Add 'reload' command These changes add the 'reload' command, which allows us to rebuild the project and start the debugging session again. Currently, if the project's code is updated while debugging it, Delve shows the new source code, but it's still running the old one. With 'reload', the whole binary is rebuilt, and the process starts again. Fixes #1551 * Remove unnecessary print Changes to be committed: modified: pkg/terminal/command.go * Add tests and refactor the code Changes to be committed: modified: cmd/dlv/cmds/commands.go modified: go.mod modified: pkg/terminal/command.go modified: service/config.go modified: service/debugger/debugger.go modified: service/test/integration2_test.go * Fix typo in the comment Changes to be committed: modified: service/debugger/debugger.go * Fix typo in the name of the variables The variables are local therefore the capitalization is not needed Changes to be committed: modified: cmd/dlv/cmds/commands.go * Call GoTestBuild Also, remove the := to avoid redeclaration * Change the Kind in the tests Change from debugger.ExecutingGeneratedTest to debugger.ExecutingGeneratedFile for consistency. We are generating a real binary instead of a test one so ExecutingGeneratedFile makes more sense here. Changes to be committed: modified: service/test/integration2_test.go * Avoid breakpoints based on addresses Changes to be committed: modified: service/debugger/debugger.go * Update the rebuild behaviour There are a few cases where we can't rebuild the binary because we don't know how it was build. Changes to be committed: modified: service/debugger/debugger.go * Fix typos and update documentation Changes to be committed: modified: Documentation/cli/README.md modified: pkg/terminal/command.go modified: service/config.go modified: service/debugger/debugger.go * Fix typo * Remove variables They were added to the debugger.Config * Rename variable Rename Kind to ExecuteKind to make it more accurate Changes to be committed: modified: cmd/dlv/cmds/commands.go modified: service/debugger/debugger.go modified: service/test/integration2_test.go
1276 lines
44 KiB
Go
1276 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)
|
|
}
|
|
}
|
|
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")
|
|
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
|
|
}
|