SCRIBE
INTRODUCTORY
USER'S MANUAL
FIRST EDITION
(DOC FILE VERSION)
Brian K. Reid
7 August 1978
CARNEGIE-MELLON UNIVERSITY
COMPUTER SCIENCE DEPARTMENT
This manual corresponds to SCRIBE version CMU 0E(110)-5.
Copyright -C- 1978 Brian K. Reid
The research that produced SCRIBE was funded in part by the Rome Air
Development Center under Contract No. F306-2-75-C-0218, in part by Army
Research Contract No. DAAG29-77-C-0034, and in part by the Defense Advanced
Research Projects Agency under contract No. F44620-73-C-0074.
PAGE 1
Preface
This manual is a beginner's manual for the SCRIBE document production system
developed in the Computer Science Department at Carnegie-Mellon University.
The reader is expected to have used (however briefly) a timesharing computer,
to know how to use a text editor, and to understand the notion of a timesharing
"file system". No particular computer expertise or knowledge of programming is
needed. If you feel that you don't have that background, see the CMU Computer
Science Department's Computer Primer. On the other hand, if you have a lot of
programming experience and would like to know more, there is a SCRIBE Experts'
Manual available, as a companion to this one.
SCRIBE is still under development. This first edition of the Introductory
User's Manual was written for internal use in the Computer Science Department,
and the particular set of formatting commands that we have devised and
documented are designed around the sorts of documents that computer scientists
produce. Users in non-academic or non-mathematical environments will have very
little use for the "Theorem" or "Equation" features, but may find something
else desirable. In time there will be separate editions of the manual.
This manual was produced with SCRIBE and printed on the Computer Science
Department's Xerox Graphics Printer. If you find anything wrong with it,
please let me know. My ARPANET mail address is "Reid@CMU-10A"; my regular
snailmail address is "Department of Computer Science, Carnegie-Mellon
University, Pittsburgh PA 15213".
PAGE 2 SCRIBE USERS' MANUAL
1. Introduction
SCRIBE is a document production program. It produces "documents", designed
to be read by people, from "manuscript files", which are primarily to be read
by the computer. The manuscript files that SCRIBE processes are created by
people by using a text editor; the document files that SCRIBE produces are
printed on printing devices to produce paper copy.
SCRIBE is a big program. It has many exotic capabilities, most of which you
will probably never need. But as the people who sell cars with big engines are
fond of saying, it's nice to have the power there in case you need to use it.
Unlike many big programs, SCRIBE looks simple. You don't need very many
commands, and the ones that you do need are not complicated. If you have used
computer text editors before, you should be able to learn enough about SCRIBE
in an hour to be able to produce your first document. As you learn more about
document production and find that you want more "features" or more power, just
read farther in the manual and you will probably find what you are looking for.
The SCRIBE Experts' Manual, a companion volume to this one, describes how to
do complicated things. We have made it a separate manual to emphasize the fact
that SCRIBE is quite useful to people who aren't experts, and also to save
printing costs, since not everybody needs to be an expert.
1.1 Some Explanation for Non-Programmers
The preparation of a document requires, in addition to the actual text, an
understanding of how the text is to be formatted. When a secretary types a
document, he applies his knowledge of typing and formats and his understanding
of what the words and sentences mean, and chooses a reasonable format for
various pieces of the text. When a typographer typesets a document for
publication, he needs editor's marks, in colored pencil, to show him what to
do.
Computers are at a double disadvantage in the production of documents. They
are not clever, like secretaries, nor can they read penciled proofreader's
marks, like typographers. Computers can recognize the 95 characters on their
keyboard, but not penciled notes. Somehow, using only those 95 characters, we
must devise a means of communicating to the computer all of the various kinds
of information that secretaries can figure out for themselves and typographers
get from the pencil marks. SCRIBE has such a scheme, using special sequences
of characters to represent formatting commands, and if it sometimes seems to
you as though a certain construct is too baroque or too mathematical, please
understand why it is that way.
INTRODUCTION PAGE 3
1.2 Some Explanation for Programmers
The SCRIBE system was designed to make document production easy for the
non-expert, and to allow him to make small changes to the formats and styles
without needing to learn much about how the program works. SCRIBE is not a
programming language.
SCRIBE does not have `commands' in the usual sense of the word: its commands
are not procedural. A SCRIBE command specifies the result that is desired
rather than the method to achieve it. For example, to enter a quotation in
running text, it is customary to switch to single spacing, indent the left and
right margins, and then change back again to normal margins and spacing. In
SCRIBE, this would be achieved by placing a "@begin(quotation)" command at the
front of the quotation's text, and an "@End(quotation)" after its text. The
details of the knowledge of how to print a QUOTATION are encoded in SCRIBE's
internal tables.
The non-procedural nature of SCRIBE typically gives fits to people who have
grown accustomed to procedural document formatters. Programmers are used to
thinking in terms of procedural commands, and are used to having the full power
of the document formatter available at the command level. Many expert
programmers, upon first seeing SCRIBE, seem to think that it is weak and
powerless and unflexible, when what they really mean is that it doesn't conform
to their notion of what a procedural command language should do.
SCRIBE has been in use at Carnegie-Mellon since January 1978. We have found
that even hard-core hackers can learn how to use SCRIBE effectively, but that
they must learn to think differently before they will ever be comfortable with
it. People who aren't experts at older document systems have had no difficulty
learning to use SCRIBE.
PAGE 4 SCRIBE USERS' MANUAL
2. Getting Started
This chapter is for new users, who have never used SCRIBE before and who
would like to learn how to use it for simple things.
2.1 Preparing Input for Scribe
A manuscript file prepared for input to SCRIBE consists primarily of plain
text. Paragraphs are separated by blank lines, and commands, if present, are
flagged with an "@" sign. If you want an "@" sign to appear in your output,
you must type two of them: "@@". The various commands are described in this
and following chapters. A file containing no commands at all will work just
fine; it will yield simple justified paragraphed text. On the PDP-10, a
manuscript file should be given the extension ".MSS"; our example that we
discuss here will be called TRIAL.MSS.
2.2 Running Scribe
Suppose that we have built a manuscript file named TRIAL.MSS, with the
1
following contents:
00100 So when he came to the churchyard Sir Arthur alighted and tied his
00200 horse to the stile. And so he went to the tent and found no
knights
00300 there for they were at jousting. And so he handled the sword by
the
00400 handles and lightly and fiercely pulled it out of the stone, and
took
00500 his horse and rode his way until he came to his brother, Sir Kay,
and
00600 delivered him the sword.
00700
00800 And as soon as Sir Kay saw the sword he wist well it was the sword
00900 from the stone, and so he rode to his father, Sir Ector, and said,
01000 `Sir, lo! here is the sword of the stone, wherefore I must be King
of
01100 this land.'
The blank line (700) indicates the end of one paragraph and the beginning of
another. To process this file, we run SCRIBE; it will prompt us for input by
typing an asterisk:
---------------
1
From Le Morte Darthur, by Sir Thomas Malory.
GETTING STARTED PAGE 5
R SCRIBE
*
In response to the prompt, type the file name of the manuscript file that is to
be processed.
R SCRIBE
*TRIAL.MSS
SCRIBE will then process the file. It will produce as output a file called
TRIAL.LPT. This TRIAL.LPT file that it produces, when typed on the terminal,
will look something like this:
So when he came to the churchyard Sir Arthur alighted and tied his
horse to the stile. And so he went to the tent and found no knights
there for they were at jousting. And so he handled the sword by the
handles and lightly and fiercely pulled it out of the stone, and took
his horse and rode his way until he came to his brother, Sir Kay, and
delivered him the sword.
And as soon as Sir Kay saw the sword he wist well it was the sword
from the stone, and so he rode to his father, Sir Ector, and said,
`Sir, lo! here is the sword of the stone, wherefore I must be King of
this land.'
1
The reader is invited to copy the file TRIAL.MSS[A800DP99] and go through this
exercise.
2.3 Printing Devices
When SCRIBE processes a manuscript file into a document file, it does so with
a particular printing device in mind. The device characteristics determine the
number of characters that SCRIBE tries to put on a line, the number of lines
that it tries to put on a page, the methods used to accomplish underlining and
backspacing, and so on.
If you don't tell SCRIBE anything one way or another about printing devices,
it will assume that you are preparing a file for the line printer. If you
aren't, you must put a @DEVICE command at the beginning of your manuscript
file, telling SCRIBE what device you are using. The format is "@DEVICE(what
---------------
1
Only at CMU Computer Science Department sites.
PAGE 6 SCRIBE USERS' MANUAL
2
kind)" ; some examples follow:
@DEVICE(LPT) Prepare for a line printer
@Device(XGP) Prepare document for Xerox Graphics Printer
@DEVICE(DIABLO) Prepare for Diablo HyType terminal
@device(FILE) Prepare as a computer file
To return to our example of the previous section, let's change it to produce
output for the XGP. The updated manuscript file TRIAL.MSS would now look like
this:
00050 @device(XGP)
00100 So when he came to the churchyard Sir Arthur alighted and tied his
00200 horse to the stile. And so he went to the tent and found no
knights
00300 there for they were at jousting. And so he handled the sword by
the
00400 handles and lightly and fiercely pulled it out of the stone, and
took
00500 his horse and rode his way until he came to his brother, Sir Key,
and
00600 delivered him the sword.
00700
00800 And as soon as Sir Kay saw the sword he wist well it was the sword
00900 from the stone, and so he rode to his father, Sir Ector, and said,
01000 `Sir, lo! here is the sword of the stone, wherefore I must be King
of
01100 this land.'
If this file were now run through SCRIBE, it would produce an output file
named TRIAL.XGO suitable for printing on the XGP, instead of the TRIAL.LPT that
it produced before.
A table of the DEVICE codes known to SCRIBE is shown in figure 2-1. We expect
to be able to add a device type for a photocomposing machine as soon as one
becomes available to us.
---------------
2
Upper and lower case may be used interchangeably in any SCRIBE command;
varying case will be used throughout this manual to emphasize that.
PREPARING A MANUSCRIPT PAGE 7
Page Page
Code Length Width Description
@z[?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2?2
LPT 53 lines 132 cols Line printer (standard)
XGP 11 inches 8.5 inches Xerox Graphics Printer
DIABLO 11 inches 8.5 inches Diablo HyType printer
LA36 66 lines 132 cols LA36 DECwriter
TI700 50 lines 80 cols Texas Instruments 700
SOS 50 lines 69 cols SOS file
FILE 50 lines 79 cols Standard DOC file
CRT 24 lines 79 cols Pages match CRT screen size
Figure 2-1: Device Types Known To SCRIBE
PAGE 8 SCRIBE USERS' MANUAL
3. Preparing a Manuscript
You now know how to build a manuscript file that contains plain text, and
then run it through SCRIBE to produce a document. In this section we will tell
you how to fancy it up with italics, underlining, subscripts, superscripts, and
so forth.
Let's start with an example, then get to a more general explanation. To get
1
italics, surround the letters that you want italicized with @i[...], like
this:
The inscription read, "@i[De minimus non curat lex]."
which will produce output that looks like this:
The inscription read, "De minimus non curat lex."
Before going on with more explanations, we need to talk some nuts and bolts.
3.1 Delimiters
The square brackets [] used in the example above are called delimiters. They
delimit the characters being italicized. Computer keyboards contain several
pairs of matching left and right delimiters, and any of them may equally well
be used. For example, you could have put @i(De minimus..) or @i<De
minimus..>. It doesn't really matter which kind of delimiter you use as long as
the closing delimiter matches the opening delimiter. If you tried @i<De
minimus...], SCRIBE will just keep italicizing until it comes to a ">"
character or the end of the paragraph. The delimiter pairs that you may use
are (...), [...], {...}, <...>, '...', `...', and "...".
Suppose that you wanted boldface and underlining of the same text. To get
boldface, you use @b[...] around the text to be boldfaced. To get underlining,
we put @u[...] around the text to be underlined.
Why would anybody want @b[@u[boldfaced underlining]]?
This is called nesting of the delimiters. The output that it will produce will
---------------
1
If this document was printed on a device not capable of italicizing letters,
then you will see underlining or overstriking where we intend italics.
PREPARING A MANUSCRIPT PAGE 9
look like this:
Why would anybody want boldfaced underlining?
The concept of nesting should be familiar to everyone in the notion of
quotations inside quotations; the inner quotation is delimited with single
quotes and the outer quotation is delimited with double quotes, like this:
Macomber said, "But the sign said `No Hunting.'"
SCRIBE is clever enough to let you nest like delimiters without getting itself
confused, but you can use different delimiters if you want:
Why would anybody want @b<@u[boldfaced underlining]>?
If you want to include an un-nested delimiter character inside a pair of
delimiters, you have to be careful. Suppose, for example, that you wanted to
put an underlined ")" character in your text. If you used parentheses as
delimiters, and put @u()), SCRIBE would treat that as "@u()" followed by ")",
and would not do what you wanted. This might seem like a useless warning, but
the situation comes up in mathematical formatting. Equations and formulas are
frequently printed with italicized variable names, and frequently contain
parentheses. To get the sequence "2*(4+y)-b" correctly italicized, we must be
careful not to use parentheses as delimiters: @i[2*(4+y)-b] will work, but
@i(2*(4+y)-b) will not do what you want: it will print as "2*(4+y-b)", which
is wrong.
3.2 Printing Device Considerations
Not every feature provided by SCRIBE can be realized on every output device.
The line printer, for example, cannot print italics or even underline, but it
can generate boldface by overstriking. The XGP at CMU can italicize and
underline and boldface, but cannot do italics and boldface on the same line.
In fact, our XGP is restricted to no more than two fonts in any pair of lines.
Some of the features in SCRIBE cannot be achieved on any of the printing
devices currently available to it, but were installed in anticipation of a
photocomposing machine or better Xerographic printers. For example, the
overbar code @o[] and the script code @s[] cannot be printed on even the XGP
without special tinkering that is beyond the scope of this manual.
3.3 Italics, Underlining, Etcetera
SCRIBE recognizes all of the font-change codes listed in figure 3-1. Whether
it will actually produce the requested font change depends on the nature of the
final printing device being used. If SCRIBE cannot produce a particular code
PAGE 10 SCRIBE USERS' MANUAL
on a particular printing device, it will attempt a compromise. In general, if
a final printing device cannot print a particular effect, SCRIBE will generate
underlining or overstriking instead.
@i[phrase] Italics
@u[phrase] Underline non-blank characters
@ux[phrase] Underline all characters
@un[phrase] Underline alpha-numerics (but not punctuation or spaces)
@b[phrase] Boldface
@r[phrase] Roman (the normal typeface)
@t[phrase] Typewriter font
super
@+[phrase] print script
@c[phrase] SMALL CAPITALS
@-[phrase] print script
sub
@g[phrase] Greek (@g[Ellen])
@o[phrase] Overbar
@p[phrase] Bold Italics
Figure 3-1: Font-change Codes
3.4 Inserts
You now know how to produce paragraphed text with various fancy effects like
italics and underlining. In this section, we will show you how to insert
various things into the middle of running text. Anything put into running text
is called an insert. Inserts can be quotations, examples, equations, tables, or
what have you. The text will resume in the same paragraph after the insert.
3.4.1 Specifying an Insert
There are two ways of specifying an insert. The long form requires more
typing, but is immune to problems with delimiters. Both yield the same result.
Consider this example: to put a quotation into running text, we mark its
beginning with "@BEGIN(QUOTATION)" and its end with "@End(QUOTATION)". Thus:
PREPARING A MANUSCRIPT PAGE 11
@Begin(Quotation)
Body of quotation.
@End(Quotation)
This is the long form. The short form of the same thing would be:
@Quotation(
Body of quotation.
)
Obviously, the short form requires that the body of the quotation not contain
the right delimiter that closes the quotation.
If your quotation is short, you can specify it all on one line:
@Quotation(Body of quotation)
SCRIBE will produce the same output from any of the three forms shown above.
A quotation in running text comes out single spaced, with the left and right
margins widened a little, like this:
The fact is, that civilization requires slaves. The Greeks were
quite right there. Unless there are slaves to do ugly, horrible,
uninteresting work, culture and contemplation become impossible. Human
slavery is wrong, insecure, and demoralizing. On mechanical slavery,
1
on the slavery of the machine, the future of the world depends .
3.4.2 Simple Inserts
SCRIBE knows about the following collection of simple insert types. Any one
of them may be used in any document type. They may be used in the long form
(using BEGIN and END), or the short form, @NAME(body of insert). ENTER is a
synonym for BEGIN and LEAVE is a synonym for END. Each of these insert types
is described inf figure 3-2; examples of the use of each can be seen in
Appendix I.
---------------
1
From Oscar Wilde, The Soul of Man under Socialism, 1895
PAGE 12 SCRIBE USERS' MANUAL
QUOTATION Text quotation
VERSE Verse quotation
EXAMPLE Example of computer type-in or type-out
DISPLAY Non-justified insert. Each line is separate.
CENTER Each line centered
VERBATIM Characters copied exactly, without formatting
FORMAT Hand-formatted text
ITEMIZE Paragraphs with a tick-mark in front of each
ENUMERATE Paragraphs with a number in front of each
DESCRIPTION Outdented paragraphs; single spacing
EQUATION Equation, with a number put in the right margin
THEOREM Numbered theorem
Figure 3-2: Basic Insert Types
3.4.2.1 QUOTATION and VERSE
The QUOTATION insert has already been described (previous section). It
inserts prose quotations in running text.
The VERSE insert differs from the QUOTATION insert in the way it handles
lines. QUOTATION doesn't pay any attention to ends of lines in the manuscript
file; it puts as many characters on each line as will fit there. VERSE starts
a new line in the final document for each end-of-line in the manuscript file,
regardless of whether the existing line is full. If VERSE needs to use more
than one line of the document to hold the text from one line of the manuscript,
the second and following lines will be indented a bit from the left. A VERSE
insert comes out looking like this:
Oh, East is East and West is West, and never the twain shall meet,
Till Earth and Sky stand presently at God's great Judgment Seat;
But there is neither East nor West, border, nor breed, nor birth
When two strong men stand face to face, though they come from the ends
1
of the earth .
---------------
1
Rudyard Kipling, The Ballad of East and West.
PREPARING A MANUSCRIPT PAGE 13
3.4.2.2 EXAMPLE and DISPLAY
The EXAMPLE and DISPLAY insert types are very similar; they differ only in
the type face that will be used. In either EXAMPLE or DISPLAY inserts, each
line of the manuscript file will produce one line in the document. Since
EXAMPLE is for showing examples of computer type-in and type-out (useful in
user's manuals), it will appear in a typeface that is designed to look like
computer output. DISPLAY inserts will appear in the normal body type face.
Thus:
This is an EXAMPLE insert
This is a DISPLAY insert
The examples were generated like this:
@Begin(Example)
This is an EXAMPLE insert
@End(Example)
@Begin(Display)
This is a DISPLAY insert
@End(Display)
If your copy of this manual was printed on a device that cannot change fonts
(such as the Diablo printer), then those two lines will look nearly identical.
3.4.2.3 CENTER
A CENTER insert is similar to a DISPLAY, except that it centers its lines
rather than left-justifying them. Like DISPLAY, CENTER produces one line in
the document for each line of the manuscript file that is inside the CENTER.
This is a CENTER insert
If there is more than one line in a CENTER insert, each line will be centered
individually: for the example we just gave, the text to generate it was
@Begin(center)
This is a CENTER insert
@End(center)
PAGE 14 SCRIBE USERS' MANUAL
although we could just as well have used
@center(This is a CENTER insert)
If you think that you want boldface centering, and find yourself wondering
whether you should say @b(@center(Mynah Birds)) or @center(@b(Mynah Birds)),
the chances are that what you are really doing is making a heading, and you
should use @Heading(Mynah Birds) instead; see Chapter 5.
3.4.2.4 VERBATIM and FORMAT
A VERBATIM insert is printed exactly as you type it; no justifying or moving
of the text will be done. SCRIBE will switch to a fixed-width font for the
VERBATIM text, in order that columns will line up properly. The @ codes will
all be processed, so it's not completely verbatim.
FORMAT differs from VERBATIM only in that it uses a variable-width character
set if one is available on the final printing device. In FORMAT mode, you
would use the tabbing and formatting commands (described in Chapter 7), rather
than the space bar on your terminal, to align columns and achieve the desired
effects.
3.4.2.5 ITEMIZE and ENUMERATE
ITEMIZE and ENUMERATE each expect a sequence of paragraphs (separated by
blank lines, as usual); and each justifies those paragraphs with slightly wider
margins and puts a mark in front of each. ITEMIZE puts a tick-mark ("- ") in
front of each paragraph, while ENUMERATE puts a number in front of each. If
you are not going to refer back to the numbers that ENUMERATE generates, you
should use ITEMIZE instead. An ITEMIZE comes out looking like this:
- First item
- Second item
- Third and last
An ENUMERATE looks like this:
1. First item
2. Second item
PREPARING A MANUSCRIPT PAGE 15
3. Third and last
The input text that made those examples was identical save for a substitution
of name: the itemization was:
@Begin(itemize)
First item
Second item
Third and last
@End(itemize)
while the enumeration was
@Begin(enumerate)
First item
Second item
Third and last
@End(enumerate)
3.4.2.6 DESCRIPTION
A DESCRIPTION insert is designed for the "command description" style that is
so common in reference manuals. The first line of a DESCRIPTION insert will be
at the left margin of the page, and the second and remaining lines will be
indented substantially, so that the word or phrase at the head of the
description stands out. If the sequence "@\" or a ^I (TAB) character is found
on the first line of a DESCRIPTION, it will be taken as a signal to tab to the
indented margin provided that it has not yet been passed. Thus, this input:
@Begin(description)
Segment^IOne of the parts into which something naturally
separates or is divided; a division, portion,
or section.
PAGE 16 SCRIBE USERS' MANUAL
Section^I A part that is cut off or separated; a distinct
part or subdivision of anything, as an object,
country, or class.
@End(description)
will produce this output:
Segment One of the parts into which something naturally separates or is
divided; a division, portion, or section.
Section A part that is cut off or separated; a distinct part or
subdivision of anything, as an object, country, or class.
3.4.2.7 EQUATION
An EQUATION insert is almost identical to a DISPLAY insert: each line in the
manuscript file generates one line in the document, the left and right margins
will be inset a bit, and it is printed in the standard body font. The
difference is that the EQUATION insert will cause an automatically generated
equation number to be printed in the right margin of each line in which a @TAG
command (see section 8.1, page 53) appears. The @TAG command is used to mark
cross-reference points, and only those equations that will be cross-referenced
need be numbered.
This input text:
@begin(equation)
@i[x]@-[n+1] = @i[x]@-[n]-@i[F](@i[x]@-[n])/@i[F]'(@i[x]@-[n])
@r(or)
@tag(Newton)@i[x]@-[n+1] = (@i[x]@-[n]+@i[c]/@i[x]@-[n])
@End(equation)
might produce output that looks like this (notice the equation number over at
the right):
x = x -F(x )/F'(x )
n+1 n n n
or
x = (x +c/x ) (3-12)
n+1 n n
PREPARING A MANUSCRIPT PAGE 17
3.4.2.8 THEOREM
A THEOREM insert is almost identical to a QUOTATION insert: it will produce
a single-spaced justified block of text, with the left and right margins pulled
in a bit. The difference is that each time you do a @Theorem() or a
@Begin(Theorem), SCRIBE will add the prefix text "Theorem" and then print the
current theorem number. Thus, this input text:
@Theorem(The closed interval [a,b] is compact)
...
@begin(Theorem)
A closed bounded subset of R@+[n] is compact.
@End(Theorem)
might produce this output text:
Theorem 1-4: The closed interval [a,b] is compact.
. . .
n
Theorem 1-5: A closed bounded subset of R is compact.
See section 8.1 for a discussion of how to cross-reference theorem numbers
using the @Tag and @Ref commands.
3.5 Footnotes
1
To get a footnote into running text, simply insert the sequence
@foot(body of footnote)
into your text at the point where the superscripted footnote marker should
appear. The footnote in the previous sentence was generated by
To get a footnote@foot(Like this one) into running text, simply
Notice that SCRIBE automatically generates footnote numbers and puts them in
the proper places; don't put the numbers in yourself.
---------------
1
Like this one
PAGE 18 SCRIBE USERS' MANUAL
In providing such a simple footnote mechanism, we feel a responsibility to
advise you to use it sparingly. Footnotes seriously interfere with the
readability of a paragraph, and their excessive use will distract the reader
rather than help him.
3.6 Indexing
Some document types request that an index be generated at the end of the
document. This index does not magically become full of entries; rather, you
have to tell SCRIBE what to put in the index. It's really quite simple. You
use the @Index command, and provide the text of the index entry. SCRIBE will
fill in the correct page number and see to it that the entries are in
alphabetical order.
At any point in the text, you may put an index entry of the form
@index(Text to be indexed)
Nothing will appear in the running text output at that point, but "Text to be
indexed" will appear in the index with the correct page number:
Text to be indexed 18
@Index works like @Foot in that it doesn't interrupt the sequence of the
text. For example, the input
Place the peaches and apples@index(peaches)@index(apples)
in a glass jug and pour in the wine.@index(wine) A few
teaspoons of sugar may be added if a sweeter drink
is preferred, though it is not normally done.
will produce this output:
Place the peaches and apples in a glass jug and pour in the wine. A
few teaspoons of sugar may be added if a sweeter drink is preferred,
though it is not normally done.
You may consult the index of this manual to see how those three entries look.
You may put SCRIBE commands into the index text if you want, but if you
include any that cause a paragraph break you will get an unsatisfactory result.
As usual, if you want an @ sign to appear in the index, you have to use two:
PREPARING A MANUSCRIPT PAGE 19
@Index(@@index command)
The index entries will be sorted into alphabetical order according to the
standard "Ascii" code. If you've put an "@" sign at the front of an index
entry (as we have in the example of the last paragraph), then it will be sorted
as if "@" were the first letter. A facility exists whereby you can make things
appear in the index out of normal alphabetical order; you will have to consult
the Experts' Manual to learn how to use it.
3.7 Special Characters
Remember that a computer keyboard normally has only 95 characters on it.
People frequently want to include special characters, whether a Greek letter
like @g[P] or @g[z], or a mathematical symbol like ?< or ?7. These special
characters are not available on the keyboard as individual keys. If you are
using an output device that is capable of printing special characters, you can
get SCRIBE to print them for you. If you are not using such an output device,
you can get SCRIBE to leave space for you to write in the characters by hand.
3.7.1 Getting SCRIBE to Print Special Characters
SCRIBE lets you specify special characters via multiple-character "escape
sequences". They are called "escape sequences" (a piece of computer jargon)
because you escape from the normal meaning of the character. For example, if
your manuscript file contains
if A ?< B then @g(L) must be 0
then your finished output will contain
if A ?< B then @g(L) must be 0
The @g(L) to print a lambda is a "font-change" code, which changes to the Greek
font. Font-change codes are described in section 3.3; page GREEKMAP has a
table of the Greek letters that you can get with the @g command. The "?<" is a
special-character escape sequence to generate the less-or-equal character. A
table of the special-character codes is on page CHARMAP.
3.7.2 Faking Special Characters
If the printing device that you are using cannot print the character you have
asked for, SCRIBE will leave a blank spot there so that you can put the
PAGE 20 SCRIBE USERS' MANUAL
character in by hand. If you don't want to learn how to produce special
characters, you can do the same thing: just leave a blank spot in your
manuscript and then write the character in with a pen. Anywhere you put the
sequence "@#", SCRIBE will leave a blank space large enough to write one
character. Thus, if your manuscript file contains
Kaiser Wilhelmstra@#e
then SCRIBE will replace that "@#" by a wide space, printing:
Kaiser Wilhelmstra e
whereupon you would take pen in hand and write in the "?#" character:
Kaiser Wilhelmstra?#e
If you will need to write special characters in by hand, SCRIBE will produce
a list that shows you where this must be done; you need just sit down with the
list and a black pen and write the characters in.
DOCUMENT TYPES AND STYLES PAGE 21
4. Document Types and Styles
Remembering our view that SCRIBE aspires to be a substitute for a secretary,
consider the case in which a secretary is handed a rough draft of something and
told to "make a letter" or "make a memo." Part of his job is to know about
basic document types and to be able to produce them as needed. SCRIBE also
knows about basic document types, and will produce the kind of document that
you tell it to.
Each time SCRIBE is run, it produces a document of a particular "Document
Type" for a particular printing device. A Document Type includes a
specification of page format, paragraphing style, margins, heading and
subheading style, and so forth. Some document types are very specialized, such
as the one named "IEEE", which produces documents in the style and layout
demanded by the various IEEE journals. Other document types are very general,
such as the one named "TEXT", which produces paragraphed, justified text on
numbered pages.
Novice SCRIBE users should use the TEXT document type first (it's the
document type that you get if you don't ask for any particular one). As they
gain more experience with the system or as they find the need to produce more
complicated documents, they should try other document types.
4.1 SCRIBE's Database of Document Types
Document types are defined by entries in SCRIBE's database. When you request
SCRIBE to produce a particular document type, it searches its database for the
definition and then reads in the definition, thereby setting itself up to
produce the requested document. If SCRIBE cannot find in its database a
document type with the name that you ask for, it will tell you and then just
halt; it can't really go on.
4.2 Specifying a Document Type: the @Make command
The @Make command specifies document type. @Make(LETTER), for example,
specifies the "LETTER" document type; @Make(TEXT) specifies the TEXT document
type. The @Make command must come at the beginning of a manuscript file or it
will not be honored. By "beginning" we mean before any text or commands that
aren't "setup" commands. The five "setup" commands are @Make, @Device, @Style,
@Font, and @Part. If you use any of these five commands, all of them must come
before any of the other commands.
SCRIBE knows about the document types that are listed in figure 4-1, which is
to say that it is the list of names that you can put in a @Make command. Since
SCRIBE is still under development, we expect that the set of available document
types will be expanded in due time.
In the Experts' Manual that is a companion to the one you are now reading,
PAGE 22 SCRIBE USERS' MANUAL
REPORT A document with a title page, divided into numbered
chapters, sections, subsections, and the like; an automatic
table of contents and outline will be generated.
MANUAL Like REPORT, but with an index. This manual was produced
using document type MANUAL.
ARTICLE A sectioned document like REPORT, but without chapters;
SECTION is the highest-level of sectioning.
LETTERHEAD A business letter with CMU letterhead.
LETTER A personal letter; you provide the return address
POSTER A single-page poster or announcement
SLIDE An overhead-projector slide. Font and line spacing have
been chosen to maximize readability.
Figure 4-1: SCRIBE Document Types
you can find out how to define your own document types or modify the appearance
of existing ones. We recommend that you not attempt this until you are an
experienced SCRIBE user. In the meantime, you may use one of the variant
document styles described in the next section, or you may use the @Style and
@Font commands that are described in chapter 9 to get small changes in format
and style and type face.
4.3 Style Variations
SCRIBE's standard document type for producing user manuals is called
"MANUAL". This SCRIBE manual was produced in that style. Different people
like different styles, though, and one particular "Manual" style isn't going to
please everybody. SCRIBE therefore has a mechanism for changing the style of
formatting without changing the basic document type.
This manual was produced in form 1 of the document type "Manual". The @Make
command that was used to produce it was
@Make(Manual,Form 1)
If it had been instead
@Make(Manual,Form 2)
then the form-2 "Manual" format would have been used instead; if the @Make
command had been just
DOCUMENT TYPES AND STYLES PAGE 23
@Make(Manual)
then the normal "Manual" format would have been produced. These "forms", or
style variations, have been produced by various SCRIBE users who didn't like
the standard style. Form-1 "Manual" format uses different type fonts, while
form-2 "Manual" uses wider margins and wider line spacing.
Each time a new installation starts using SCRIBE, they find that they don't
like certain things about its formats. The new users typically make small
style changes to the document-type definitions in the SCRIBE data base. As
those small changes filter back to CMU, they get installed in our master
version of the data base as variant styles of our basic document types.
PAGE 24 SCRIBE USERS' MANUAL
5. Titles, Headings, Sections, and the Table of Contents
Almost every document has a title. Some have title pages. Others have
headings and subheadings here and there in the text. In this chapter, you will
find out how to get various kinds of titles and headings.
As usual, we'll start with some vocabulary. A document has one and only one
title. This title goes on the title page, at the top of the first page, or
something like that. A document can have many headings. Sometimes you might
want to put a few subheadings inside a heading. If you give numbers to
headings and subheadings, then they become sections. At the top (and/or bottom)
of every page are the page headings, sometimes known in the printing business
as "running headers".
Different document types use different schemes to produce headings or
sections. This manual, for example, was produced using the document type
"MANUAL"; it is divided into numbered chapters, sections, and subsections and
has a table of contents. A smaller document might have sections but not
chapters; a short piece of text might have just a heading or two. The
particular SCRIBE commands that you should use to get headings in your document
depend on what kind of a document you are producing.
5.1 Headings in a Document Without a Table of Contents
There is a simple set of heading commands to produce headings for documents
without tables of contents. They are simple because all they have to do is
print the heading: they don't have to give it a number or put it in the table
of contents. Use
MajorHeading to get large letters, centered.
Heading to get medium-size letters, centered.
SubHeading to get normal-size boldface letters, flush to the left
margin.
Thus, this input sequence:
@MajorHeading(This is a Major Heading)
@Heading(This is a Heading)
@Subheading(This is a Subheading)
will produce this output:
TITLES, HEADINGS, SECTIONS, AND THE TABLE OF CONTENTS PAGE 25
THIS IS A MAJOR HEADING
THIS IS A HEADING
This is a Subheading
That's all there is to it. Since these heading commands are really just
insert names, you can use the "long form" call on them also:
@begin(MajorHeading)
This is a Major Heading
@End(MajorHeading)
@begin(Heading)
This is a Heading
@End(Heading)
@begin(SubHeading)
This is a Subheading
@End(SubHeading)
will produce the same results as the previous example.
5.2 Headings in a Document Having a Table of Contents
A document having a table of contents must use a different set of commands
for headings. They are different because they must both print the headings in
the text and make an entry in the table of contents. Usually these commands
will automatically number the chapters and sections, though in some document
types they will not.
The use of these sectioning commands is as simple as can be:
@Chapter(Chapter Title)
declares (and prints) a chapter title;
@Section(Section Title)
declares (and prints) a section title.
In document types REPORT and MANUAL, you get the following sectioning
commands:
Left heading center heading Right heading
Chapter, Section, SubSection, and Paragraph
Appendix and AppendixSection
UnNumbered
PrefaceSection
In document type ARTICLE, you get the same list except "Chapter"; the
highest-order sectioning command in an ARTICLE is "Section". UnNumbered uses
the same style and font size as Chapter, but it is not assigned a chapter
number.
The easiest way to show you what these commands do is to draw your attention
to the table of contents at the front of this manual, and to reproduce here the
first few sectioning commands that were used in it:
@PrefaceSection(Preface)
@Chapter(Introduction)
@section(Some Explanation for Non-Programmers)
@section(Some Explanation for Programmers)
@chapter(Getting Started)
@section(Preparing Input for Scribe)
@section(Running Scribe)
@Section(Printing Devices)
@Subsection(Getting SCRIBE to Print Special Characters)
@SubSection(Faking Special Characters)
@Chapter(Preparing a Manuscript)
Notice that Chapter, Appendix, UnNumbered, and PrefaceSection all cause
SCRIBE to start at the top of a new page.
5.3 Numbering Pages and Page Headings
The information printed at the top or bottom of each page is called a page
heading (or page footing). Normally SCRIBE will number the pages for you,
putting a page number centered at the top of all pages after the first. You
may, if you like, change the page headings to any text that you want.
The page heading and footing areas are divided into three parts: a left
part, a center part, and a right part. These parts are printed at the left,
center, and right sides of the heading or footing area.
The headings and footings of this page are labeled to show you the position of
these six fields.
Page headings and footings are declared with the @Pageheading and
@PageFooting commands. The commands for this page said:
Left footing center footing Right footing
TITLES, HEADINGS, SECTIONS, AND THE TABLE OF CONTENTS PAGE 27
@Pageheading(left "Left heading",center "center heading",
right "Right heading")
@Pagefooting(left "Left footing",center "center footing",
right "Right footing")
The text fields inside the quotes can contain anything, including SCRIBE
commands. To get the current page number, use "@Value(Page)". To get the
date, use "@Value(Date)". Thus, this command:
@PageHeading(left "Reference Manual",center "@value(Date)",
,right "@value(page)")
will cause the pages to have "Reference Manual" in the top left corner, the
current date in the top center, and the page number in the top right corner.
Section 10.4.1 will tell you more about the @Value command.
The @Pageheadinng and @Pagefooting commands may take an optional parameter,
IMMEDIATE. If the IMMEDIATE parameter is present:
@PageHeading(Immediate,Left="Left heading",....)
then the heading of the current page will be changed. In the absence of the
"Immediate" parameter, the newly-declared heading or footing won't take effect
until the following page.
You may declare different page headings to be used on odd and even pages. If
you are going to be reproducing your document printed on both sides of the
paper, then you will want odd and even headings to be the mirror image of one
another. Use two different @PageHeading commands, one containing the keyword
"odd" and the other containing the keyword "even". The commands that generated
the page headings for this manual are:
@pageheading(even,right "@c[SCRIBE Users' Manual]",
left "@c[Page @ref(page)]")
@pageheading(odd,left "@c[@Title(Chapter)]",
right "@c[Page @ref(page)]")
The @Title command is described in section 10.4.2.
PAGE 28 SCRIBE USERS' MANUAL
5.4 Title Pages
The document types REPORT and MANUAL (and their variations) include a simple
mechanism for generating title pages.
Surround the title page text with a @Begin(TitlePage) and a @End(TitlePage).
These will cause the title page to be on a page by itself, and text within the
title page to be centered.
At CMU, the title page for a technical report should have the title, author,
and date of publication visible within a "box" that will be reproduced on the
cover of the report. To put text in this box, use the insert type "TitleBox".
If you do a @Begin(TitleBox), the next line of text will be positioned at the
very top of the title box region. When you @End(TitleBox), text assembly will
shift down to a region of the page that is no longer in the title box. To get
large or medium letters inside the title box, use the "MajorHeading" or
"Heading" commands described in section 5.1.
The insert type "CopyrightNotice" is used to put a copyright notice on the
title page. If you type this text into the manuscript file:
@CopyrightNotice(L. Frank Baum)
then SCRIBE will put the following line on your title page, at an appropriate
spot near the bottom:
Copyright -C- 1978 L. Frank Baum
for the current year.
The insert type "ResearchCredit" is used to put a research funding credit at
the bottom of the title page. Any text that you put between a
@Begin(ResearchCredit) and @End(ResearchCredit) will be placed in an
appropriate spot at the bottom of the page, justified and single spaced.
See appendix I.1 for an example of a title page.
FIGURES AND TABLES PAGE 29
6. Figures and Tables
Figures and tables are inserted into the manuscript file in very much the
same way as any other kind of insert: you mark the beginning with a
@Begin(Figure) or @Enter(Figure), and mark the end with an @End(Figure) or
@Leave(Figure). Between those delimiters you place the commands necessary to
produce the figure.
A figure has three parts:
1. A figure body. The figure body can be something you paste onto the
finished document. It can be an image picture printed on the XGP.
It can be text produced with SCRIBE. How you produce it is your own
business.
2. A caption. All figures must have captions. You provide the text of
the caption, and you decide how it is to be placed with respect to
the figure body.
3. A figure number. Figures are numbered sequentially. SCRIBE will
automatically assign numbers to figures, and you can use the standard
SCRIBE cross-reference mechanism (see section 8.1) to refer to them.
6.1 Generating Figure Bodies
You may generate the body of a figure using any of the standard SCRIBE
environments, such as FORMAT, VERBATIM, or EXAMPLE. You may also generate the
body of a figure using the special commands @Blankspace or @Picture. The
@Blankspace command leaves a blank space in your document; the @Picture command
(which works only on the XGP, and then only on the CMU XGP) inserts an image
1
picture into the document .
Figure 6-1: Sample Image Picture
6.1.1 The @Blankspace Command
The @Blankspace command makes a blank space of a specified size.
---------------
1
Image pictures are binary files produced by the SPACS program, the PLOT
program, and others. These programs are mentioned in the CMU Introductory
Users' Manual and are fully documented in other manuals.
PAGE 30 SCRIBE USERS' MANUAL
@Blankspace(3 inches) makes a blank space about 3 inches high; @Blankspace(16
cm) makes a blank space about 16 centimeters high. We say "about", because
SCRIBE will always leave a small margin above and below the blank space that
you request. You may use the distance units "inches", "in", "inch", "cm",
"mm", or "lines". If you specify the amount of blank space in lines, then the
amount that you actually get will depend on the font and printing device being
used.
6.1.2 The @Picture Command
The @Picture command needs two arguments: the size of the image picture,
measured in XGP scan lines, and the name of the PDP-10 file that will contain
the image picture at the time you are printing the document on the XGP. A
typical @Picture command might be:
@Picture(622,File "TEMP:IOBUS.IMG[F100CH00]")
This command will generate an image picture that is 622 scan lines high (about
3.4 inches), and whose definition can be found in the file "TEMP:IOBUS.IMG" on
1
the account F100CH00 .
6.2 Generating Figure Captions
Figure captions are generated with the @Caption command. The call is just
@Caption(Text of Figure Caption)
SCRIBE will add the word "Figure" and the correct figure number; what will get
printed in the finished document will be something like:
Figure 3-6: Text of Figure Caption
.
---------------
1
CMU Computer Science Department users please note: the file name and PPN
specified here are evaluated on CMU-10B, regardless of which machine you run
SCRIBE on. If you have different account numbers on different machines, make
sure that you use the 10-B account numbers in the @Picture command
FIGURES AND TABLES PAGE 31
6.3 Figure Numbers
Figures are numbered automatically during the processing of the @Caption
command. If you don't put a caption on a figure, it won't get a number. If
you want to reference the figure in the text of the document, you will want to
put a@Tag command into the body of the figure. The right place to put the @Tag
is after the @Caption. If you put it before the @Caption, you will get the
wrong figure number assigned to the tag, because the number will not yet have
been incremented.
6.4 Full-page figures
If you want to make sure that a figure occupies an entire page, use
"FullPageFigure" instead of "Figure":
@begin(FullPageFigure)
<figure body>
@Caption(figure caption)
@End(FullPageFigure)
The figure will be given a page to itself. If you want the caption at the
bottom of the page, you must put in the right amount of spacing yourself.
If you want to leave a blank figure page in the document, use the @Blankpage
command:
@Blankpage(1)
will leave one "blank" figure page. This figure page will have page headings
and footings, and will be given a page number, but nothing will be printed on
it.
You may remember that there is a @Newpage command (section 7.4.2), which
starts a new page and can leave a specified number of blank pages. @Blankpage
differs from @Newpage in a subtle but important way. When SCRIBE encounters a
@Newpage command, it skips immediately to the top of the next page. When
SCRIBE encounters a @Blankpage command, it makes a note about the blank page
request but continues on the current page; then when it finally comes to the
end of the current page, it will put in the extra blank page(s) at that point.
The sequence
PAGE 32 SCRIBE USERS' MANUAL
@Begin(FullPageFigure)
@End(FullPageFigure)
will yield exactly the same effect as
@Blankpage(1)
.
FORMAT CONTROL: TABS, COLUMNS, AND CURSOR MOVEMENT PAGE 33
7. Format Control: Tabs, Columns, and Cursor Movement
SCRIBE provides several ways to get text or numbers formatted into columns.
For simple formats or small amounts of tabular material, the VERBATIM
environment serves admirably. For more complex formatting, typewriter-style
tab stops, set in fixed columns, are available; they may be used in any
environment, but FORMAT is a frequent choice.
7.1 VERBATIM
For small amounts of tabular material, it might be easiest to format "by
hand" at the terminal and use a VERBATIM insert. In VERBATIM, SCRIBE copies
each line of the input manuscript file to one line in the output, and uses a
fixed-width font so that characters will line up correctly.
For example, if the input manuscript file contains this text:
@begin(Verbatim)
Directory listing 26-Jun-78 0:56:57
Name Extension Len Prot Access ---Creation---
ARTICL MAK 25 <155> 24-Jun-78 11:59 22-Jun-78
TEXT MAK 3 <055> 24-Jun-78 0:56 24-Jun-78
MCFREP MAK 9 <055> 26-Jun-78 18:30 24-Jun-78
MANUAL MAK 48 <055> 25-Jun-78 22:48 24-Jun-78
Total of 85 blocks in 4 files on DSKC: [C410BR10]
@End(Verbatim)
then the finished document, when printed, will look like this:
Directory listing 26-Jun-78 0:56:57
Name Extension Len Prot Access ---Creation---
ARTICL MAK 25 <155> 24-Jun-78 11:59 22-Jun-78
TEXT MAK 3 <055> 24-Jun-78 0:56 24-Jun-78
MCFREP MAK 9 <055> 26-Jun-78 18:30 24-Jun-78
MANUAL MAK 48 <055> 25-Jun-78 22:48 24-Jun-78
Total of 85 blocks in 4 files on DSKC: [C410BR10]
The fixed-width font is important so that columns will line up correctly: if
we printed that same text in our normal font (which has different widths for
different characters), it would come out looking like this:
PAGE 34 SCRIBE USERS' MANUAL
Directory listing 26-Jun-78 0:56:57
Name Extension Len Prot Access ---Creation---
ARTICL MAK 25 <155> 24-Jun-78 11:59 22-Jun-78
TEXT MAK 3 <055> 24-Jun-78 0:56 24-Jun-78
MCFREP MAK 9 <055> 26-Jun-78 18:30 24-Jun-78
MANUAL MAK 48 <055> 25-Jun-78 22:48 24-Jun-78
Total of 85 blocks in 4 files on DSKC: [C410BR10]
7.2 Tabs and Tabs Stops
SCRIBE has a tab-stop mechanism that works pretty much the way tabs on a
typewriter work. Tabs may be set in any horizontal position, and when a "tab"
command is found, SCRIBE will move right to the next tab stop and start
formatting there.
7.2.1 Setting Tab Stops
It's very simple to clear and set SCRIBE tabs. The @TabClear command will
clear all tabs, and the @Tabs command will set them. Thus, the sequence
@Tabclear
@Tabs(1inch,2inches,3inches)
will clear all tabs and then set new tabs 1, 2 and 3 inches from the left
margin of the current environment.
The @TabDivide command will divide the formatting area into a particular
number of columns, making them however wide they must be in order to fit that
many columns on the page. Thus,
@TabDivide(5)
will set 4 tab stops, each 1/5th of the way across the page. The right margin
serves as the final tab stop.
The @. command sets a tab in the current cursor position. Thus, the sequence
@tabclear
This line @.is for setting @.tab stops.
@\^@\^
FORMAT CONTROL: TABS, COLUMNS, AND CURSOR MOVEMENT PAGE 35
will clear all tabs and then set two new tabs. The document will show the
lines
This line is for setting tab stops.
^ ^
The exact location of these new tabs depends on the font in use. The first one
will be set at the distance that the letters "This line" occupy on the page.
7.2.2 Tabbing to a Tab Stop
The @\ command tells SCRIBE to move its formatting cursor to the right until
it encounters the next tab stop. If there is no tab stop to the right of the
cursor position, then it will be moved to the right margin.
The ^I or TAB character on your terminal's keyboard does not generate a
SCRIBE tab, but rather is converted into a series of blank spaces.
7.3 Fancy Cursor Control
This section tells you how to do more elaborate cursor control. These fancy
cursor-control features can be used, for example, to generate wierd
mathematical formatting. If you don't see how these features would be useful
to you, then they aren't.
7.3.1 Overprinting
The @ovp command allows you to overprint things. @ovp[text] lays down "text"
and then backspaces over it. Thus
Simple example of @ovp(=)/ overprinting.
will generate the output
Simple example of = overprinting.
If you use the @ovp command, your document will most likely not give
satisfactory results on a printing device other than the one you are used to,
because the appearance of overstruck letters varies markedly from one printing
device to another. If you want to overprint an underline character you would
PAGE 36 SCRIBE USERS' MANUAL
be better served to use the @U command, because different output devices use
different characters for underlining.
You can use @ovp to fabricate an approximation to some special characters.
The sequence "@ovp(?+)/" will generate "?+, which is a rough approximation to
the mathematical symbol for "is not a subset of". If you are going to be
producing a lot of special characters on the XGP, you would be better off
making a private character set file that contains those special characters; see
Section PRIVATEFONTS.
If you are so motivated, you can create real junk with the @ovp command:
This line is @ovp(Carefully)overstruck
produces:
This line is Carefullyk
7.3.2 The Return Marker
SCRIBE maintains a "return marker", which is a fixed memory of a particular
horizontal position on the page. You set the return marker by putting "@!" in
your text. Wherever "@!" occurs, the return marker will be set to the current
horizontal cursor position.
Whenever SCRIBE finds an "@/", it moves the cursor to the return marker.
This will work regardless of whether the cursor was to the left or right of the
return marker.
One use of the return marker is building super-subscripts:
A@!@+[i]@/@-[j]
generates
i
A
j
FORMAT CONTROL: TABS, COLUMNS, AND CURSOR MOVEMENT PAGE 37
7.3.3 Centering, Flush Left, and Flush Right
SCRIBE has commands that make it take pieces of text and center them or flush
them right. Left flush is no big trick.
To flush a text fragment right, it must be flushed "against" something.
Usually text is flushed to the right margin,
like this
but text can be flushed right against any tab stop:
text flushed
right
against a tab stop
To flush a text fragment to the right, you have to delimit the fragment to be
flushed and you have to tell SCRIBE what to flush it against. The code "@>"
(looking vaguely like a right arrow) says "begin a flush-right operation". If
there is a tab sequence (@\) later in the line, then SCRIBE will find the
column that the tab sequence tabs to, and then flush right against that column
position. If there is no tab sequence later in the line, then SCRIBE will
flush the rest of the line against the right margin.
It's time for an example. This input:
@tabdivide(3)
1.@>Flushed to right margin
2.@>to tab stop@\
3.@>longer line flushed to different tab stop@\
4.This line starts in the middle @>and flushes from here
produces this output:
1. Flushed to right margin
2. to tab stop
3. longer line flushed to different tab stop
4.This line starts in the middle and flushes from here
Since there is no @\ in line 1 after the @> code, the remainder of the line is
flushed against the right margin. Line 2 has a @\ tab code at the end, so the
line is flushed right against the tab stop to which that @\ tabs. Line 3 is
PAGE 38 SCRIBE USERS' MANUAL
like line 2, except that by the time the @\ code is reached, the line has
already passed the first tab stop, so the @\ moves to the second tab stop and
the line is flushed to that second tab stop. Line 4 shows a fragment of a line
being flushed right.
Before talking about the commands that center, let's talk about what we mean
by centering. Centering requires that there be a left and right marker of some
kind, and that the text be centered between them. For example,
this line is centered in the page
but
this is centered in this is centered in
the left half of the right half of
the page the page
SCRIBE uses tab stops and margins as the reference points for centering. If
there are no tab stops set, it will always use the current left and right
margins as centering guides. If there are tab stops, then SCRIBE will use them
instead. More detail in a minute.
To center something, you have to mark the left and right ends of the thing to
be centered. Mark the left end always with "@=". You may mark the right end
with "@\" (a tab), with another "@=", with a "@>", or with the end of the line.
If you mark the right end with nothing, then SCRIBE will center the remainder
of the line and use the right margin for a right-hand centering guide.
When SCRIBE finds a @= (begin centering) code or a @> (begin flushright)
code, it first checks to see if there was a previous unclosed @= or @> on the
same line. If there was, then SCRIBE simulates a @\ code (tab), which closes
the previous center or rightflush code. If this all sounds much too
complicated, then contemplate the following example. This input:
FORMAT CONTROL: TABS, COLUMNS, AND CURSOR MOVEMENT PAGE 39
@begin(format)
@TabDivide(4)
1.a@\b@\c@\d
2.@=e@\@=f@\@=g@\@=h
3.@=i@=j@=k@=l
4.Left@=Center@>right
5.Left@=Center@>right@\
@TabClear
6.Left@=Center@>right
@End(format)
produces this output:
1.a b c d
2. e f g h
3. i j k l
4.Left Center right
5.Left Center right
6.Left Center right
In line 1, the "b", "c", and "d" are positioned immediately after the three
tab stops set by @TabDivide(4), so they will serve as markers to help you see
the position of those tab stops. Line 2 has four letters, one centered in each
of the four columns. Each of them is in a centering field marked on the left
with a "@=" code and on the right with a "@\" (tab) code. Line 3 produces the
same effect without the "@\" codes; the "@=" code serves like a "@\" then the
"@\" is missing.
Compare lines 4, 5, and 6. In line 4, a centering zone is begun by a "@=";
the next code on the line is the "@>". Since there is no "@\" to close the
centered zone, the "@>" first simulates a "@\", thereby tabbing to the first
tab column, and centering the "Center" word between the left margin and the
first tab stop. There is no "@\" code to end the "@>" flush-right code, so the
rest of the line (i.e. the word "right") is flushed to the right margin. Line
5 is identical to line 4 except that there is a "@\" code at the end, which
causes "right" to be flushed to the appropriate tab stop and not to the right
margin. Line 6 is identical to line 4, but the tab stops have been cleared by
a @TabClear command. This makes the "Center" right marker be the right margin,
since there is not a tab stop for it to settle on.
7.4 Controlling Word, Line, and Page Breaks
SCRIBE sometimes decides to break a line at a place that you don't like;
sometimes it might break a page between two lines that really ought to be
together on the same page. This section tells you how to get things kept
together. It also tells you how to force word breaks, line breaks, and page
PAGE 40 SCRIBE USERS' MANUAL
breaks.
7.4.1 Controlling Word and Line Breaks
SCRIBE breaks lines between words. To change where it breaks a line, we must
change what it thinks is a word. Words are separated by blanks, so what we
need is a means of making SCRIBE think that a blank is part of a word rather
than a separator between two of them. A blank that is part of a word is called
a significant blank. The need for significant blanks arises often in
mathematical formatting. If you are going to write x = y, you don't want the x
on one line and the = y on another: you want to make the blanks into
significant blanks.
There are two ways to do this. The sequence "@ " (an @ sign and then a
space) generates a significant blank, which is treated by SCRIBE exactly as if
it were a letter. Thus, you could write
x@ =@ y
to make a single word out of that equation. For long and complicated
equations, it gets a bit tedious to put an "@ " instead of every blank; it's
also quite hard to read. SCRIBE therefore provides a command that makes all
blanks in its range into significant blanks: @w. So
@w[x = y]
produces the same results as our previous example.
The @| command is used to tell SCRIBE that it may break a word at that point.
If your text contains "Abra@|cadabra", for example, then the output document
might contain "Abracadabra" printed together as a single word, or it might
contain "Abra" on one line and "cadabra" on the next line, depending on how the
line filling happened. "@|" is stronger than @w -- if you use "@|" inside a @w
group, the "@|" will win, and a word break will be allowed there.
If you want to force a line break to occur before it otherwise might, use the
"@*" command. When SCRIBE is justifying text and comes across an "@*", it will
start a new line without justifying the old one. If SCRIBE encounters a "@*"
while processing unjustified text, it will be treated as if it were an
end-of-line.
FORMAT CONTROL: TABS, COLUMNS, AND CURSOR MOVEMENT PAGE 41
7.4.2 Controlling Page Breaks
Normally SCRIBE will start a new page when the old one is full, regardless of
what it is doing at the time. If SCRIBE happens to be processing an insert at
the moment that the page becomes full, the insert will be split across two
pages. It is often desirable to ensure that an insert will not be split across
a page. There are two ways to proceed if an insert will not fit on a page:
start a new page (leaving blank space at the bottom of the previous page), or
"float" the insert to the top of a nearby page and continue the text
uninterrupted at that point. Both of these options are available in SCRIBE. To
ask for them, you need to use the long-form insert specification (with @Begin
and @End).
To allow an insert to float if it won't fit on the current page, add the
keyword FLOAT to the @Begin marker:
@Begin(Verse,Float)
Text of verse
@End(Verse)
If the verse insert won't fit, the text will continue without interruption, and
the insert will appear on the top of the next page.
To require that a new page be started if an insert doesn't fit on the current
page, use the keyword GROUP:
@Begin(Display,Group)
Text of display insert
@End(Display)
The @HINGE command may be put into a GROUPed insert to allow it to be broken at
that point. If one or more @Hinge commands are in a GROUPed insert, it will be
treated as a sequence of smaller inserts, each one being GROUPed. @Hinge will
be ignored if it appears anywhere but inside a GROUPed insert. @Hinge always
forces a new output line.
If you would like to force a page break to occur prematurely, use the
@Newpage command. "@Newpage" causes SCRIBE to start at the top of a new page.
"@NEWPAGE(how many)" causes it to leave <how many> blank pages, then start at
the top of a new page. These pages will not be totally blank; rather they will
have page headings and/or footings. If you would like completely blank pages,
just put blank paper in your document at that point.
PAGE 42 SCRIBE USERS' MANUAL
8. Cross Reference, Bibliography, and Citation
SCRIBE does automatic bookkeeping of cross references of various kinds. One
kind of cross reference is the bibliographic citation, a reference to something
mentioned in the bibliography. Another kind of cross reference is the text
reference, which is a reference to some other part of the document.
8.1 Cross References
A cross reference is a notation like "see page 13" or "see chapter 5". If
you are typing a document by hand, it is a major feat to get cross references
right; and if you change anything, they are suddenly wrong again. The Joy of
Cooking, an 800-page kitchen classic, averages 7 to 8 cross references per
page. We shudder to think of the work that it took to get all 5000 to 6000 of
them right.
SCRIBE will do cross referencing automatically, by letting you define
codewords to mark places in the text, then filling in the correct page or
section number wherever you reference the codeword. There are two separate
kinds of cross references, but their use is nearly identical. You may refer to
the page or section number containing a piece of text, or you may refer to a
specific equation or theorem or example by number. These are called text
references and object references respectively.
8.1.1 Text References: the @LABEL Command
The mechanism for text references is quite simple. If you put the sequence
@LABEL(Codeword), for some codeword that you choose, anywhere in a document,
SCRIBE will note the page and section number at the spot where the @Label
appeared. If you put @REF(Codeword) somewhere else, SCRIBE will fill in the
section number of the text that contains the corresponding @Label; if you put
@PAGEREF(Codeword), SCRIBE will fill in the page number of the corresponding
label.
To take an example from this manual, we said on page 16 that
... each line in which a @TAG command (see section 8.1, page 42)
appears.
The manuscript file text that generated that line actually contains:
... each line in which a @@TAG command (see section
@ref(Xrefs), page @pageref(Xrefs)) appears.
CROSS REFERENCE, BIBLIOGRAPHY, AND CITATION PAGE 43
Someplace in section 8.1 there is a @Label(Xrefs) command. "Xrefs" is a
codeword that was picked more or less arbitrarily to stand for that section.
You must choose your own codewords and spell them the same everywhere in the
document.
If a @REF at the beginning of a document references a @LABEL at the end,
SCRIBE will use the page number that was generated the last time the document
was processed. If the document has never been processed before, then there
won't be any "last time", and SCRIBE will tell you to process the file a second
time if you want the cross references right.
If you have made changes to a document, some of the cross references might be
wrong the first time you SCRIBE it after making those changes. If this
happens, SCRIBE will tell you; you then have the option of printing the file as
it stands (with the errors, but knowing that it's not your final copy and that
you don't need perfection), or of re-running SCRIBE to get the cross references
right. They will be right the second time because the correct values for all
labels will have been stored in an auxiliary file, which SCRIBE will read in
before the second processing. Since the normal evolutionary development of a
document involves alternate editing and reprocessing, the references will be
correct almost all of the time, and if you want perfection on a particular run,
it is simple enough to run it through twice.
SCRIBE builds an "AUX" file that contains the various pieces of information
that it must remember from one run to the next. Cross-reference labels are
included in this AUX file. If you are processing a file named, say,
"RECIPE.MSS", then SCRIBE will store its auxiliary information in a file named
"RECIPE.AUX".
8.1.2 Object References: the @TAG Command
One of the most valuable features of SCRIBE is its ability to number things
for you, and thus to renumber them if changes are made. Automatic page
numbering is pretty much taken for granted; we have already mentioned the
automatic numbering of sections (Section 5.2) and of equations or theorems
(Section 3.4.2). SCRIBE will number anything it can count; you can also attach
a cross-reference tag to anything that SCRIBE can count.
Let's talk about the difference between the @Label command and the @Tag
command; this difference is a bit subtle. A sectioned document has many
different sequences of numbers that identify the pieces of it. Pages are
numbered sequentially; chapters and sections and such are usually numbered
independently of the pages. Figures and tables are often numbered within a
PAGE 44 SCRIBE USERS' MANUAL
chapter, ignoring section numbers. If you want to attach a codeword to the
section number of the section that contains a particular theorem or example or
figure or table, then use @Label. If you want to attach a codeword to the
theorem number or example number or equation number, rather than to the section
that it is contained in, use the @Tag command.
It's time for some examples. You should remember from section 3.4.2 that the
THEOREM and EQUATION environments are used to print theorems and equations and
automatically to assign numbers to them. You may place an @Tag command inside
a THEOREM or an EQUATION to define a label so that you may reference the
equation or theorem number. You may also place a @Label command inside a
THEOREM or an EQUATION so that you may reference the section number or page
number on which the theorem or equation occurs.
This unlikely input text:
@begin(Theorem)
@tag(imbed)
@label(ImbedSec)
If G is a non-self-embedding context-free grammar, then
L(G) is a regular set.
@End(Theorem)
It follows immediately from Theorem @ref(Imbed), that ...
[and in a later section...]
We showed in section @ref(ImbedSec) in Theorem @ref(imbed) ...
might produce this output text:
Theorem 4.10: If G is a non-self-embedding context-free grammar,
then L(G) is a regular set.
...It follows immediately from Theorem 4.10, that ...
We showed in section 4.6 in Theorem 4.10 ...
8.2 Bibliography and Citation
A bibliography is a labeled list of books, articles, papers, and the like. A
citation is a marker in the text that refers to an entry in the bibliography.
Thus, if a section of your bibliography looks like this:
[15] E. W. Dijkstra. Co-operating Sequential Processes. In F. Genuys, editor,
Programming Languages, pages 43-110. Academic Press, 1968.
CROSS REFERENCE, BIBLIOGRAPHY, AND CITATION PAGE 45
[16] Mary-Claire van Leunen. A Handbook for Scholars. Alfred A. Knopf, 1978.
[17] A. van Wijngaarden, B. J. Mailloux, J. E. L. Peck, and C. H. A. Koster.
Report on the Algorithmic Language ALGOL 68. Mathematisch Centrum,
Amsterdam, 1969.
then text with citations might look like this:
M. van Leunen, in her lively and detailed book, argues against the
bibliographic footnote [16].
The original language, which was rather more cumbersome to learn and
to use, is defined in van Wijngaarden et al [17].
The SCRIBE bibliography facility does three things:
1. Selects from a database the bibliographic entries that are actually
cited,
2. Formats them into a bibliography and assigns a number or label to
each, and
3. Causes the correct numbers to be placed in the citations in the text.
8.2.1 Bibliography Files
Because SCRIBE selects and prints only those entries in a bibliography that
are actually cited in the text, you may use a common bibliography "database"
for many different documents. This database is in a separate file which we
will call the bibliography file. Each entry will be given an identifier, or
name, by which it is cited. These identifiers work in very much the same way
as do the @label/@ref cross-reference keywords (see section 8.1): an identifier
is defined in one place (the bibliography) amd cited in others (@cite commands
in the text).
The bibliography file thus consists of a series of entries, each with an
identifier. Each entry also has an entry type and a list of data fields. For
example, the bibliography file entries for our examples of the previous section
might be
PAGE 46 SCRIBE USERS' MANUAL
@InBook(Dijkstra69, Author "E. W. Dijkstra",
Title "Co-operating Sequential Processes",
Editor "F. Genuys",
Title "Programming Languages",
Publisher "Academic Press",
Date "1969"
)
@Book(VanLeunen78,Author "Mary-Claire van Leunen",
Title "A Handbook for Scholars",
Publisher "Alfred A. Knopf",
Date "1978"
)
@Report(ALGOL68,Author "A. van Wijngaarden, B. J. Mailloux,
J. E. L. Peck, and C. H. A. Koster",
Title "Report on the Algorithmic Language ALGOL 68",
Publisher "Mathematisch Centrum, Amsterdam",
Date "1969"
)
In this example, the names "Dijkstra69", "VanLeunen78", and "ALGOL68" are the
identifiers by which these bibliography entries will be cited. The text of the
document would contain @Cite commands that reference those identifiers.
Any text following a bibliography file entry is assumed to be an annotation
or commentary on that entry, and will be included in the bibliography printed
in your document.
Normally SCRIBE will look for a file with an extension of ".BIB" as the
bibliography file for a document; i.e. if your manuscript file is "THESIS.MSS",
SCRIBE will use "THESIS.BIB" as the bibliography file. You may use the @Use
command, described in section 10.5, to request that SCRIBE use some different
file for the bibliography file for your document.
8.2.2 Citations
Citations are simple. Just put a @cite command into your text at the spot
where the citation should appear. @Cite takes one or more identifiers to tell
it what to cite:
@cite(Knuth59)
@cite(Guarino78,Cooprider78)
CROSS REFERENCE, BIBLIOGRAPHY, AND CITATION PAGE 47
These will be processed by SCRIBE into standard form citations:
[12]
[5,16]
8.2.3 Alternate Citation Styles
Some people don't like straight numeric citations, though it is the form most
frequently needed in preparing papers for publication. Some journals require
other forms, though, and therefore provides a style parameter to change
citation style. You may choose:
1. Straight numeric citation. This is normally the default: [6].
2. Author's last name and year: [Guarino78].
3. First 3 characters of author's last name, and year: [Gua78].
4. Print the identifier instead of a generated label.
You may set the bibliography style using the CITATION parameter to the @Style
command:
@Style(CITATION=1) or @Style(CITATION=4), etc.
Some document types may include a specification of CITATION style of other than
1; this is why we said that style 1 is normally the default rather than style 1
is the default.
PAGE 48 SCRIBE USERS' MANUAL
9. Changing Things
Although SCRIBE's basic approach to document production is to provide its
users with a large menu of document types and discourage them from tinkering
with details, we recognize that the urge to tinker is incurable. SCRIBE
therefore provides two commands that may be used to make small changes in the
format and style of a document.
9.1 Changing Type Font: The @Font Command
The @Font command tells SCRIBE to use a particular type font. For use with
SCRIBE, a "font" is a collection of type faces, chosen to look harmonious when
used together. A font will often contain 10 to 15 different type faces in
diferent sizes and styles. For example, a typical font will contain Roman,
Boldface and Italic in both body text size and footnote text size; it will also
contain various sizes of heading and title fonts, usually without italics and
boldface. A font, like a document type, is defined by an entry in SCRIBE's
database. This font database entry is a list of information of the form "when
I say @B, I mean Times Roman Bold; when I say @R, I mean Times Roman Medium."
An entry like that would be found in a font whose name was "Times Roman", which
would be specified by the command @Font(TimesRoman).
9.2 A List of Available Fonts
At CMU at the time of this writing (August 1978), the following fonts are
available for use with SCRIBE. Many different character-set files exist for
the XGP, but very few of them are attractive enough and readable enough to
warrant printing a document in them. Each SCRIBE font uses 10 to 15 different
character-set files.
Here is the list; a sample of each is in appendix FONTSAMPLES:
News Gothic 10
News Gothic 12
Nonie 12
Nonie 9
Meteor 12
Meteor 9
Baskerville 12
Bodoni 10
The number associated with a font is its height in "points", which is a unit of
printer's measure. A 10-point type like News Gothic 10 is about the same size
as a standard Elite typewriter font.
For Diablo printers, a font simply specifies a type wheel and a list of
CHANGING THINGS PAGE 49
special characters to be constructed with it; SCRIBE knows about these fonts
(typewheels) for the Diablo:
Elite
Pica
Although users may create their own fonts by creating their own database
entries, we defer description of this process to the Experts' Manual. If you
have a private character set for the XGP that you would like to use, see
section PRIVATEFONTS.
The HELP text for SCRIBE, which you can see by typing HELP SCRIBE to the
monitor, will give you instructions for finding out the current list of
available fonts.
9.3 The @Style Command
The @Style command changes the settings of certain of SCRIBE's internal
parameters. These parameters form a sort of "genetic code"; each parameter is
somewhat like a gene. There is a parameter that controls whether or not SCRIBE
makes a flush right margin. There is a parameter that controls how much space
SCRIBE leaves between lines; another that controls the distance that each
paragraph is indented.
The database entry for a document type presets the value of all SCRIBE
parameters. You may use the @Style command to override these values. All
@Style commands used in a document must come at the beginning; you can't change
styles in mid-document.
Let's consider a small example. The document type TEXT specifies no
paragraph indentation; it adds an extra blank line between paragraphs instead.
If you wanted to change to standard typewriter-style indentation (5 spaces),
you could put the command
@Style(Indentation,5)
into your manuscript file. SCRIBE would then indent paragraphs 5 spaces. If
you also wanted to suppress the extra blank line between paragraphs, you could
say
@Style(Indentation 5, Spread 0)
or alternatively you could say
PAGE 50 SCRIBE USERS' MANUAL
@Style(Indentation 5)
@Style(Spread 0)
The word "Spread" was chosen to mean inter-paragraph spacing solely because
it would be pretty tedious to type @style(Inter-ParagraphSpacing 0).
Some style parameters expect names instead of numbers; others expect quoted
strings. For example:
@Style(Justification Off)
will turn off right-margin justification, while
@Style(Footnotes "*")
tells SCRIBE to use asterisks instead of numbers when enumerating footnotes.
9.4 A List of STYLE Parameters
This table lists the style parameters that you can specify in the @Style
command, and briefly describes what they do.
Indentation Controls paragraph indentation in text. A horizontal distance
should be provided:
@Style(Indentation 5)
means to indent 5 spaces. If you want backwards indentation,
give it a negative number.
Spacing Controls inter-line spacing. A vertical distance should be
provided: "2" means "2 lines", i.e. double space. If you want,
say, one-and-a-half spacing, then say
@Style(Spacing 1.5)
The default spacing that you get depends on the document type
being produced.
Spread Controls the inter-paragraph spacing, i.e. the extra space,
over and above the line spacing, that will be put between
paragraphs.
Justification A "Yes", "No", "On", or "Off" tells SCRIBE whether or not to
CHANGING THINGS PAGE 51
justify the right margin. Don't put the word in quotes:
@Style(Justification Off)
@Style(Justification On)
LeftMargin This parameter will change the size of the left margin of the
pages. For example,
@Style(LeftMargin 1.3 inches)
will cause the page to have a 1.3-inch left margin. The
"margin" of a page is the white space at the edge of the paper,
so if you specify a bigger number here, it will make a bigger
white space and hence leave a smaller print line.
RightMargin This parameter will change the size of the right margin. The
RightMargin parameter and the PaperWidth parameter both affect
the length of the printed lines. Remember that the "margin" is
the white space at the edge of the paper, so increasing the
size of the RightMargin parameter will increase the size of the
margin, hence decreasing the amount of space taken by the print
line.
TopMargin Changes the top margin of the page.
BottomMargin Changes the bottom margin of the page. The BottomMargin
parameter and the PaperLength parameter both affect the size of
the printing area on the page.
PaperLength Used to specify the length of the paper that you are using.
For example,
@Style(PaperLength 14 inches)
specifies legal-size paper.
PaperWidth Used to specify the width of the paper that you are using.
Footnotes Controls the way that footnotes are numbered. The normal
numbering scheme is numeric: the first footnote is numbered
"1", the second one "2", and so forth.
@Style(Footnotes "@*")
PAGE 52 SCRIBE USERS' MANUAL
will cause the numbering to be "*", "**", and so forth. If you
want some other numbering scheme used, specify a template. See
the Experts' Manual to find out what that means.
9.5 Miscellany
This section documents a few odds and ends that don't seem to belong anywhere
else. They probably don't belong here either, but they've got to go somewhere.
9.5.1 Changing Command Names
If you really don't like SCRIBE's name for some command, you may use the
@Equate command to define your own equivalent. The format is
@Equate(New=Old,New=Old,...)
Let's suppose, for example, that you don't like the name "Enumerate". You
think it's too long. You would like to be able to say "@En" instead of
"@Enumerate". Then enter at the front of your file the command
@Equate(EN=Enumerate)
From then on, you will be able to say
@begin(en)
@end(en)
or even just
@en{...}
You may not use @Equate to change the meaning of an existing name. If you
try, say,
@Equate(Itemize=Enumerate)
SCRIBE will complain mightily and refuse to execute the @Equate.
CHANGING THINGS PAGE 53
9.5.2 Changing Counter Values
SCRIBE counters are things like "page", "chapter", and "TheoremCounter".
They are incremented from time to time from inside SCRIBE, with values ranging
from 1 to whatever.
Sometimes people don't like the counter numbers to be so well-behaved.
SCRIBE therefore provides a command to let you meddle with counter values. For
example, the command
@set(Page=8,Chapter=4)
will set the page number to 8 and the chapter number to 4. If you would like to
add or subtract some quantity to or from a counter, use a + or - sign: the
command
@Set(Page=+3)
adds 3 to the current page number.
We would like to refer you to the separate compilation facility, described in
section 10.2, as a better way of doing the deeds that you are probably trying
to accomplish when you go about meddling with counter values.
PAGE 54 SCRIBE USERS' MANUAL
10. Producing Large Documents
Big documents are proportionately much harder to produce than small ones.
The amount of work needed to produce one 200-page document is several times
that needed to produce ten 20-page documents. Bookkeeping becomes a chore.
The amount of file space used becomes huge. It can take an hour or two of
elapsed time just to process a 200-page document through SCRIBE when the system
is heavily loaded.
SCRIBE has a large-document facility, with several independent mechanisms,
that make it easier to produce large documents. The large-document facility
includes:
- An @include command, that allows a document to be split into multiple
files, each one of which is of manageable size.
- A @part command that lets you separately process one component file
of a document, yet have page numbers, section numbers, chapter
numbers, and cross references still come out right.
- A @string command that lets you store commonly-used text sequences
and recall them by name when they are to appear in the document.
- A @use command to request that SCRIBE use some private or custom
edition of its database.
- An automatically-generated outline of your document, created in a
separate file, to help you manage its organization.
10.1 Breaking a Manuscript into Several Smaller Files
SCRIBE normally reads sequentially through a manuscript file, processing text
and commands as it comes to them. The @Include command makes SCRIBE suspend
processing of the main manuscript file, process a second file, then resume
processing of the original manuscript file. For example, if your manuscript
file contains
00100 The Wicked Witch was both surprised and worried when
00200 she saw the mark on Dorothy's forehead, for she knew
00300 well that neither the Winged Monkey nor she, herself,
00400 dare hurt the girl in any way.
00500 @Include(SUBFIL.MSS[C410BR10])
00600 At first the Witch was tempted to run away from Dorothy;
00700 but she happened to look into the child's eyes and saw
00800 how simple the soul behind them was, and that the
PRODUCING LARGE DOCUMENTS PAGE 55
00900 little girl did not know of the wonderful power the
01000 Silver Shoes gave her.
and if the file whose name is SUBFIL.MSS[C410BR10] contains
00100 She looked down at Dorothy's feet, and seeing the
00200 Silver Shoes, began to tremble with fear, for she knew
00300 what a powerful charm belonged to them.
then the finished document will contain the text
The Wicked Witch was both surprised and worried when she saw the mark
on Dorothy's forehead, for she knew well that neither the Winged Monkey
nor she, herself, dare hurt the girl in any way. She looked down at
Dorothy's feet, and seeing the Silver Shoes, began to tremble with
fear, for she knew what a powerful charm belonged to them. At first
the Witch was tempted to run away from Dorothy; but she happened to
look into the child's eyes and saw how simple the soul behind them was,
and that the little girl did not know of the wonderful power the Silver
Shoes gave her.
@Include requests may be nested, i.e. a file that is processed because of an
@Include command may itself contain other @Include commands naming yet more
files. The name "@File" is a synonym for "@Include", and may be used
interchangeably with it.
To break up a large document into component manuscript files, it is best to
build a small "root" file that contains the @Make, @Device, and @Style commands
and then has a series of @Include commands that include all of the text. Each
of these @Include commands includes one part of the document. It is usually
convenient to divide a document into separate chapter files, with one @Include
for each chapter, but any division that is convenient for you is acceptable.
Figure 10-1 shows the root file for the CMU Computer Primer, a large document
produced with SCRIBE. It prints the title page, then includes in turn each of
the chapter files.
The file CH0.MSS contains the preface, introduction, and such. CH1.MSS
contains the text of chapter 1, CH2.MSS contains the text of chapter 2, and so
forth. The "@Chapter" command is in the included file and not in the root
file.
PAGE 56 SCRIBE USERS' MANUAL
@device(XGP)
@make(Primer)
@pageheading(left "@c[CMU Computer Primer]",Right "@value(page)")
@begin(TitlePage)
@begin(TitleBox)
@begin(MajorHeading)
COMPUTER
PRIMER
@end(MajorHeading)
@begin(Heading)
For Computer Science Department
Computer Users
@end(Heading)
by
Brian K. Reid
@value(Month) @value(Year)
@end(TitleBox)
@begin(Heading)
Carnegie-Mellon University
Computer Science Department
@end(Heading)
@CopyrightNotice(Brian K. Reid)
@end(TitlePage)
@include(ch0.mss)
@Include(ch1.mss)
@Include(ch2.mss)
@Include(ch3.mss)
@Include(ch4.mss)
@Include(ch5.mss)
@Include(ap1.mss)
@Include(ap2.mss)
Figure 10-1: Sample Root File
10.2 Separate Processing of Component Files
If you have used the @Include command to break your manuscript into small
component files, you may process them independently as manuscripts in their own
right. By judicious use of the @Part command, which we will shortly describe,
PRODUCING LARGE DOCUMENTS PAGE 57
you may separately process the components of a large document for draft copy
purposes, yet be able to process the whole thing without having to change any
of the components.
10.2.1 Component Files As Separate Documents
It frequently arises that some masterful piece of prose will be published as
a chapter of a larger work as well as be published on its own. By carefully
keeping its head in the sand at the right times, SCRIBE lets you set up files
so that they will work both as included parts of a large document and as
documents in their own right.
SCRIBE ignores certain commands if they are found inside an included file,
but processes the same commands if they are found in a root file. This lets
you put commands into a file that will be ignored if it is part of a larger
document but will be processed if it is being produced as a document in its own
right.
The commands @Device, @Make, @Style, and @Font will be ignored if they are
found in an included file but processed if they are found at the beginning of
the root file. The text inside a TitlePage environment (see section 5.4) will
also be ignored inside an included file.
You may therefore put at the beginning of a file the commands necessary to
process it as a stand-alone document, trusting that they will be ignored if it
is included as part of a larger document.
10.2.2 Separate Processing of Component Parts
For very large documents, the processing time for the full document is large
enough for it to be wasteful to re-process and re-print all of the document
when only a piece of it has changed. A person working on a small section of a
large document would like to be able to produce a draft copy of that section
without coping with the whole thing. When each chapter is produced by a
different author, the several authors would each like to be able to get proof
copies of their chapter apart from the other text. For situations like these,
SCRIBE provides a @Part command, which supports separate compilation of
fragments of a larger document.
To take advantage of this separate compilation facility, place a @Part
command at the front of each included file. It should be the first command in
the file. The @Part command must provide two items of information: a name for
PAGE 58 SCRIBE USERS' MANUAL
the part and the file name of the root file of the document. Thus
@Part(Chapter3,root "primer.mss")
defines a part whose name is "Chapter3" and that is part of the document whose
root file is PRIMER.MSS. The name that you choose for the part is just a name,
and may be any combination of letters, digits, and "-" characters.
Having put @Part commands, each with a different part name but all specifying
the correct root file, into the various subfiles, you must process the entire
document once to record the part information. When SCRIBE finds a @Part
command in an included file, it makes a note of the part name and the page and
section numbers at that point. These notes are saved along with the
cross-reference data in the AUX file for the document.
Once there exists an AUX file with part information stored in it, you may
process any part by itself. If SCRIBE finds a @Part command at the beginning
of a file it is asked to process, it assumes that you are separately compiling
a piece of a larger document and enters a special sub-compilation mode. SCRIBE
does three special things in sub-compilation mode:
1. SCRIBE finds the root file and processes the @Device, @Make, @Style,
@Font, @Equate, @PageHeading, and @PageFooting commands that are in
it. Some other commands, documented only in the Experts' Manual,
will also be picked up from the root file.
2. SCRIBE restores the page and section numbers to the correct values
for the part being processed.
3. SCRIBE reads in the cross-reference label definitions for the entire
document, and not just for the part being processed.
The result of this complicated series of acts is that the separately-compiled
part will be produced with the correct page and section numbers; if it contains
any cross references to labels defined in some other part, the references will
be correct.
At the end of processing a separately-compiled part, SCRIBE will update and
rewrite the AUX file. If the number of pages in the part has changed since the
last processing, SCRIBE will correct the stored page number information for
parts that follow this one, in order that page numbers will be right if other
parts are later processed.
The index and table of contents produced by processing a part will reflect
PRODUCING LARGE DOCUMENTS PAGE 59
only the contents of that part. If a new part is to be added, the entire root
file must be processed to incorporate the new part correctly.
10.3 Defining and Using Text Strings
The @String command provides a mechanism for storing a series of characters
under a particular name, then including that series of characters in the
document by referring to the name in a @Ref command.
10.3.1 The @String Command
@String defines names to equal a quoted string:
@String(CACM="@i[Communications of the ACM]")
@String(EQ4="@i[x]@+[2]+4*@i[x]*@i[y]-17*@i[y]@+[2]")
@String(Name="J. Alfred Prufrock", Agency="Rutabaga, Inc.")
You need not use quotation marks; any of the delimiters described in section
3.1 will work. To use these text strings that you have defined, call them
inside a @Ref command. For example, if the @String commands of the previous
example have been processed, then this input:
Prior work was published in @ref(CACM).
The solution is @ref(EQ4).
@Ref(Name) no longer is employed by @ref(Agency).
will produce this output:
Prior work was published in Communications of the ACM.
2 2
The solution is x +4*x*y-17*y
J. Alfred Prufrock no longer is employed by Rutabaga, Inc.
If both a text string and a cross-reference label are given the same name, then
the @Ref will refer to the text string and not to the cross-reference label.
10.4 Environment Inquiry: Predefined Strings
SCRIBE has a mechanism that allows you to include in your document various
characteristics of the processing environment, such as the date and the name of
the file being processed. These things are called "internal strings" because
they are defined inside SCRIBE.
PAGE 60 SCRIBE USERS' MANUAL
10.4.1 Internal Strings and the @Value Command
The @Value command is used to access internal strings. For example,
@Value(Date) will produce the current date at that point in the document, and
@Value(Manuscript) will produce the name of the manuscript file. Thus, if you
put in your manuscript file the text
This document was produced on @Value(Date).
then your document will contain the text:
This document was produced on 7 August 1978.
@Value(Date) will produce the current date. The precise format in which the
date will be printed is controlled by the "DATE" parameter to the @Style
command. Normally the date will print this way: "7 August 1978". However, if
you have put a @Style command at the front of your manuscript file that
specifies a DATE style, it might come out in a different format.
@Style(Date=1) is the default. @Style(Date=2) gives you "August 7, 1978".
@Style(Date=3) gives you "7 Aug 78". @Style(Date=4) gives you " 7 AUG 78".
@Style(Date=5) gives you "08/07/78".
@Value(Month) will return the full name of the current month, e.g. "August".
@Value(Day) will give you the day number in the current month, e.g. "7".
@value(Year) will return the current year, e.g. "1978". @Value(Weekday) will
give you the name of the current day of the week, e.g. "Monday". @Value(Time)
will tell you the time, in 24-hour notation, to the nearest minute, when the
current SCRIBE run began; e.g. "02:26". To get a "time stamp" that records the
date and time of processing, use @Value(TimeStamp); it will give you a value
like "7 August 1978 at 02:26".
You can also inquire about the files that SCRIBE is working on.
@Value(Manuscript) tells you the name of the manuscript file that SCRIBE is
processing, e.g. "USERL.MSS". @Value(SourceFile) tells you the particular
place in the manuscript file or the @Included subfile that SCRIBE is processing
at that moment, e.g. "UMCH10.MSS, 05800/5. And if you really must know,
@value(ScribeVersion) tells you the version of SCRIBE that is doing the
processing, e.g. "CMU 0E(110)-5".
If you are producing a document with a table of contents, then you may
inquire as to the number or title of the current section. @Value(SectionTitle)
gives you the title of the chapter, section, subsection, or whatever is
PRODUCING LARGE DOCUMENTS PAGE 61
appropriate, e.g. "Internal Strings and the @Value Command".
@Value(SectionNumber) gives you its number, e.g. "10.4.1". @Value(Page) tells
you the current page number, e.g. "61".
10.4.2 Current Values of Counters
If the @Ref command is applied to a counter, e.g. PAGE or CHAPTER, it will
give the current numeric reference value of that counter. If the @Title
command is applied to a counter, it will give the current title associated with
that counter. Thus, at this point in the SCRIBE manual, "@Title(Chapter)"
returns "Producing Large Documents" and "@ref(Chapter)" returns "10".
There is a bit of ambiguity between @Value(Page) and @Ref(Page): they both
do exactly the same thing. Early versions of SCRIBE did not have the @Value
command, so @Ref(Page) is left in the system for compatibility.
If you ask for the title of a counter that has no title, a null string will
be returned: "@Title(Page)" returns "".
10.5 File Names and the @Use Command
The "@Use" command directs SCRIBE to use other database, bibliography, and
auxiliary files than it normally would. For example, SCRIBE will normally look
for an AUX file with the same name as the manuscript file: if your manuscript
file is "PRIMER.MSS", the AUX file would be "PRIMER.AUX". If you put the
command
@Use(AuxFile "OTHER.AUX")
at the front of your manuscript, then SCRIBE will use "OTHER.AUX" instead of
"PRIMER.AUX". The extension ".AUX" will always be used.
To request that SCRIBE use some particular bibliography file, use the @Use
command with the parameter "Bibliography":
@Use(Bibliography "PROSYS.BIB[C410HB00]")
The extension ".BIB" is not required, any extension is allowed.
The @Use command may also be used to direct SCRIBE to use a nonstandard
version of the database. If you put the command
PAGE 62 SCRIBE USERS' MANUAL
@Use(Database "somewhere")
at the very beginning of your root file, then SCRIBE will interpret "somewhere"
as the location of a database and will look there for everything that it needs.
The precise nature of the "somewhere" string depends on the details of the
computer system in use; sample strings for various popular computer systems are
"<Jones>", "[M100MD0C]", and "[51,1062]".
WARNING
If you develop your own version of the SCRIBE database, the software
maintainer disavows any responsibility to maintain compatibility
between your private database and future versions of the program.
EPILOGUE AND SERMON PAGE 63
11. Epilogue and Sermon
The guiding principle that shaped every aspect of the design of SCRIBE is
that most people who produce documents don't know or care about the details of
the formatting involved. To this end, those details are determined by
information in SCRIBE's database and not by commands from the user.
The benefits of this somewhat arrogant approach are legion. For those people
who really don't care about details, it is possible to produce attractive
formatted output with very little work and even less decision-making. To
produce a document for a different printing device, the simple change of one
@Device command will yield a completely different set of formats, designed to
look attractive on the new device.
The cost of this approach is that it is not always possible to get every
character to land on the page in precisely the spot that you think it ought to.
Trying to force SCRIBE to format one way while it is trying to format in
another way is like pulling teeth: possible but painful.
Please don't use pliers on SCRIBE. If you find yourself fighting with SCRIBE,
you are probably not using it right. If you catch yourself constantly thumbing
through the table of commands and style parameters, trying to find the command
or parameter that will force some particular character to a particular column,
then you are not using SCRIBE correctly. And if you ever catch yourself, even
once, wanting to use the @Blankspace command outside a figure, then you are
definitely using SCRIBE wrong.
If you find yourself fighting SCRIBE, think carefully about what that means:
SCRIBE is trying to produce a document in one format, while you want it to be
in another. You have several recourses:
1. Learn to like the standard SCRIBE formats. This is by far the
simplest approach. Not everyone needs to be a typographer.
2. Look at all of the variant styles that are in the SCRIBE database.
Perhaps one of them will please you. You can get these variant
styles by using the "Form" parameter to the @Make command; see
section 4.3 for details.
3. If none of the standard or variant styles pleases you, then you are a
very finicky person. To indulge your finickiness you are going to
have to work hard. If you are not willing to work hard, go back to
step 1; it might be more appealing the second time around. If you
are willing to work hard, then go get a copy of the Experts' Manual,
curl up in a comfortable place, and read it from cover to cover. If
PAGE 64 SCRIBE USERS' MANUAL
that doesn't stop you, then roll up your sleeves and go make your own
document style. Please tell me about it when it's done, so that I
can add it to the SCRIBE database for other people to use.
One final behest: please don't complain to me about the formats that SCRIBE
produces. SCRIBE is capable of producing almost any format at all, but it
comes from the factory equipped to produce formats that I happen to like. If
you don't like my formats, don't complain to me about it. Either learn to like
them or make your own.
A FEW EXAMPLES PAGE 65
I. A Few Examples
This appendix is full of random examples. All of them were motivated because
early users of SCRIBE often asked, "How do I do such-and-so". There is no
particular logic to the sequencing of these examples.
I.1 How to Make a Title Page
Document Types REPORT, MANUAL, and ARTICLE contain a title page facility; you
can also say "@Make(TitlePage)" and produce just the title page.
This input file produced the title page for this manual:
@begin(TitlePage)
@begin(TitleBox)
@MajorHeading(SCRIBE
Introductory
User's
Manual)
@Heading(First Edition)
Brian K. Reid
@value(Date)
@end(TitleBox)
@begin(Heading)
Carnegie-Mellon University
Computer Science Department
@end(Heading)
This manual corresponds to SCRIBE version @value(ScribeVersion).
@CopyrightNotice(Brian K. Reid)
@Begin(ResearchCredit)
The research that produced SCRIBE was funded in part by the
Rome Air Development Center under Contract No. F306-2-75-C-0218,
in part by Army Research Contract No. DAAG29-77-C-0034,
and in part by the Defense Advanced Research Projects Agency
under contract No. F44620-73-C-0074.
@End(ResearchCredit)
@end(TitlePage)
The "TitlePage" environment will be on a page by itself; i.e. a page break
will be taken before it and after it. The "TitleBox" environment is used to
line up text with the box on CMU technical report covers. Anything that you
put inside the environment "TitleBox" will be positioned on the page so that it
will show through the cutout box.
PAGE 66 SCRIBE USERS' MANUAL
The "ResearchCredit" environment puts justified text at the bottom of the
title page. The "CopyrightNotice" environment generates the centered notice,
and positions it in a particular place on the page.
I.2 Equations and Cross References
This example is taken from Volume 1 of The Art of Computer Programming by
Donald E. Knuth. It shows the use of the SCRIBE equation numbering scheme, and
it shows the use of cross-references to equations earlier in the text.
Here is the input file:
Let @i[P(n)] be some statement about the integer @i[n]; for
example, @i[P(n)] might be "@i[n] times (@i[n] + 3) is an even
number," or "if @i[n] ?> 10, then 2@+[@i[n]] > @i[n]@+[3]."
Suppose we want @i[to prove that P(n) is true for all positive
integers n]. An important way to do this is:
@Begin(Enumerate)
Give a proof that @i[P(1)] is true; @Tag(BaseStep)
Give a proof that "if all of @i[P](1), @i[P](2), . . . , @i[P](@i[n])
are true, then @i[P](@i[n]+1) is also true"; this proof should be valid
for any positive integer @i[n]. @Tag(InductStep)
@End(Enumerate)
As an example, consider the following series of equations, which
many people have discovered independently since ancient times:
@equation(
1 = 1@+[2], 1 + 3 = 2@+[2], 1 + 3 + 5 = 3@+[2], 1 + 3 + 5 + 7 = 4@+[2],
1 + 3 + 5 + 7 + 9 = 5@+[2].
)
We can formulate the general property as follows:
@equation{
1 + 3 + . . . + (2@i[n] - 1) = @i[n]@+[2] @Tag(Induction)
}
Let us, for the moment, call this equation @i[P(n)]; we wish to
prove that @i[P(n)] is true for all positive @i[n]. Following
the procedure outlined above, we have:
@Begin(Enumerate)
"@i[P](1) is true since 1 = 1@+[2]."
"If all of @i[P](1), . . . , @i[P](@i[n]) are true, then, in particular,
@i[P](@i[n]) is true, so Eq. @Ref(Induction) holds; adding 2@i[n] + 1
A FEW EXAMPLES PAGE 67
to both sides, we obtain
@begin(equation)
1 + 3 + . . . + (2@i[n] - 1) + (2@i[n] + 1) = @i[n]@+[2] + 2@i[n] + 1 =
(@i[n] + 1)@+[2]
@End(equation)
which proves that @i[P](@i[n] + 1) is also true."
@End(Enumerate)
We can regard this method as an @i[algorithmic proof procedure].
In fact, the following algorithm produces a proof of @i[P](@i[n]) for
any positive integer @i[n], assuming that steps @Ref(BaseStep)
and @Ref(InductStep) above have been worked out.
and here is the output that it produces:
Let P(n) be some statement about the integer n; for example, P(n)
n
might be "n times (n + 3) is an even number," or "if n ?> 10, then 2 >
3
n ." Suppose we want to prove that P(n) is true for all positive
integers n. An important way to do this is:
1. Give a proof that P(1) is true;
2. Give a proof that "if all of P(1), P(2), . . . , P(n) are true,
then P(n+1) is also true"; this proof should be valid for any
positive integer n.
As an example, consider the following series of equations, which many
people have discovered independently since ancient times:
2 2 2 2
1 = 1 , 1 + 3 = 2 , 1 + 3 + 5 = 3 , 1 + 3 + 5 + 7 = 4 ,
2
1 + 3 + 5 + 7 + 9 = 5 .
We can formulate the general property as follows:
2
1 + 3 + . . . + (2n - 1) = n (1)
Let us, for the moment, call this equation P(n); we wish to prove that
P(n) is true for all positive n. Following the procedure outlined
above, we have:
2
1. "P(1) is true since 1 = 1 ."
2. "If all of P(1), . . . , P(n) are true, then, in particular, P(n)
is true, so Eq. 1 holds; adding 2n + 1 to both sides, we obtain
PAGE 68 SCRIBE USERS' MANUAL
2 2
1+3+ ... +(2n-1)+(2n+1)=n +2n+1=(n+1)
which proves that P(n + 1) is also true."
We can regard this method as an algorithmic proof procedure. In fact,
the following algorithm produces a proof of P(n) for any positive
integer n, assuming that steps 1. and 2. above have been worked out.
I.3 Printing on Model Paper
Academic journals frequently request that papers submitted for publication be
typed on "model paper", which they provide. Model paper is usually larger than
the normal 8.5-by-11 inch size, and has various blue lines on it that demarcate
the area in which your paper is supposed to go.
It is usually convenient to proof your document on normal-sized paper, then
convert it to the format required by the journal. There are dozens of
different kinds of model paper in use. Ideally, SCRIBE would have a document
type for each, so you could just say "@Make(NorthHolland)", for example, and
generate model paper for North-Holland journals. In time these document types
will become available; right now they are not.
There are two approaches to the preparation of model paper. You may use the
Diablo, typing directly on the paper, or you may cut and paste. In either
case, you will need to be able to control page size, margins, and line spacing.
1
All of the information that you need to produce model paper is in chapter 9,
but it may not have been obvious to you how to put it all together. Figure
11-1 shows an excerpt of a sample manuscript file used to prepare a document to
be typed directly on the model paper with the Diablo typewriter. To print with
the XGP to cut and paste, you would use a similar approach.
I.4 Business Letters
SCRIBE will format a business letter for you and print it either on the XGP,
simulating stationery, or on the Diablo, typed on real stationery. Your
manuscript file will be in the same format either way. Figure 11-2 shows a
sample manuscript file that will produce a business letter, albeit a whimsical
one. Figure 11-3 shows how that letter would look when printed on the XGP.
---------------
1
If you choose to cut and paste, I recommend Carter's Glue Sticks for the
pasting part.
THE FORMAT OF BIBLIOGRAPHY FILES PAGE 69
@device(Diablo)
@Font(Elite10)
@Style(PaperLength 12inches,Paperwidth 9inches)
@Style(TopMargin 1inch,BottomMargin 1.3inches)
@Style(LeftMargin 1.2inches,RightMargin 1.6Inches)
@Style(Spacing 1,Justification Off)
@Style(Indentation 3)
@enter(Heading)
THE HARPY SPEECH UNDERSTANDING SYSTEM
Bruce Lowerre
Raj Reddy
Carnegie-Mellon University
Pittsburgh, PA 15213
@leave(Heading)
@Heading(ABSTRACT)
HARPY is one of the first systems to demonstrate that high performance,
large vocabulary connected speech recognition systems can in fact be
realized economically for task-oriented (restricted) languages. In
this chapter we present, using simple examples, the principles of
organization of the Harpy system. We will illustrate how knowledge
sources (KSs) are specified, how the knowledge compiler integrates the
KSs
into a unified directional graph representation, and how this knowledge
is utilized. In conclusion, we will discuss many of the limitations of
the present system and how these can be eliminated or reduced in future
systems.
@heading(INTRODUCTION)
Figure 11-1: Sample text for paper typed onto model paper
PAGE 70 SCRIBE USERS' MANUAL
@device(XGP)
@make(Letterhead)
@begin(Address)
Mr. J. Z. Williams
Market Research Analyst
Williams Pharmaceuticals
1234 Main Street
Elkhart, Indiana 42103
@end(Address)
@begin(Body)
Dear Mr. Williams:
Your company's television ads recommend that people take two
Alka-Seltzers at a time. I buy them in bottles of 25.
I find that this leaves me with one extra Alka-Seltzer
at the end of each bottle.
Could you be so kind as to help me decide what to do with
these poor orphaned pills, lest they go to waste?
@end(body)
Sincerely,
Brian Reid
@begin(Notations)
BKR/xgp
@end(Notations)
Figure 11-2: Manuscript file to make a business letter
THE FORMAT OF BIBLIOGRAPHY FILES PAGE 71
PAGE 72 SCRIBE USERS' MANUAL
Figure 11-3: XGP output produced by sample letter file
THE FORMAT OF BIBLIOGRAPHY FILES PAGE 73
II. The Format of Bibliography Files
As we mentioned in chapter 8, a bibliography file is a sequence of
bibliography entries. This appendix describes the details of the format of
these entries.
Each bibliography entry takes the form
@what(identifier, information list)
where "what" is one of BOOK, ARTICLE, THESIS, INBOOK, REPORT, or MISC. The
"information list" is a list of data about the entry, each datum consisting of
a parameter word and a quoted string. Each type of entry needs a different set
of information. For example, an ARTICLE needs a JOURNAL parameter, while a
THESIS needs a SCHOOL parameter. The complete set of parameters is:
AUTHOR The name of the author or authors. Put names in the order
JOURNAL The title of the journal or its standard abbreviation.
ISSUE The number within volume of the journal issue.
VOLUME For journals, the journal volume number. For multi-volume
books, the book volume number.
DATE The publication date.
TITLE The title of the article, paper, book, or thesis being cited.
BOOKTITLE If a chapter of a book is being cited, the book title must also
be given.
EDITOR If a chapter of a book is being cited, the name of the editor
of the book must be given.
PAGE If desired, a page number or numbers may be provided.
SCHOOL The name of the school at which a thesis was submitted.
If an unnecessary parameter is included in an entry, it will be ignored. If
a necessary parameter is omitted from an entry, a warning message will be
issued when the file is processed.
PAGE 74 SCRIBE USERS' MANUAL
Index
@ sign, meaning 4
@! command 36
@# command 20
@* command 40
@+ command 10
@- command 10
@. command 34
@/ command 36
@= command 38
@> command 37
@Appendix command 25
@Appendixsection command 25
@B command 10
@Begin command 10, 11
@BlankPage command 31
@Blankspace command 29
@C command 10
@Caption command 30
@Chapter command 25
@Cite command 45
@CopyrightNotice command 28
@Device command 5, 21, 55
@End command 10, 11
@Enter command 11
@Equate command 52
@file command 55
@Font command 21, 22, 48
1
@Foot command 17
@G command 10, 19
@Heading command 24
@Hinge command 41
@I command 10
@Include command 54
@Index command 18
@Label command 42, 45
@Leave command 11
@MajorHeading command 24
---------------
1
@Foot command 17
INDEX PAGE 75
@Make command 21, 55
@Newpage command 31, 41
@O command 9, 10
@ovp command 35
@P command 10
@PageFooting command 26
@PageHeading command 26
@Pageref command 42
@Paragraph command 25
@Part command 21, 57
@Picture command 30
@Prefacesection command 25
@R command 10
@Ref command 17, 42, 45, 59
@ResearchCredit command 28
@S command 9
@Section command 25
@Set command 53
@String command 59
@Style command 21, 22, 49, 50, 55, 60
@SubHeading command 24
@Subsection command 25
@T command 10
@Tabclear command 34
@TabDivide command 34
@Tabs command 34
@Tag command 16, 17, 43
@Theorem command 17
@TitleBox command 28
@TitlePage command 28
@U command 10, 35
@UN command 10
@UnNumbered command 25
@Use command 61
@UX command 10
@Value command 60
@W command 40
@\ command 35, 38
@| command 40
Alphabetic space 20, 40
Annotation in Bibliography 46
APPENDIX command 25
APPENDIXSECTION command 25
PAGE 76 SCRIBE USERS' MANUAL
Apples 18
ARTICLE document type 21, 65
AUX file 43, 58, 61
B command 10
BEGIN command 10, 11
Bibliographic citations 42
Bibliography 44
Bibliography annotation 46
Bibliography database 45
Bibliography entry parameters 73
Bibliography entry selection 45
Bibliography entry type 45
Bibliography file 45, 61
Blank lines 4, 14
Blank Pages 31
BLANKPAGE command 31
BLANKSPACE command 29
Boldface, how to get 10
BOTTOMMARGIN style parameter 51
Bracketing 8
C command 10
CAPTION command 30
Captions for figures 30
CENTER insert 11, 13
Centering 38
Changing command names 52
CHAPTER command 25
Chapter titles 25
Character fonts 19
Citation 44
CITATION style parameter 47
Citation styles 47
Citations 42, 46
CITE command 45
Clearing tab stops 34
Codewords 42
Column formatting 33, 34
Command names, changing 52
Copyright notice, how to produce 28
COPYRIGHTNOTICE command 28, 66
Counters 53
Cross reference codewords 42
INDEX PAGE 77
Cross reference example 42
Cross references 16, 42, 45
Cross references, errors in 43
Cursor control 35
Database 61
Date, current 60
Day of week 60
Delimiters 8, 11
Delimiters, nesting 8
DESCRIPTION insert 11, 15
DEVICE command 5, 21, 55
Devices 9
Diablo 48
Diablo HyType printer 6
DISPLAY insert 11, 13
Document file 5
Document types 21
Document types, how to define 21
Document types, how to modify 48
Document, definition of 2
Double-spacing 50
END command 11
ENTER command 11
ENUMERATE insert 11, 14
EQUATE command 52
EQUATION insert 11, 16
Equation number references 42
Equation numbers 43
Equations, examples 66
Even/odd page headings 27
EXAMPLE insert 11, 13
Example number references 42
Figure bodies, generating 29
Figure captions, generating 30
Figure numbers 31
Figure pages 31
Figures, full page 31
Figures, how to make 29
FILE command 55
File output 6
Fixed-width fonts 33
PAGE 78 SCRIBE USERS' MANUAL
FLOAT parameter 41
Flush right 37
FONT command 21, 22, 48
Font height measurement 48
Font-change codes 9
Fonts 9, 19, 33, 48
Fonts, how to create 49
FOOT command 17
Footnote numbering 50, 51
Footnote numbers 17
Footnotes 17, 50
Forcing a line break 40
Forcing a page break 41
FORMAT insert 11, 14, 33
Full-page figures 31
Funding acknowledgement 28
G command 10, 19
Greek letters 10, 19
GROUP 41
GROUP parameter 41
HEADING command 24
Headings 14, 24
HINGE command 41
I command 10
Identifier 45
IMMEDIATE parameter to @Pageheading 27
INCLUDE command 54
INDENTATION style parameter 50
INDEX command 18
Indexing 18
Insert, long form 10, 25
Insert, short form 11
Inserts 10, 11
Inserts, long form 41
Inter-line spacing 50
Inter-paragraph spacing 49, 50
Internal strings 60
Italics 8
Italics, how to get 10
ITEMIZE insert 11, 14
INDEX PAGE 79
Joy of Cooking 42
Justification 50
JUSTIFICATION style parameter 50
LABEL command 42, 45
Large letters 24
LEAVE command 11
LEFTMARGIN style parameter 51
LETTER document type 21
Letterhead 68
LETTERHEAD document type 21
Line break, forcing 40
Line breaks 40
Line length 51
Line printer output 5, 6, 9
Line width 51
MAJORHEADING command 24
MAKE command 21, 55
MANUAL document type 21, 25, 65
Manuscript File, definition of 2
Manuscript file, preparation of 4
Manuscript file, processing of 5
Margins, changing 51
Mathematical formatting 35
Month 60
MSS file extension 4
Nested delimiters 8
New page 31
New paragraph 4
NEWPAGE command 31, 41
Numbering pages 26
O command 9, 10
Object references 42, 43
Odd/even page headings 27
Output characters 9
Output devices 6
Output files 5
Overbar 10
Overbar code 9
Overprinting 35
Overstriking 10
PAGE 80 SCRIBE USERS' MANUAL
OVP command 35
P command 10
Page breaks 41
Page Headings 24, 26
Page length 51
Page number references 42
Page number, changing 53
Page numbering 43
Page numbers 26
Page, starting at top of new 31, 41
PAGEFOOTING command 26
PAGEHEADING command 26
PAGEREF command 42
PAPERLENGTH style parameter 51
PAPERWIDTH style parameter 51
PARAGRAPH command 25
Paragraph indentation 49, 50
Paragraphs 4, 14
PART command 21, 57
Peaches 18
PICTURE command 30
POSTER document type 21
PREFACESECTION command 25
Printing devices 5, 6
Quotation 10, 11
QUOTATION insert 11
Quotations 3
R command 10
REF command 17, 42, 45, 59
References 42
REPORT document type 21, 25, 65
RESEARCHCREDIT command 28
RESEARCHCREDIT insert 65
Return marker 36
RIGHTMARGIN style parameter 51
Roman typeface, how to get 10
Root file 55, 57
Running headers 24
Running SCRIBE 4
S command 9
INDEX PAGE 81
Script code 9
SECTION command 25
Section number references 42
Section title 25
Sectioning a document 24
Separate compilation facility 57
SET command 53
Setting tab stops 34
Setup commands 21
Significant space 20, 40
SLIDE document type 21
Small capitals, how to get 10
SPACING style parameter 50
Spread 50
SPREAD style parameter 50
STRING command 59
Strings, text 59
STYLE command 21, 22, 49, 50, 55, 60
SUBHEADING command 24
Subheadings 24
Subscripts, how to get 10
SUBSECTION command 25
Superscripts, how to get 10
T command 10
TAB character (Ctrl I) 35
Tab stops 33, 34, 38
Tabbing 35
TABCLEAR command 34
TABDIVIDE command 34
Table of Contents 25
Tables, how to make 29
Tabs 15, 34, 37
TABS command 34
TAG command 16, 17, 43
TEXT document type 21
Text reference 42
Text references 42
Text strings 59
THEOREM command 17
THEOREM insert 11, 17
Theorem number references 42
Theorem numbers 43
Time, finding 60
PAGE 82 SCRIBE USERS' MANUAL
Times Roman font 48
Title page 24
Title page, example 65
Title page, how to produce 28
TITLEBOX command 28
TITLEPAGE command 28
TITLEPAGE insert 65
TOPMARGIN style parameter 51
Typewheels for Diablo 48
Typewriter font 10
U command 10, 35
UN command 10
Underlining 10, 35
Underlining, how to get 10
UNNUMBERED command 25
USE command 61
UX command 10
VALUE command 60
Variable-width fonts 33
VERBATIM insert 11, 14, 33
VERSE insert 11, 12
W command 40
Wine 18
Word break 40
Word breaks, forcing 40
Word breaks, preventing 40
Xerox Graphics Printer 6
XGP 48
XGP output 6, 9
Year 60
Yogurt 29
TABLE OF CONTENTS PAGE I
Table of Contents
1. Introduction 2
1.1 Some Explanation for Non-Programmers 2
1.2 Some Explanation for Programmers 3
2. Getting Started 4
2.1 Preparing Input for Scribe 4
2.2 Running Scribe 4
2.3 Printing Devices 5
3. Preparing a Manuscript 8
3.1 Delimiters 8
3.2 Printing Device Considerations 9
3.3 Italics, Underlining, Etcetera 9
3.4 Inserts 10
3.4.1 Specifying an Insert 10
3.4.2 Simple Inserts 11
3.4.2.1 QUOTATION and VERSE 12
3.4.2.2 EXAMPLE and DISPLAY 13
3.4.2.3 CENTER 13
3.4.2.4 VERBATIM and FORMAT 14
3.4.2.5 ITEMIZE and ENUMERATE 14
3.4.2.6 DESCRIPTION 15
3.4.2.7 EQUATION 16
3.4.2.8 THEOREM 17
3.5 Footnotes 17
3.6 Indexing 18
3.7 Special Characters 19
3.7.1 Getting SCRIBE to Print Special Characters 19
3.7.2 Faking Special Characters 19
4. Document Types and Styles 21
4.1 SCRIBE's Database of Document Types 21
4.2 Specifying a Document Type: the @Make command 21
4.3 Style Variations 22
5. Titles, Headings, Sections, and the Table of Contents 24
5.1 Headings in a Document Without a Table of Contents 24
PAGE II SCRIBE USERS' MANUAL
5.2 Headings in a Document Having a Table of Contents 25
5.3 Numbering Pages and Page Headings 26
5.4 Title Pages 28
6. Figures and Tables 29
6.1 Generating Figure Bodies 29
6.1.1 The @Blankspace Command 29
6.1.2 The @Picture Command 30
6.2 Generating Figure Captions 30
6.3 Figure Numbers 31
6.4 Full-page figures 31
7. Format Control: Tabs, Columns, and Cursor Movement 33
7.1 VERBATIM 33
7.2 Tabs and Tabs Stops 34
7.2.1 Setting Tab Stops 34
7.2.2 Tabbing to a Tab Stop 35
7.3 Fancy Cursor Control 35
7.3.1 Overprinting 35
7.3.2 The Return Marker 36
7.3.3 Centering, Flush Left, and Flush Right 37
7.4 Controlling Word, Line, and Page Breaks 39
7.4.1 Controlling Word and Line Breaks 40
7.4.2 Controlling Page Breaks 41
8. Cross Reference, Bibliography, and Citation 42
8.1 Cross References 42
8.1.1 Text References: the @LABEL Command 42
8.1.2 Object References: the @TAG Command 43
8.2 Bibliography and Citation 44
8.2.1 Bibliography Files 45
8.2.2 Citations 46
8.2.3 Alternate Citation Styles 47
9. Changing Things 48
9.1 Changing Type Font: The @Font Command 48
9.2 A List of Available Fonts 48
9.3 The @Style Command 49
9.4 A List of STYLE Parameters 50
9.5 Miscellany 52
TABLE OF CONTENTS PAGE III
9.5.1 Changing Command Names 52
9.5.2 Changing Counter Values 53
10. Producing Large Documents 54
10.1 Breaking a Manuscript into Several Smaller Files 54
10.2 Separate Processing of Component Files 56
10.2.1 Component Files As Separate Documents 57
10.2.2 Separate Processing of Component Parts 57
10.3 Defining and Using Text Strings 59
10.3.1 The @String Command 59
10.4 Environment Inquiry: Predefined Strings 59
10.4.1 Internal Strings and the @Value Command 60
10.4.2 Current Values of Counters 61
10.5 File Names and the @Use Command 61
11. Epilogue and Sermon 63
I. A Few Examples 65
I.1 How to Make a Title Page 65
I.2 Equations and Cross References 66
I.3 Printing on Model Paper 68
I.4 Business Letters 68
II. The Format of Bibliography Files 73
Index 74