summaryrefslogtreecommitdiff
path: root/src/pkg/exp/ogle/cmd.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/exp/ogle/cmd.go')
-rw-r--r--src/pkg/exp/ogle/cmd.go210
1 files changed, 105 insertions, 105 deletions
diff --git a/src/pkg/exp/ogle/cmd.go b/src/pkg/exp/ogle/cmd.go
index 2e75fe519..45b47ef5b 100644
--- a/src/pkg/exp/ogle/cmd.go
+++ b/src/pkg/exp/ogle/cmd.go
@@ -6,52 +6,52 @@
package ogle
import (
- "bufio";
- "debug/elf";
- "debug/proc";
- "exp/eval";
- "fmt";
- "go/scanner";
- "go/token";
- "os";
- "strconv";
- "strings";
+ "bufio"
+ "debug/elf"
+ "debug/proc"
+ "exp/eval"
+ "fmt"
+ "go/scanner"
+ "go/token"
+ "os"
+ "strconv"
+ "strings"
)
var world *eval.World
var curProc *Process
func Main() {
- world = eval.NewWorld();
- defineFuncs();
- r := bufio.NewReader(os.Stdin);
+ world = eval.NewWorld()
+ defineFuncs()
+ r := bufio.NewReader(os.Stdin)
for {
- print("; ");
- line, err := r.ReadSlice('\n');
+ print("; ")
+ line, err := r.ReadSlice('\n')
if err != nil {
break
}
// Try line as a command
- cmd, rest := getCmd(line);
+ cmd, rest := getCmd(line)
if cmd != nil {
- err := cmd.handler(rest);
+ err := cmd.handler(rest)
if err != nil {
scanner.PrintError(os.Stderr, err)
}
- continue;
+ continue
}
// Try line as code
- code, err := world.Compile(string(line));
+ code, err := world.Compile(string(line))
if err != nil {
- scanner.PrintError(os.Stderr, err);
- continue;
+ scanner.PrintError(os.Stderr, err)
+ continue
}
- v, err := code.Run();
+ v, err := code.Run()
if err != nil {
- fmt.Fprintf(os.Stderr, err.String());
- continue;
+ fmt.Fprintf(os.Stderr, err.String())
+ continue
}
if v != nil {
println(v.String())
@@ -61,11 +61,11 @@ func Main() {
// newScanner creates a new scanner that scans that given input bytes.
func newScanner(input []byte) (*scanner.Scanner, *scanner.ErrorVector) {
- sc := new(scanner.Scanner);
- ev := new(scanner.ErrorVector);
- sc.Init("input", input, ev, 0);
+ sc := new(scanner.Scanner)
+ ev := new(scanner.ErrorVector)
+ sc.Init("input", input, ev, 0)
- return sc, ev;
+ return sc, ev
}
/*
@@ -75,12 +75,12 @@ func newScanner(input []byte) (*scanner.Scanner, *scanner.ErrorVector) {
// A UsageError occurs when a command is called with illegal arguments.
type UsageError string
-func (e UsageError) String() string { return string(e) }
+func (e UsageError) String() string { return string(e) }
// A cmd represents a single command with a handler.
type cmd struct {
- cmd string;
- handler func([]byte) os.Error;
+ cmd string
+ handler func([]byte) os.Error
}
var cmds = []cmd{
@@ -92,19 +92,19 @@ var cmds = []cmd{
// successful, it returns the command and the bytes remaining after
// the command, which should be passed to the command.
func getCmd(line []byte) (*cmd, []byte) {
- sc, _ := newScanner(line);
- pos, tok, lit := sc.Scan();
+ sc, _ := newScanner(line)
+ pos, tok, lit := sc.Scan()
if sc.ErrorCount != 0 || tok != token.IDENT {
return nil, nil
}
- slit := string(lit);
+ slit := string(lit)
for i := range cmds {
if cmds[i].cmd == slit {
return &cmds[i], line[pos.Offset+len(lit):]
}
}
- return nil, nil;
+ return nil, nil
}
// cmdLoad starts or attaches to a process. Its form is similar to
@@ -124,7 +124,7 @@ func getCmd(line []byte) (*cmd, []byte) {
//
// load always sets the current process to the loaded process.
func cmdLoad(args []byte) os.Error {
- ident, path, err := parseLoad(args);
+ ident, path, err := parseLoad(args)
if err != nil {
return err
}
@@ -136,99 +136,99 @@ func cmdLoad(args []byte) os.Error {
}
// Parse argument and start or attach to process
- var fname string;
- var tproc proc.Process;
+ var fname string
+ var tproc proc.Process
if len(path) >= 4 && path[0:4] == "pid:" {
- pid, err := strconv.Atoi(path[4:]);
+ pid, err := strconv.Atoi(path[4:])
if err != nil {
return err
}
- fname, err = os.Readlink(fmt.Sprintf("/proc/%d/exe", pid));
+ fname, err = os.Readlink(fmt.Sprintf("/proc/%d/exe", pid))
if err != nil {
return err
}
- tproc, err = proc.Attach(pid);
+ tproc, err = proc.Attach(pid)
if err != nil {
return err
}
- println("Attached to", pid);
+ println("Attached to", pid)
} else {
- parts := strings.Split(path, " ", 0);
+ parts := strings.Split(path, " ", 0)
if len(parts) == 0 {
fname = ""
} else {
fname = parts[0]
}
- tproc, err = proc.ForkExec(fname, parts, os.Environ(), "", []*os.File{os.Stdin, os.Stdout, os.Stderr});
+ tproc, err = proc.ForkExec(fname, parts, os.Environ(), "", []*os.File{os.Stdin, os.Stdout, os.Stderr})
if err != nil {
return err
}
- println("Started", path);
+ println("Started", path)
// TODO(austin) If we fail after this point, kill tproc
// before detaching.
}
// Get symbols
- f, err := os.Open(fname, os.O_RDONLY, 0);
+ f, err := os.Open(fname, os.O_RDONLY, 0)
if err != nil {
- tproc.Detach();
- return err;
+ tproc.Detach()
+ return err
}
- defer f.Close();
- elf, err := elf.NewFile(f);
+ defer f.Close()
+ elf, err := elf.NewFile(f)
if err != nil {
- tproc.Detach();
- return err;
+ tproc.Detach()
+ return err
}
- curProc, err = NewProcessElf(tproc, elf);
+ curProc, err = NewProcessElf(tproc, elf)
if err != nil {
- tproc.Detach();
- return err;
+ tproc.Detach()
+ return err
}
// Prepare new process
- curProc.OnGoroutineCreate().AddHandler(EventPrint);
- curProc.OnGoroutineExit().AddHandler(EventPrint);
+ curProc.OnGoroutineCreate().AddHandler(EventPrint)
+ curProc.OnGoroutineExit().AddHandler(EventPrint)
- err = curProc.populateWorld(world);
+ err = curProc.populateWorld(world)
if err != nil {
- tproc.Detach();
- return err;
+ tproc.Detach()
+ return err
}
- return nil;
+ return nil
}
func parseLoad(args []byte) (ident string, path string, err os.Error) {
- err = UsageError("Usage: load [sym] \"path\"");
- sc, ev := newScanner(args);
+ err = UsageError("Usage: load [sym] \"path\"")
+ sc, ev := newScanner(args)
- var toks [4]token.Token;
- var lits [4][]byte;
+ var toks [4]token.Token
+ var lits [4][]byte
for i := range toks {
_, toks[i], lits[i] = sc.Scan()
}
if sc.ErrorCount != 0 {
- err = ev.GetError(scanner.NoMultiples);
- return;
+ err = ev.GetError(scanner.NoMultiples)
+ return
}
- i := 0;
+ i := 0
switch toks[i] {
case token.PERIOD, token.IDENT:
- ident = string(lits[i]);
- i++;
+ ident = string(lits[i])
+ i++
}
if toks[i] != token.STRING {
return
}
- path, uerr := strconv.Unquote(string(lits[i]));
+ path, uerr := strconv.Unquote(string(lits[i]))
if uerr != nil {
- err = uerr;
- return;
+ err = uerr
+ return
}
- i++;
+ i++
if toks[i] == token.SEMICOLON {
i++
@@ -237,13 +237,13 @@ func parseLoad(args []byte) (ident string, path string, err os.Error) {
return
}
- return ident, path, nil;
+ return ident, path, nil
}
// cmdBt prints a backtrace for the current goroutine. It takes no
// arguments.
func cmdBt(args []byte) os.Error {
- err := parseNoArgs(args, "Usage: bt");
+ err := parseNoArgs(args, "Usage: bt")
if err != nil {
return err
}
@@ -252,10 +252,10 @@ func cmdBt(args []byte) os.Error {
return NoCurrentGoroutine{}
}
- f := curProc.curGoroutine.frame;
+ f := curProc.curGoroutine.frame
if f == nil {
- fmt.Println("No frames on stack");
- return nil;
+ fmt.Println("No frames on stack")
+ return nil
}
for f.Inner() != nil {
@@ -268,8 +268,8 @@ func cmdBt(args []byte) os.Error {
} else {
fmt.Printf(" ")
}
- fmt.Printf("%8x %v\n", f.pc, f);
- f, err = f.Outer();
+ fmt.Printf("%8x %v\n", f.pc, f)
+ f, err = f.Outer()
if err != nil {
return err
}
@@ -278,20 +278,20 @@ func cmdBt(args []byte) os.Error {
}
}
- fmt.Println("...");
- return nil;
+ fmt.Println("...")
+ return nil
}
func parseNoArgs(args []byte, usage string) os.Error {
- sc, ev := newScanner(args);
- _, tok, _ := sc.Scan();
+ sc, ev := newScanner(args)
+ _, tok, _ := sc.Scan()
if sc.ErrorCount != 0 {
return ev.GetError(scanner.NoMultiples)
}
if tok != token.EOF {
return UsageError(usage)
}
- return nil;
+ return nil
}
/*
@@ -300,12 +300,12 @@ func parseNoArgs(args []byte, usage string) os.Error {
// defineFuncs populates world with the built-in functions.
func defineFuncs() {
- t, v := eval.FuncFromNativeTyped(fnOut, fnOutSig);
- world.DefineConst("Out", t, v);
- t, v = eval.FuncFromNativeTyped(fnContWait, fnContWaitSig);
- world.DefineConst("ContWait", t, v);
- t, v = eval.FuncFromNativeTyped(fnBpSet, fnBpSetSig);
- world.DefineConst("BpSet", t, v);
+ t, v := eval.FuncFromNativeTyped(fnOut, fnOutSig)
+ world.DefineConst("Out", t, v)
+ t, v = eval.FuncFromNativeTyped(fnContWait, fnContWaitSig)
+ world.DefineConst("ContWait", t, v)
+ t, v = eval.FuncFromNativeTyped(fnBpSet, fnBpSetSig)
+ world.DefineConst("BpSet", t, v)
}
// printCurFrame prints the current stack frame, as it would appear in
@@ -314,47 +314,47 @@ func printCurFrame() {
if curProc == nil || curProc.curGoroutine == nil {
return
}
- f := curProc.curGoroutine.frame;
+ f := curProc.curGoroutine.frame
if f == nil {
return
}
- fmt.Printf("=> %8x %v\n", f.pc, f);
+ fmt.Printf("=> %8x %v\n", f.pc, f)
}
// fnOut moves the current frame to the caller of the current frame.
-func fnOutSig() {}
+func fnOutSig() {}
func fnOut(t *eval.Thread, args []eval.Value, res []eval.Value) {
if curProc == nil {
t.Abort(NoCurrentGoroutine{})
}
- err := curProc.Out();
+ err := curProc.Out()
if err != nil {
t.Abort(err)
}
// TODO(austin) Only in the command form
- printCurFrame();
+ printCurFrame()
}
// fnContWait continues the current process and waits for a stopping event.
-func fnContWaitSig() {}
+func fnContWaitSig() {}
func fnContWait(t *eval.Thread, args []eval.Value, res []eval.Value) {
if curProc == nil {
t.Abort(NoCurrentGoroutine{})
}
- err := curProc.ContWait();
+ err := curProc.ContWait()
if err != nil {
t.Abort(err)
}
// TODO(austin) Only in the command form
- ev := curProc.Event();
+ ev := curProc.Event()
if ev != nil {
fmt.Printf("%v\n", ev)
}
- printCurFrame();
+ printCurFrame()
}
// fnBpSet sets a breakpoint at the entry to the named function.
-func fnBpSetSig(string) {}
+func fnBpSetSig(string) {}
func fnBpSet(t *eval.Thread, args []eval.Value, res []eval.Value) {
// TODO(austin) This probably shouldn't take a symbol name.
// Perhaps it should take an interface that provides PC's.
@@ -363,10 +363,10 @@ func fnBpSet(t *eval.Thread, args []eval.Value, res []eval.Value) {
if curProc == nil {
t.Abort(NoCurrentGoroutine{})
}
- name := args[0].(eval.StringValue).Get(t);
- fn := curProc.syms.LookupFunc(name);
+ name := args[0].(eval.StringValue).Get(t)
+ fn := curProc.syms.LookupFunc(name)
if fn == nil {
t.Abort(UsageError("no such function " + name))
}
- curProc.OnBreakpoint(proc.Word(fn.Entry)).AddHandler(EventStop);
+ curProc.OnBreakpoint(proc.Word(fn.Entry)).AddHandler(EventStop)
}
generated by cgit v1.2.3 (git 2.46.0) at 2025-10-17 15:01:57 +0000