func init() {
	name := "enable"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: EnableCommand,
		Help: `enable [bpnum1 ...]

Enable a breakpoint by the number assigned to it.`,

		Min_args: 0,
		Max_args: -1,
	}
	gub.AddToCategory("breakpoints", name)
}

func init() {
	name := "jump"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: JumpCommand,
		Help: `jump *num*

Jumps to instruction *num* inside the current basic block.
`,
		Min_args: 1,
		Max_args: 1,
	}
	gub.AddToCategory("running", name)
}

func init() {
	name := "whatis"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: WhatisCommand,
		Help: `whatis *name*

print information about *name* which can include a dotted variable name.
`,
		Min_args: 1,
		Max_args: 1,
	}
	gub.AddToCategory("inspecting", name)
}

func init() {
	name := "disable"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: DisableCommand,
		Help: `Disable [bpnum1 ...]

Disable a breakpoint by its breakpoint number.

See also "enable", "delete", and "info break"`,
		Min_args: 0,
		Max_args: -1,
	}
	gub.AddToCategory("breakpoints", name)
}

func init() {
	name := "delete"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: DeleteCommand,
		Help: `Delete [bpnum1 ...]

Delete a breakpoint by breakpoint number.
`,

		Min_args: 0,
		Max_args: -1,
	}
	gub.AddToCategory("breakpoints", name)
	// Down the line we'll have abbrevs
	gub.AddAlias("del", name)
}

func init() {
	name := "continue"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: ContinueCommand,
		Help: `continue

Leave the debugger loop and continue execution. Subsequent entry to
the debugger however may occur via breakpoints or explicit calls, or
exceptions.
`,
		Min_args: 0,
		Max_args: 0,
	}
	gub.AddAlias("c", name)
	gub.AddToCategory("running", name)
}

func init() {
	name := "down"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: DownCommand,
		Help: `down [*count*]

Move the current frame down in the stack trace (to a newer frame). 0
is the most recent frame. If no count is given, move down 1.

See also 'up' and 'frame'.
`,
		Min_args: 0,
		Max_args: 1,
	}
	gub.AddToCategory("stack", name)
}

func init() {
	name := "stepi"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: StepInstructionCommand,
		Help: `stepi

Execute one SSA instrcution and stop.

See also step, and next.
`,
		Min_args: 0,
		Max_args: 0,
	}
	gub.AddToCategory("running", name)
	// Down the line we'll have abbrevs
}

func init() {
	name := "up"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: UpCommand,
		Help: `up [*count*]

Move the current frame up in the stack trace (to a older frame). 0
is the most-recent frame. If no count is given, move down 1.

See also 'down' and 'frame'.
`,
		Min_args: 0,
		Max_args: 1,
	}
	gub.AddToCategory("stack", name)
}

func init() {
	name := "set"
	gub.Cmds[name] = &gub.CmdInfo{
		SubcmdMgr: &gub.SubcmdMgr{
			Name:    name,
			Subcmds: make(gub.SubcmdMap),
		},
		Fn: SetCommand,
		Help: `Modifies parts of the debugger environment.

Type "set" for a list of "set" subcommands and what they do.`,
		Min_args: 0,
		Max_args: 3,
	}
	gub.AddToCategory("support", name)
}

func init() {
	name := "environment"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: EnvironmentCommand,
		Help: `environment [*name*]

print current runtime environment values.
If *name* is supplied, only show that name.
`,
		Min_args: 0,
		Max_args: 1,
	}
	gub.AddToCategory("inspecting", name)
	// Down the line we'll have abbrevs
	gub.AddAlias("env", name)
	gub.AddAlias("environ", name)
}

func init() {
	name := "locations"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: LocationsCommand,
		Help: `locations

Give list of all the stopping locations in the package
`,
		Min_args: 0,
		Max_args: 1,
	}
	gub.AddToCategory("status", name)
	// Down the line we'll have abbrevs
	gub.AddAlias("locs", name)
	gub.AddAlias("loc", name)
	gub.AddAlias("location", name)
}

func init() {
	name := "run"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: RunCommand,
		Help: `run

Terminates program. If an exit code is given, that is the exit code
for the program. Zero (normal termination) is used if no
termintation code.
`,
		Min_args: 0,
		Max_args: 0,
	}
	gub.AddToCategory("running", name)
	gub.AddAlias("R", name)
	gub.AddAlias("restart", name)
}

func init() {
	name := "next"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: NextCommand,
		Help: `next

Step one statement ignoring steps into function calls at this level.

Sometimes this is called 'step over'.
`,
		Min_args: 0,
		Max_args: 0,
	}
	gub.AddToCategory("running", name)
	// Down the line we'll have abbrevs
	gub.AddAlias("n", name)
}

func init() {
	name := "show"
	gub.Cmds[name] = &gub.CmdInfo{
		SubcmdMgr: &gub.SubcmdMgr{
			Name:    name,
			Subcmds: make(gub.SubcmdMap),
		},
		Fn: ShowCommand,
		Help: `Generic command for showing things about the debugger.

Type "set" for a list of "set" subcommands and what they do.
Type "help set *" for just a list of "info" subcommands.`,
		Min_args: 0,
		Max_args: 3,
	}
	gub.AddToCategory("support", name)
}

func init() {
	name := "instruction"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: InstructionCommand,
		Help: `instruction [num [operand]]

Print information about instruction
`,
		Min_args: 0,
		Max_args: 2,
	}
	gub.AddToCategory("inspecting", name)
	// Down the line we'll have abbrevs
	gub.AddAlias("inst", name)
	gub.AddAlias("instr", name)
	gub.AddAlias("instruct", name)
}

func init() {
	name := "quit"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: QuitCommand,
		Help: `quit [exit-code]

Terminates program. If an exit code is given, that is the exit code
for the program. Zero (normal termination) is used if no
termintation code.
`,
		Min_args: 0,
		Max_args: 1,
	}
	gub.AddToCategory("support", name)
	gub.AddAlias("exit", name)
	// Down the line we'll have abbrevs
	gub.AddAlias("q", name)
}

func init() {
	name := "disassemble"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: DisassembleCommand,
		Help: `disassemble [*fn* | *int* | . | + ]

disassemble SSA instructions. Without any parameters we disassemble the
current instruction. If a function name is given, that is disassembled.
If a number is given that is the block number of the current frame.
If "." is given we disassemble the current block only. If "+" we disassemble
the current function.
`,
		Min_args: 0,
		Max_args: 1,
	}
	gub.AddToCategory("inspecting", name)
	gub.AddAlias("disasm", name)
}

func init() {
	name := "step"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: StepCommand,
		Help: `step

Execute the current statement, stopping at the next event.  Sometimes this
is called 'step into'.

See also: stepi, continue, finish, and next.
`,
		Min_args: 0,
		Max_args: 0,
	}
	gub.AddToCategory("running", name)
	// Down the line we'll have abbrevs
	gub.AddAlias("s", name)
}

func init() {
	name := "goroutines"
	gub.Cmds[name] = &gub.CmdInfo{
		Fn: GoroutinesCommand,
		Help: `goroutines [*id*]

Without a parameter, list stack traces for each active goroutine. If an id
is given only that goroutine stack trace is shown. The main (first) goroutine is 0.
`,
		Min_args: 0,
		Max_args: 1,
	}
	gub.AddToCategory("stack", name)
	gub.AddAlias("gore", name)
	// Down the line we'll have abbrevs
	gub.AddAlias("gor", name)
	gub.AddAlias("goroutine", name)
}