BEGIN
-- Erases the names of all points in the (pointLpad..pointRpad) list.
p: PointPtr ← Im.image.points;
WHILE p # NIL DO
p.name ← NIL; p ← p.link
ENDLOOP
END;

BEGIN
-- Assigns the ith standard name to the point p, and returns the chosen name.
-- Also paints the name on the viewer. Complains if p already named.
IF p.name # NIL THEN ERROR;
nam ← Atom.MakeAtom[IF i > 25
THEN Rope.Cat["a", Convert.RopeFromInt[i - 26, 10, FALSE]]
ELSE Rope.FromChar['a + i - 1]];
p.name ← nam;
Gr.DrawRope[Atom.GetPName[nam], p.x + 5, p.y + 5];
Gr.viewerChanged ← TRUE
END;

BEGIN
-- Returns the Juno expression for the frame determined by
-- the three points frame.org, frame.xP, frame.yP
-- (the last one or two of which may be NIL).
temp: REF = IF frame.xP = NIL THEN frame.org.name
ELSE IF frame.yP = NIL THEN LIST[Alg.comma, frame.org.name, frame.xP.name]
ELSE LIST[Alg.comma, frame.org.name, LIST[Alg.comma, frame.xP.name, frame.yP.name]];
RETURN[LIST[Alg.leftPren, temp]]
END;

BEGIN
-- Creates a procedure body describing all wound points in the current image, plus
-- associated constraints and actions.
-- Assumes nParms of those points are parameters, whose name field has already been set.
-- The remaining points are local variables. The hints for each of these will be its
-- current position, relative to the given frame.
locals, actions, constrs: Alg.Se;
sing: BOOL;
m ← Alg.GetFrameMatrix[frame, m];
[mInv, sing] ← Alg.InvertMatrix[m, mInv];
IF sing THEN ERROR;
locals ← BuildLocalList [frame, mInv, nParms];
actions ← BuildActionList[];
constrs ← BuildConstrList[];
IF locals = NIL THEN
{IF constrs # Alg.true OR actions # Alg.skip THEN ERROR;
RETURN[actions]}
ELSE
{RETURN [LIST[Alg.if,
LIST[Alg.rightArrow, LIST[Alg.suchThat, locals, constrs], actions]]]}
END;

BEGIN
-- Assign names to all points in the image list that have nonzero winding numbers.
-- Points that already
-- have names are ignored (they are assumed to be input parameters).
-- Also returns a Juno expression declaring the newly named points.
-- The hints for each new point will be its current position, relative to the
-- given frame;
-- mInv should be the matrix of the viewer's frame relative to the given one.
-- Uses standard names (<letters>, then a<number>), but assumes nParms
-- of those have already been assigned to the input parameters.
i: INT ← nParms+1;
p: PointPtr ← Im.image.points;
x, y: REAL;
nam: ATOM;
localList: LIST OF Alg.Se ← NIL;
frameExpr: Alg.Se ← MakeFrameExpr[frame];
-- Is it OK for all hints to share the same frame expression?
UNTIL p = NIL DO
IF p.wn # 0 AND p.name = NIL THEN
{nam ← NamePoint[p, i];
i ← i + 1;
x ← p.x * mInv^[1][1] + p.y * mInv^[1][2] + mInv^[1][3];
y ← p.x * mInv^[2][1] + p.y * mInv^[2][2] + mInv^[2][3];
localList ← CONS [
LIST[Alg.approx,
nam,
LIST[Alg.rel,
LIST[Alg.leftPren, LIST[Alg.comma, NEW[REAL ← x], NEW[REAL ← y]]],
frameExpr]],
localList]};
p ← p.link
ENDLOOP;
RETURN [ReverseAndNest[localList, Alg.comma, NIL]]
END;

BEGIN
IF args = NIL THEN RETURN [zero];
expr ← args.first; args ← args.rest;
WHILE args # NIL DO
expr ← LIST[op, args.first, expr];
args ← args.rest
ENDLOOP;
RETURN [expr]
END;

BEGIN

cExprList: LIST OF Alg.Se ← NIL;

AddConstrExpr: PROC[op: ATOM, r1, r2: Alg.Se ← NIL, frame: Alg.Frame] =
{pred: Alg.Se ← IF r2 = NIL THEN LIST[op, r1] ELSE LIST[op, r1, r2];
IF frame # [NIL, NIL, NIL] THEN
{pred ← LIST[Alg.rel, pred, MakeFrameExpr[frame]];
cExprList ← CONS[pred, cExprList]}};

c: Stor.ConstrPtr ← Im.image.constrs;
WHILE c # NIL DO
IF Im.ConstrIsWound[c] THEN
{WITH c SELECT FROM
cc: Stor.HorPtr =>
{AddConstrExpr
[Alg.hor,
PrenArgs[LIST[cc.i, cc.j]], NIL, [NIL, NIL, NIL]]};
cc: Stor.VerPtr =>
{AddConstrExpr
[Alg.ver,
PrenArgs[LIST[cc.i, cc.j]], NIL, [NIL, NIL, NIL]]};
cc: Stor.CongPtr =>
{AddConstrExpr
[Alg.cong,
PrenArgs[LIST[cc.i, cc.j]],
PrenArgs[LIST[cc.k, cc.l]], cc.frame]};
cc: Stor.ParaPtr =>
{AddConstrExpr
[Alg.para,
PrenArgs[LIST[cc.i, cc.j]],
PrenArgs[LIST[cc.k, cc.l]], [NIL, NIL, NIL]]};
cc: Stor.PerpPtr =>
{AddConstrExpr
[Alg.perp,
PrenArgs[LIST[cc.i, cc.j]],
PrenArgs[LIST[cc.k, cc.l]], cc.frame]};
cc: Stor.AtPtr =>
{AddConstrExpr
[Alg.equals,
PrenArgs[LIST[cc.p]],
LIST[Alg.leftPren,
LIST[Alg.comma, NEW[REAL ← cc.x], NEW[REAL ← cc.y]]], cc.frame]};
cc: Stor.CcwPtr =>
{AddConstrExpr
[Alg.ccw,
PrenArgs[LIST[cc.i, cc.j, cc.k]], NIL, cc.frame]};
ENDCASE => ERROR};
c ← c.link
ENDLOOP;

constrs ← ReverseAndNest [cExprList, Alg.and, Alg.true]
END;

BEGIN
actionList: LIST OF Alg.Se ← NIL;
a: Stor.ActionPtr ← Im.image.actions.first;

WHILE a # NIL DO
IF Im.ActionIsWound[a] THEN
{actionList ← CONS
[LIST [Alg.leftPren, a.op, UnEval[a.arg]],
actionList]};
a ← a.link
ENDLOOP;

actions ← ReverseAndNest [actionList, Alg.semicolon, Alg.skip]
END;

{IF list = NIL THEN RETURN [zero]
ELSE IF list.rest = NIL THEN RETURN [list.first]
ELSE RETURN [LIST[op, list.first, Nest[list.rest, op, zero]]]};

{IF list = NIL THEN RETURN [zero]
ELSE IF list.rest = NIL THEN RETURN [list.first]
ELSE RETURN [LIST[op, list.first, NestAtoms[list.rest, op, zero]]]};

{WITH arg SELECT FROM
aa: REF INT => RETURN [aa];
aa: REF REAL => RETURN [aa];
aa: Rope.ROPE => RETURN [aa];
aa: PointPtr => RETURN [aa.name];
aa: Alg.FunVal => ERROR; -- Alg.GetName[aa, globals]
aa: LIST OF Alg.Value => RETURN [UnEvalList[aa]];
ENDCASE => ERROR};

{IF list.rest = NIL
THEN RETURN [UnEval[ list.first]]
ELSE RETURN [LIST[Alg.comma, UnEval[list.first], UnEvalList[list.rest]] ]};

{RETURN [LIST[Alg.leftPren, UnEvalList[arg]]]};

-- Added Tioga formatting.

-- Extended MakeDefBody for more than two arguments.

-- Infinitesimal bug: stringFont was not being copied in ScanLists

-- Cleaned up matrix operations in preparation for relative constraints

changes to: GetFrameMatrix(new), InvertMatrix(new), MultiplyMatrix(new), ComputeTransform (parameter change), ComputeSomeTransform(replaces a piece of JunoTop.MoveStep), TransformPoint (new), EraseAllNames (new), true, and, skip, comma (new), MakeFrameExpr (new), MakeBody (new, replaces MakeDefBody and OtherMakeDefBody), BuildLocalList (substantial parameter changes), Nest (parameter changes; handles empty lists too), BuildActionAndPredLists (parameter changes), ScanLists (cleanup and parameter changes), AddAction, AddPred (made local to ScanLists), TransformPoints (replaces PerformTransform)

changes to: TransformPoints (to account for changes in TransformPoint parameters)

changes to: Delete, TransformPoint, Copy, copiedPoints, Identify (moved to HerculesImage), FindSelectedPoint, SortPoints (moved to HerculesTop), ItemOperation, EnumerateItems, (moved to HerculesImage) copiedPoints (deleted), ListOfCopies, AllHaveCopies, Copy, TransformPoints, Identify, SetCopiesToNil, Delete, DeleteOriginals (moved to HerculesImageImpl), MakeFrameExpr (parameter is Frame), MakeBody (parameter is Frame), BuildLocalList (considers only wound points; shares frame expression), ReverseAndNest (new - replaces Nest), BuildActionsAndPresdsLists (replaced by BuildConstrList, BuildActionsList), BuildConstrList (considers only wound constraints), BuildActionsList (considers only wound actions; preserves chronological order)

changes to: UnEval, UnEvalList (replace PointNames, PointOrValueNames),

changes to: BuildActionList (actions now are always applications),