🚀 go-pugleaf

Summary:
Expires:
Sender:
Followup-To:
Distribution:
Xpath: ukc eagle

In article <320@cord.UUCP> miker@cord.UUCP writes:
>abstract: how can items be sorted in troff(nroff)?
>
>explanation: given the definition of the list-begin, list-item,
>       and list-end macros, how can i generate a sorted list of
>       the first arguments to the list-item macros?
>
>       e.g., given the following pseudo-troff input:
>
>list-begin
>list-item arg1
>list-item arg1
>list-item arg1
>list-end
>list-sort      \" i.e. produce a sorted list of all arg1s
>
>       what should list-item and list-sort do?

(You are joking, aren't you?)

Ignoring the fact that troff doesn't have string comparisons,
just numeric ones, what you need is a way of imitating arrays
in troff so you can do quicksort/bubblesort or whatever.

The way to imitate arrays is to use dynamically constructed
register/string names.  To mimic an array Q with 10 elements and
access Q[i] where i is a suitable numeric register, do things
like

        .nr \n(Q\ni 7           \" Q[i] := 7
        .nr \n(Q\ni \n(Q\n(j    \" Q[i] := Q[j]
        .nr \n(Q2 3             \" Q[2] := 3

or have a string array if you can find some way of comparing
the arguments. To get arrays with more than 0 elements, you
have to encode the subscript into a single character - help is
at hand in the unlikely form of the .af primitive

        .af i a

will give you a 27 element array with index letters 0,a-z
and tricky use of .ie conditionals will give you A-Z as well by
changing the format to a or A as appropriate. Note that .af
doesn't change the way you assign numbers into the register.

Control structures - I can't offhand think of a way to do
iteration directly (Exercise for the readers?) but recursion is
just macro calling and the \$n arguments really are call-by-value
local variables!  Your only problem will be avoiding macro
nesting depth limits, but you have to tackle the sorting of
strings first.

For the paper in which I first saw these crazy ideas used (to
do proper floating keeps, no -ms rubbish here!), look in
Software- Practice & Experience sometime in the past 4 years
(?) for a paper entitled

        "* On the Power of Traps and Diversions*"

Note the use of pattern matching to compensate for failing
memory.  When you have written your sort program, you might
care to tackle the aesthetically valid idea of re-writing troff
in troff......
-- 

William Roberts         ARPA: liam@cs.qmc.ac.uk  (gw: cs.ucl.edu)
Queen Mary College      UUCP: liam@qmc-cs.UUCP
LONDON, UK              Tel:  01-980 4811 ext 3900