[GetWorld, GFHFromTV, IsRemote, RemoteGFHFromTV, TVToCardinal],

[Class, DynamicParent, Error, Signal, TVType, TypeClass],

[Abort, Action, ActionError, ActionId, Event, ForceChange, NextPendingAction, PeekData, TakeData, WaitForChange],

[AddBreakToList, BreakId, BreakIndex, ClearAllBreaks, ClearBreak, CondProc, FindBreakId, NextBreak, NullIndex],

[Context, ContextForLocalFrame, ContextForWorld, GetContents, GetDefaultGlobalContext, SetDefaultGlobalContext],

[GetDefaultActionAndContext, SameLocalFrame, SetDefaultActionAndContext],

[EntryLocation, ExitLocation, GFandPCFromLocation, IsLocationAtLocation, Location, LocationToSource, TVFromLocation],

[CreateEntry, CreateMenu, InsertMenuEntry, Menu, MenuProc],

[Print, PrintArguments, PutClosure, PutProc],

[Cat, Fetch, Flatten, FromRefText, Index, Map, ROPE, Size, Text],

AMBridge, AMTypes, BBAction, BBBreak, BBBugOut, BBContext, BBDisableBreaks, BBFocus, BBObjectLocation, BBSafety, BBVForUserExec, BBVOps, Buttons, Commander, Containers, Convert, Labels, Menus, PrintTV, Process, Rope, TypeScript, VFonts, ViewerOps, VMenus, WorldVM

NullIndex: BreakIndex = BBBreak.NullIndex;

[indent: INTEGER ← 0, trail: INTEGER ← 2]

RETURNS [Labels.Label] = TRUSTED {

AddLabel adds a new label to the container at the given position

label: Labels.Label ← NIL;

x: INTEGER ← 0;

y: INTEGER ← ymax;

w: INTEGER ← emWidth * labelMax;

h: INTEGER ← emHeight;

label ←

x ← label.wx + label.ww - 1;

y ← label.wy + label.wh - 1 + trail;

IF x > xmax THEN xmax ← x;

IF y > ymax THEN ymax ← y;

RETURN [label]

};

y ← vMenuY;

x ← xmax;

list ← VMenus.Create[name, specs, container, x, y];

[,,x,y] ← VMenus.GetDimensions[list];

IF x > xmax THEN xmax ← x;

IF y > ymax THEN ymax ← y;

};

ViewerOps.CreateViewer[

[menu: menu, entry: Menus.CreateEntry[name: "ResetDefault!", proc: ResetDefaultHit]];

[menu: menu, entry: Menus.CreateEntry[name: "Stop!", proc: StopHit]];

[menu: menu, entry: Menus.CreateEntry[name: "Bigger", proc: BiggerHit]];

[menu: menu, entry: Menus.CreateEntry[name: "Smaller", proc: SmallerHit]];

["Show stack",

["Walk stack",

["Control",

["Breaks",

["Options",

["Display",

[info: [parent: container, wx: 0, wy: ymax, ww: 64, wh: 64],

[BBContext.ContextForWorld[WorldVM.LocalWorld[]]];

old: BBObjectLocation.Location ← loc;

loc ← NIL;

SELECT TRUE FROM

};

Kvetch["Setting break..."];

msg ← "invalid location";

IF loc = NIL THEN

IF loc # NIL THEN {

Kvetch["Break NOT set: ", msg];

};

forceEntry ← FALSE;

BBDisableBreaks.DisableBreakPoints[inner]};

old: BBObjectLocation.Location ← loc;

loc ← NIL;

SELECT TRUE FROM

};

Kvetch["Clearing break..."];

IF loc = NIL THEN loc ← BBVOps.LocationFromSelection

IF loc # NIL

IF loc # NIL THEN {

Kvetch["Break NOT found: ", msg];

};

forceEntry ← FALSE;

BBDisableBreaks.DisableBreakPoints[inner]};

action: Action ← NIL;

ctx: Context ← NIL;

tv, gfTV: TV ← NIL;

msg: ROPE ← "Source? What source?";

Kvetch["Finding source..."];

[action, ctx] ← BBFocus.GetDefaultActionAndContext[];

[,gfTV, tv] ← BBContext.GetContents[ctx];

IF tv = NIL THEN tv ← gfTV;

IF tv = NIL THEN

IF tv # NIL THEN {

Kvetch[msg];

};

Kvetch["Clearing breaks..."];

BBBreak.ClearAllBreaks[MyNormalBreak];

BBBreak.ClearAllBreaks[MyOneShotBreak];

BBBreak.ClearAllBreaks[];

Kvetch["All breaks cleared"];

};

loc: Location ← NIL;

msg: ROPE ← "invalid location";

IF mouseButton = red

loc ← BBVOps.LocationFromSelection

IF loc # NIL THEN {

Kvetch["Break NOT found: ", msg];

};

WHILE NOT (i = NullIndex) DO

bid: BreakId ← BBBreak.FindBreakId[i];

IF bid # NIL THEN -- display this break with optional verbosity

ENDLOOP;

BBAction.NextPendingAction[action] WHILE action # NIL DO

DisplayAction[action, mouseButton = blue];

ENDLOOP;

IF action.status # pendingOut

sigTV ← AMTypes.Signal[lfTV];

putRope["signal: "];

DisplayTV[sigTV];

putRope[" args: "];

IF tryFrame

};

[lfTV !

event: Event ← action.event;

WITH e: event SELECT FROM

};

abort the current request & say why

abortNextChar ← FALSE;

TypeScript.PutChar[ts, '\n];

KvetchMore[" aborted."];

ERROR ABORTED};

pendingOut => {};

new => putRope[" (new)"];

busy => putRope[" (busy)"];

pendingIn => putRope[" (pendingIn)"];

dead => putRope[" (dead)"];

new => putRope[" (new)"];

ENDCASE => putRope[" (??)"];

putRopes[", world = ", WorldVM.WorldName[event.world]];

break =>

call =>

signal => {

interrupt =>

unknown =>

ENDCASE;

gf: TV ← NIL;

pc, gfh: CARDINAL ← 0;

[gf, pc] ← BBObjectLocation.GFandPCFromLocation[loc];

IF AMBridge.IsRemote[gf]

putRope[", gfh: "]; putCard[gfh];

putRope[", pc: "]; putCard[pc];

};

frame: lf, put: putClosure, report: Report,

args: args, vars: vars, allVars: vars AND allVarsOption];

DisplayLocalFrame[current, args, vars];

current ← AMTypes.DynamicParent[current];

ENDLOOP;

< 0 => {

> 0 => {

ENDCASE;

Kvetch["No current action."]; action ← NIL};

context ← BBFocus.GetDefaultActionAndContext[].ctx;

IF context = NIL THEN context ← BBContext.GetDefaultGlobalContext[]};

THEN Buttons.SetDisplayStyle[button, $WhiteOnBlack]

ELSE Buttons.SetDisplayStyle[button, $BlackOnWhite];

WHILE NOT (i = NullIndex) DO

bid: BreakId ← BBBreak.FindBreakId[i];

IF bid # NIL THEN -- see if this one is the right one

ENDLOOP;

localMax: BBAction.ActionId ← maxReportedId;

defCtx: Context ← NIL;

changeNum ← BBAction.WaitForChange[changeNum];

IF container.destroyed THEN RETURN;

[action, ctx] ← BBFocus.GetDefaultActionAndContext[];

event ← NIL;

IF action = NIL OR action.status # pendingOut THEN

FOR act: Action ← BBAction.NextPendingAction[NIL],

maxReportedId ← localMax;

IF action # NIL AND ctx = NIL THEN

defCtx ← BBContext.GetDefaultGlobalContext[];

IF action # lastAction OR ctx # lastCtx OR defCtx # oldDefCtx THEN {

};

msg: ROPE ← BBSafety.Mother[inner];

IF msg # NIL THEN putRopes["\nBELCH! Error in reporting loop: ", msg, "\n"];

};

BBDisableBreaks.DisableBreakPoints[each ! ABORTED => EXIT];

ENDLOOP;

"bbv",

BuildTool,

"BBV is an alternative interface to some BugBane commands."];