Trailing-Edge
-
PDP-10 Archives
-
decus_20tap2_198111
-
decus/20-0028/snobol.mem
There is 1 other file named snobol.mem in the archive. Click here to see a list.
PDP-10 SNOBOL4 USER'S GUIDE
Author: L. P. Wade
Date: October 17, 1970
Version: %004
PREFACE
This manual is intended to serve as an introduction to
SNOBOL4 on the PDP-10. The material presented here
describes all the unique aspects of the PDP-10 version and
includes the introductory chapters of the reference manual
(Griswold, Poage Polonsky, THE SNOBOL4 PROGRAMMING LANGUAGE
Copyright 1968. Reprinted by permission of Prentice-Hall,
Inc., Englewood Cliffs, N. J.) for those unfamiliar with
the language.
This manual describes version 3.4 on the PDP-10.
Copyright 1970, Digital Equipment Corporation Maynard,
Mass., 01754.
PDP-10 Snobol4 User's Guide Page 2
TABLE OF CONTENTS
----- TABLE OF CONTENTS -----
1. INTRODUCTION
2. PDP-10 DIFFERENCES AND FEATURES
A. Character Set
B. Input/Output
C. Omissions
D. Changes
E. Additions
Notes for the Novice
3. INTRODUCTION TO THE SNOBOL4 PROGRAMMING LANGUAGE
A. Assignment Statements
and Basic Data Types
B. Pattern Matching Statements
C. Replacement Statements
D. Patterns
E. Conditional Value Assignment
F. Flow of Control
G. Indirect Reference
H. Functions
I. Keywords
J. Arrays
K. Programmer-defined Data Types
L. Program Example
M. Tables
4. INPUT AND OUTPUT
A. Printed Output
PDP-10 Snobol4 User's Guide Page 3
TABLE OF CONTENTS
B. Punched Output
C. Input
D. The I/O System
E. Output Associations
F. Input Associations
G. Other I/O Functions
5. STRUCTURE OF A SNOBOL4 RUN
A. Compilation
B. Execution
C. Termination
APPENDIX A - SYSTEM PROGRAMMER'S NOTES
APPENDIX B - DEVICE NUMBER ASSIGNMENTS
PDP-10 Snobol4 User's Guide Page 4
CHAPTER 1
INTRODUCTION
The PDP-10 version of SNOBOL4 is almost wholly
compatible with the Bell Telephone Laboratories version
running on other systems. Minor changes were required
because of slightly different character sets and operating
systems. In addition several modifications were made to
take advantage of the PDP-10 time sharing features. These
unique characteristics are itemized later in this chapter.
BACKGROUND
SNOBOL stands for StriNg-Oriented symBOlic Language (1)
and was developed at Bell Telephone Laboratories,
Incorporated, in 1962 by D. J. Farber, R. E. Griswold and
I. P. Polonsky. SNOBOL4 is the latest in the series and
contains features not commonly found in other programming
languages. As such it is a useful tool in such areas as
compilation techniques, machine simulation, symbolic
mathematics, text preparation, natural language translation,
linguistics, and music analysis.
The basic element of SNOBOL4 is a string of characters.
The language has facilities for joining and separating
strings, for testing their contents, and for making
replacements in them. If the string is a paragraph, it can
be broken into sentences, phrases or words. A common
operation on a string is examination of its contents for a
desired structure of characters. This structure is known as
a pattern and can be as simple as a string or can be
extremely complicated. The basic facility of SNOBOL is the
use of the pattern in a pattern matching statement.
SNOBOL4 provides numerical capabilities with both real
and integer numbers. However, the arithmetical facilities
are not extensive since the language is essentially
character oriented. Also a number of built-in functions,
called primitive functions, are available which are a
standard part of the language. As examples, the function
LGT (for lexical comparison) will test two strings to
determine whether the first is alphabetically greater than
the second, and the function REPLACE will replace all
characters in one set which appear in a given string with
corresponding members of another set.
------------------------------------------------------
(1) Farber was once overheard to say that this name was
largely contrived when the original JACM article was
published. The name was apparently picked when one of the
original implementors made a statment such as, "This program
doesn't have a snowball's chance in hell of ...".
PDP-10 Snobol4 User's Guide Page 5
CHAPTER 1
Execution of SNOBOL4 programs in interpretive. The
system compiles a program into a notation the interpreter
can easily execute. This approach makes it fairly simple to
provide capabilities such as tracing of new values for
variables, an operation that is otherwise quite difficult.
Another important product of interpretation is flexibility.
Functions can be defined and redefined during program
execution. Function calls can be made recursively with no
special program notation. Consult "THE SNOBOL4 PROGRAMMING
LANGUAGE, for a complete description.
USER'S GUIDE
SNOBOL4 on the PDP-10 corresponds to the latest copy
released by Bell Telephone Laboratories. This is currently
version 3.4.
The program takes up a good deal of core. Small
programs will require 35K to run and serious SNOBOL
programming will likely require 45K to 50K of user core.
The high segment requires about 16K and the low segment will
initially take 17K and expand as more core is needed.
The following remarks assume operation on a 10/50
system. If using a 10/40 system, refer to the System
Programmer's Notes in Appendix A for additional details.
In general, source programs will be prepared with one
of the system editors and saved with an extension of "SNO".
Alternatively the source program can be typed in directly,
but this method should be discouraged since a copy of the
program is not saved.
After getting SNOBOL into core by typing
R SNOBOL<CR>
it will type an asterisk indicating the user is expected to
give it input. At this time the user should specify the
standard input and output device files, as described below
GENERAL FORMAT
LISTING-DEVICE:FILENAME.EXT_SOURCE-DEVICE:FILENAME.EXT(S)
LISTING-DEVICE
The device on which the output produced by SNOBOL is to be
written. If a device is not specified DSK is assumed.
MTAn: Magnetic Tape
DTAn: DEC Tape
DSK: Disk
PDP-10 Snobol4 User's Guide Page 6
CHAPTER 1
PTP: Paper Tape Punch
LPT: Line Printer
TTY: Teletype
SOURCE-DEVICE
The device from which the source program input to
compilation is to be read. If a device is not specified,
"DSK" is assumed.
MTAn: Magnetic Tape
DTAn: DEC Tape
TTY: Teletype
CDR: Card Reader
PTR: Paper Tape Reader
FILENAME.EXT (DSK: AND DTAn: only)
The filename and filename
extension of the listing file
and the source file.
If .EXT is omitted,
.LST is assumed for the
listing file and
.SNO is assumed for
the source file.
The listing device
is separated from the
source device by a left
arrow.
Note that a shorthand form is possible where only the
name of the input file needs to be specified. For example
the user would type
SNOPRG<CARRIAGE RETURN>
This would result in the source program SNOPRG.SNO to
be compiled and the output to be written on the file named
SNOPRG.LST.
The output file can be listed either with PIP or the
LIST command, or can be examined with an editor to look for
the desired results.
While specifying the standard IO devices the user can
specify several switches as described below.
PDP-10 Snobol4 User's Guide Page 7
CHAPTER 1
/D - Set the SNOBOL keyword DUMP in order to cause a
dump of variable storage at program termination.
/I - Increase the size of the reserved IO buffer space
for each occurrence of this switch. For each input/output
association which your program has which is not on device
numbers 5 or 6, you must use this switch to reserve IO
buffer space. Initially, enough buffer space for a total of
six separate files is reserved (including the standard INPUT
and OUTPUT files).
/U - Equivalent to -UNLIST to suppress printout of the
source program listing.
Later versions of the CCL program released by DEC will
likely have an interface to SNOBOL. If this version is on
the system the source program can be executed with the
EXECUTE command. for example, you would type
.EXECUTE SNOPRG<CARRIAGE RETURN>
The "EG" command of TECO could also be used to expedite the
debugging process.
PDP-10 Snobol4 User's Guide Page 8
CHAPTER 2
PDP-10 DIFFERENCES AND FEATURES
A. CHARACTER SET
1. The alternation symbol is the exclamation mark
(!) instead of the vertical bar.
2. The negation symbol is the back slash (\).
3. The underline symbol is not defined.
4. Of the control characters, TAB, FORM-FEED and
VERTICAL TAB are syntactically equivalent to BLANK.
5. Since the exclamation mark has been used for the
alternation symbol, it cannot be used for exponentiation.
6. Since the vertical bar is undefined, it cannot
be used to indicate a comment line. Additional comment
characters include the exclamation mark and semicolon.
7. Both upper and lower case letters are allowed.
B. INPUT/OUTPUT
1. The devices and files associated with the
standard input and output reference numbers are selected by
the user at run time. This mechanism is a substitute for
the JCL procedure on the IBM/360.
2. The IO device reference numbers available to the
programmer are listed in Appendix B.
3. The standard FORMAT statement for OUTPUT
associations should include the A5 conversion rather than
the typical A1 conversion with IBM installations.
C. OMISSIONS
1. Variables are not alphabetized on a DUMP
request.
2. The EXTERNAL FUNCTION feature is not
implemented.
D. CHANGES
PDP-10 Snobol4 User's Guide Page 9
CHAPTER 2
1. LIST LEFT has been made the default in order to
make it more practical to use a TTY (it reduces the amount
of typeout).
E. ADDITIONS
1. The IFILE primitive function has been defined to
allow the user to select the disk filename for input files
at execution time.
2. The OFILE primitive function has been defined to
allow the user to select the disk filename for output files
at execution time.
3. The MSTIME primitive function has been defined
to return the elapsed time in milliseconds since midnight.
This is in contrast to the TIME function which returns only
the runtime.
4. An INPUT association to device reference number
99 is an interface to the PDP-10 TTCALL facility. Each time
such an association is made, one character will be input
from the user's terminal (including perhaps control
characters).
5. An OUTPUT association to device reference number
99 is interfaced to the PDP-10 TTCALL facility. Each time
such an association is made, the referenced string will be
output. No free CARRIAGE-RETURN/LINE-FEED will be added.
6. The ASCII primitive function has been defined to
allow referencing nonprinting and control characters.
7. The "D" switch is equivalent to &DUMP = 1 and
causes a dump of variable storage at program termination.
8. The "U" switch is equivalent to -UNLIST and
suppresses all compiler output up to the "ERRORS DETECTED"
message.
9. Dynamic core expansion has been added to reduce
the amount of start-up core required. As more core for free
storage is needed, it is retrieved. The program shrinks
back to its original size upon termination. A message has
been added to the statistics printout to indicate to the
user how much core his program used.
10. The program has been made reentrant, to make
multiprogramming of SNOBOL practical.
NOTES FOR THE NOVICE
PDP-10 Snobol4 User's Guide Page 10
CHAPTER 2
These notes may help you avoid some of the common pitfalls
usually made by new SNOBOL programmers.
1. Always remember that the "BLANK" is syntactically
significant in SNOBOL and it must be present in a number of
key places. For example,
A. Blanks must be on both sides of an "=" sign in
an assignment statement.
B. Blanks must be on both sides of binary
operators, I.E. I = I + 1.
In addition, blanks must not be inserted in random
places. For example, if in the label
END.OF.FILE
one of the dots was missing and a BLANK inserted instead,
error termination will likely result in a "TRANSFER TO
UNDEFINED LABEL" message or cause incorrect results. Blanks
must also not be inserted between a function name and the
left parenthesis.
2. Remember that strings are always initialized to the
NULL string. Consequently, misspelled key variables can
cause confusing results. For example, if the word OUTPUT
was spelled as OUTPVT then the statement
OUTPVT = 'DATE IS ' DATE()
will assign the correct result but no output will occur.
3. It is good practice to always set the DUMP keyword
in order to provide the maximum amount of information.
4. It is good practice to always set the TRIM keyword
to work with trimmed strings, especially until you see a
need to leave trailing blanks on.
5. When making OUTPUT associations, you should use the
following FORMAT
OUTPUT('TYPE',5,'(1X,16A5)')
The A5 format is the only practical "A" FORMAT on the
PDP-10. In particular A1 formats will give you every fifth
character.
6. Access to disk files is possible through the IFILE
and OFILE primitive functions (described elsewhere)..break
PDP-10 Snobol4 User's Guide Page 11
CHAPTER 3
INTRODUCTION TO THE SNOBOL4 PROGRAMMING LANGUAGE
This chapter is an introductory overview of the
SNOBOL4 programming language. It describes the format of
statements, some of the operations, and some of the types of
data handled by the language. The reference manual
describes in more detail the material in this introductory
chapter.
A SNOBOL4 program consists of a sequence of
statements. There are four basic types of statements:
1) THE ASSIGNMENT STATEMENT,
2) THE PATTERN MATCHING STATEMENT,
3) THE REPLACEMENT STATEMENT, AND
4) THE END STATEMENT.
THE END statement terminates the program.
A. ASSIGNMENT STATEMENTS AND BASIC DATA TYPES
The simplest type of statement is the assignment statement.
It has the form
VARIABLE = VALUE
The assignment statement may be said to have the following
meaning: "LET VARIABLE HAVE THE GIVEN VALUE." For example,
let V have the value 5, or
V = 5
The value may be given by a expression, consisting, for
example, of arithmetic operations as in the statement
W = 14 + (16 - 10)
which assigns the value 20 to the variable W. Blanks are
required around arithmetic operators such as + and - . The
value need not be an integer, which is just one type of data
handled by SNOBOL4. For example, the value may be a string
of characters, indicated by enclosing quotes. An example is
the assignment statement
V = 'DOG'
which assigns the string DOG to the variable V. Various
types of data and operations that may be performed on them
are described later.
Typically a variable is a name such as V, X, or ANS.
Variables appearing explicitly in a program must begin with
PDP-10 Snobol4 User's Guide Page 12
CHAPTER 3
a letter which may be followed by any number of letters,
digits and periods.
The value of a variable may be used in an assignment
statement. Thus
RESULT = ANS.1
assigns to the variable RESULT the value of ANS.1.
(Quotation marks distinguish literal strings from
variables.)
Blanks are required to separate the parts of a statement.
In an assignment statement, the equal sign must be separated
from the variable on the left and the value on the right by
at least one blank.
A statement which is longer than one line can be continued
onto successive lines by starting the coninuation lines with
a period or plus sign. An example is
N = (3 + M) (2 + SUM) -
. (F - 2)
When continuing a statement over a line boundary, the
statement may be broken wherever a blank is required.
Several statements may be placed on one line by using
semicolons which indicate the ends of statements. An
example is
X = 2; Y = 3; Z = 10
A line beginning with an asterisk is treated as a comment
and does not affect the operation of the program.
1. INTEGERS
The arithmetic operations of addition, subtraction,
multiplication, division, and exponentiation of integers may
be used in expressions. The statements
N = 5; M = 4
P = N * M / (N - 1)
assign the value 5 to P. While blanks are required between
the binary operators and their operands, unary operators
such as the minus sign must be adjacent to their operands.
An example is the statement
Q2 = -P / -N
which assigns the value 1 to Q2 .
PDP-10 Snobol4 User's Guide Page 13
CHAPTER 3
Arithmetic expressions can be arbitrarily complex. When
evaluating arithmetic expressions, the natural order of
operator precedence applies. The unary operations are
performed first, then exponentiation (**), then
multiplication, followed by division, and finally addition
and subtraction. All operations associate to the left
except exponentiation. Hence,
X = 2 ** 3 ** 2
is equivalent to
X = 2 ** (3 ** 2)
Parentheses may be used to emphasize or alter the order of
evaluation of an expression.
In the above examples all the operands are integers and the
results are integers. The quotient of two integers is also
an integer. The remainder is discarded. Thus
Q1 = 5 / 2
Q2 = 5 / -2
give Q1 and Q2 the values 2 and -2, respectively.
Similarly,
MOD = N - (N / M) * M
gives MOD the value N modulo M if N and M are positive
integers.
2. REAL NUMBERS
Arithmetic expressions involving real operands are also
permitted in assignment statements. The statements
PI = 3.14159
CIRCUM = 2. * PI * 5.
assign real values to PI and CIRCUM.
Exponentiation can be performed on real operands. In
addition integer and real numbers can be mixed freely to
permit mixed-mode arithmetic.
3. STRINGS
Expressions involving operands that are character strings
are also permitted in assignment statements. For example,
the assignment statement
SCREAM = 'HELP'
PDP-10 Snobol4 User's Guide Page 14
CHAPTER 3
assigns the string HELP as the value of SCREAM .
The string is specified by enclosing it within a pair of
quotation marks. Any character may appear in a string. A
pair of double quotation marks can be used instead of single
quotation marks. This permits the use of quotation marks
within a string as in the statements
PLEA = 'HE SHOUTED, "HELP."'
QUOTE = '"'
APOSTROPHE = "'"
THE NULL STRING
The NULL string, which is a string of length zero, is
frequently used in SNOBOL4. With a few exceptions,
explained later, all variables have the NULL string as their
initial value. A variable can also be assigned the NULL
string by a statement like
NULL = ''
or, more briefly,
NULL =
The variable NULL is used in many examples that follow to
represent the NULL string.
The NULL string is different from the following strings,
each of which has length one:
'0'
" "
STRINGS IN ARITHMETIC EXPRESSIONS
Numeral strings can be used in arithmetic expressions with
integers. For example, as a result of the statements
Z = '10'
Z = "10"
X = 5 * -Z + '10'
X has the value -40. Numeral strings contain only digits
and a decimal point and perhaps a preceding sign. Thus, the
following strings can be used in arithmetic expressions:
'-3.50'
'3.257'
The following strings cannot be used in arithmetic
PDP-10 Snobol4 User's Guide Page 15
CHAPTER 3
expressions:
'1,253,465'
'.364 E-03'
They cause execution of the program to terminate with the
comment "ILLEGAL DATA TYPE."
Strings can be used in expressions involving real numbers.
The NULL string is equivalent to the integer zero in
arithmetic expressions.
STRING-VALUED EXPRESSIONS
Concatenation is the basic operation for combining two
strings to form a third. The following statements
illustrate the format of an expression involving
concatenation.
TYPE = 'SEMI'
OBJECT = TYPE 'GROUP'
The resulting value of OBJECT is the string SEMIGROUP .
Notice there is no explicit operator for concatenation.
Concatenation is indicated by specifying two string valued
operands separated by at least one blank.
FIRST = 'WINTER'
LT SECOND = 'SPRING'
TWO.SEASONS = FIRST ',' SECOND
are equivalent to
TWO.SEASONS = 'WINTER,SPRING'
Strings can also be concatenated with integers as in
ROW = 'K'
NO. = 22
SEAT = ROW NO.
which gives SEAT the value K22 .
In an expression involving concatenation and integer
arithmetic, concatenation has the lowest precedence. Thus
SEAT = ROW NO. + 4 / 2
is equivalent to
SEAT = ROW (NO. + 4 / 2))
PDP-10 Snobol4 User's Guide Page 16
CHAPTER 3
or
SEAT = 'K24'
INPUT AND OUTPUT OF STRINGS
Three variables provide means for reading and writing data.
The variables OUTPUT and PUNCH are for printing and
punching. Whenever either of them is assigned a string or
integer value, a copy of the value is put out.
OUTPUT = 'THE RESULTS ARE:'
assigns THE RESULTS ARE: to OUTPUT and also prints it.
PUNCH = OUTPUT
causes the same line to be punched on the card punch. The
statements
OUTPUT =
PUNCH =
cause a blank line to be printed and a blank card to be
punched.
The variable INPUT is used for reading in strings. Each
time the value of INPUT is required in a statement, another
card is read in and the 80 character string on it is
assigned as the value of INPUT. Thus
PUNCH = INPUT
produces a copy of the input card on the card punch.
B. PATTERN MATCHING STATEMENTS
The operation of examining substrings for the occurrence of
specified substrings (i.e. pattern matching) is fundamental
to the SNOBOL4 language. Pattern matching can be specified
in two types of statements:
1) THE PATTERN MATCHING STATEMENT, AND
2) THE REPLACEMENT STATEMENT.
The pattern matching statement has the form
SUBJECT PATTERN
where the two fields are separated by at least one blank.
PDP-10 Snobol4 User's Guide Page 17
CHAPTER 3
The subject specifies a string that is to be examined, and
the pattern can be thought of as specifying a set of
strings. The statement causes the subject string to be
scanned from the left for the occurrence of a string
specified by the pattern.
If
TRADE = 'PROGRAMMER'
the statement
TRADE 'GRAM'
examines the value of TRADE for an occurrence of GRAM . If
PART = 'GRAM'
then an equivalent statement is
TRADE PART
The following example illustrates a pattern matching
statement in which the pattern is a string valued
expression.
ROW = 'K'
NO. = 20
'K24' ROW NO. + 4
The subject is a literal and the value of the expression is
the string K24 .
Notice that there is no explicit pattern matching operator
between the subject and the pattern. The two fields are
separated by blanks.
If it is necessary to have concatenation in the subject, the
expression must be enclosed within parentheses to avoid
ambiguity. An example is
TENS = 2
UNITS = 5
(TENS UNITS) 30
On the other hand, a pattern formed by concatenation does
not need parentheses. The following statements are
equivalent:
TENS UNITS 30
TENS (UNITS 30)
C. REPLACEMENT STATEMENTS
PDP-10 Snobol4 User's Guide Page 18
CHAPTER 3
A replacement statement has the form
SUBJECT PATTERN = OBJECT
where the fields are separated by at least one blank. If
the pattern matching operation succeds, the subject string
is modified by replacing the matched substring by the
object. For example, if
WORD = 'GIRD'
then the replacement statement
WORD 'I' = 'OU'
causes the subject string GIRD to be scanned for the string
I and then, since the pattern matches, I is replaced by OU .
Hence word has as value the string GOURD . If the statement
is
WORD 'AB' = 'OU'
the value of WORD does not change because the pattern fails
to match.
Another example of the use of replacement statements is
given in the following sequence of statements
HAND = 'AC4DAHKDKS'
RANK = 4
SUIT = 'D'
HAND RANK SUIT = 'A5'
which replaces the substring 4D with the string A5 .
A matched substring is deleted from the subject string if
the object in the replacement statement is the NULL string.
Thus
HAND RANK SUIT =
deletes 4D from hand leaving it with the string ACAHKDKS as
value.
D. PATTERNS
The patterns in the preceding examples specify single
strings. It is also possible to specify more complex
patterns. There are two operations available for
constructing such patterns:
1) Alternation, and
2) Concatenation.
PDP-10 Snobol4 User's Guide Page 19
CHAPTER 3
Alternation is indicated by an expression of the form
P1 ! P2
where the two patterns P1 and P2 are separated from the !
by blanks. The value of the expression is a pattern
structure that matches any string specified by either P1 or
P2. For example, the statement
KEYWORD = 'COMPUTER' ! 'PROGRAM'
assigns to KEYWORD a pattern structure that matches either
of these two strings.
Subsequently, KEYWORD may be used wherever patterns are
permitted. for example,
KEYWORD = KEYWORD ! 'ALGORITHM'
gives KEYWORD a new pattern value equivalent to the value
assigned by executing the statement
KEYWORD = 'COMPUTER' ! 'PROGRAM' ! 'ALGORITHM'
Similarly,
TEXT KEYWORD =
examines the value of TEXT from the left and deletes the
first occurrence of one of the alternative strings. If
TEXT = 'PROGRAMMING ALGORITHMS FOR COMPUTERS'
the result of the replacement statement is as if the
following statement were executed:
TEXT = 'MING ALGORITHMS FOR COMPUTERS'
Concatenation of two patterns, P1 and P2, is specified in
the same way as the concatenation of two strings:
P1 P2
that is, the two patterns are separated by blanks. The
value of the expression is a pattern that matches a string
consisting of two substrings, the first matched by P1, the
second matched by P2. For example, if
BASE = 'BINARY' ! 'DECIMAL' ! 'HEX'
SCALE = 'FIXED' ! 'FLOAT'
ATTRIBUTE = SCALE BASE
and
PDP-10 Snobol4 User's Guide Page 20
CHAPTER 3
DCL = 'AREAFIXEDDECIMAL'
then the pattern match succeeds in the statement
DCL ATTRIBUTE
Concatenation has higher precedence than alternation. Thus
ATTRIBUTE = 'FIXED' ! 'FLOAT' 'DECIMAL'
matches FIXED of FLOATDECIMAL. The order of evaluation may
be altered by using parentheses.
ATTRIBUTE = ('FIXED' ! 'FLOAT') 'DECIMAL' .break
matches either FIXEDDECIMAL or FLOATDECIMAL.
E. CONDITIONAL VALUE ASSIGNMENT
It is possible to associate a variable with a component of a
pattern such that if the pattern matches, the variable is
assigned the substring matched by the component. The
operator . is the conditional value assignment operator and
it is used in an expression of the form
PATTERN . VARIABLE
where the operator is separated from its operands by blanks.
For example
BASE = ('HEX' ! 'DEC') . B1
assigns to BASE a pattern that matches either HEX or DEC.
If BASE is used successfully in a pattern match, the value
of B1 is set to the substring matched by BASE . The
operator . has the highest precedence of all the operators
and associates to the left. Thus
A.OR.B = A ! B . OUTPUT
is equivalent to
A.OR.B = A ! (B . OUTPUT)
which assigns to A.OR.B a pattern that matches the value of
A or B . If B matches, the substring matched is printed.
There is also an operator $ for immediate value assignment
which assigns value to a variable if the associated
component of the pattern matches regardless of whether the
entire pattern matches. Immediate value assignment is
discussed in more detail in the reference manual.
PDP-10 Snobol4 User's Guide Page 21
CHAPTER 3
F. FLOW OF CONTROL
A SNOBOL4 program is a sequence of statements terminated by
an END statement. Statements are executed sequentially
unless otherwise specified in the program. Labels and gotos
are provided to control the flow of the program.
A statement may begin with a label, permitting transfer to
the statement. For example, the assignment statement
START TEXT = INPUT
has the label START. A label consists of a letter or a
digit followed by any number of other characters up to a
blank. Blanks separate the label from the subject. A
statement with no label must begin with at least one blank.
The END statement is distinguished by the label END,
indicating the end of the program.
Transfer to a labelled statement is specified in the goto
field which may appear at the end of a statement and is
separated from the rest of the statement by a colon. Two
types of transfers can be specified in the goto field:
conditional and unconditional.
A conditional transfer consists of a label enclosed within
parentheses and preceded by an F or S corresponding to
failure or sucess goto. An example is the statement
TEXT = INPUT :F(DONE)
This statement causes a record to be read in and assigned as
the value of TEXT. If, however, there is no data in the
input file, i.e. an end of file is encountered, no new
value is assigned to TEXT. Then, because of the failure to
read, transfer is made to the statement labelled DONE.
A use of the success goto is illustrated in the following
program which punches a copy of the input file.
LOOP PUNCH = INPUT :S(LOOP)
END
The first statement is repeatedly executed until the end of
file is encountered and then the program flows into the END
statement which causes the program to terminate.
The success or failure of a pattern match can also be used
to control the flow of a program by conditional gotos. For
example
COLOR = 'RED' ! 'GREEN' ! 'BLUE'
BRIGHT TEXT COLOR = :S(BRIGHT)F(BLAND)
PDP-10 Snobol4 User's Guide Page 22
CHAPTER 3
BLAND
All occurrences of the strings RED, GREEN amd BLUE are
deleted from the value of TEXT before the pattern fails to
match. Control then passes to the statement labelled BLAND.
Both success and failure gotos can be specified in one goto
field, and may appear in either order.
For an example of an unconditional transfer, consider the
following program that punches and lists a deck of cards.
LOOP PUNCH = INPUT :F(END)
OUTPUT = PUNCH :(LOOP)
END
The goto field in the second statement specifies an
unconditional transfer.
G. INDIRECT REFERENCE
Indirect referencing is indicated by the unary operator $ .
For example, if
MONTH = 'APRIL'
then $MONTH is equivalent to APRIL . That is, the statement
$MONTH = 'CRUEL'
is equivalent to
APRIL = 'CRUEL'
The indirect reference operator can also be applied to a
parenthesized expression as in the statements
WORD = "RUN"
$(WORD ':') = $(WORD ':') + 1
which increment the value of RUN: .
In general, the unary operator $ generates a variable that
is the value of its operand. The expression
$("A" ! "B")
causes the program to terminate with the message "ILLEGAL
DATA TYPE" because the value of the operand of $ is a
pattern, not a string. Indirect reference in a goto is
demonstrated by
N = N + 1 :($("PHASE" N))
PDP-10 Snobol4 User's Guide Page 23
CHAPTER 3
If, for example, the assignment statement sets N equal to 5,
then the transfer is to the statement labelled PHASE5.
H. FUNCTIONS
Many SNOBOL4 procedures are invoked by functions built into
the system called primitive functions. Operations that
occur frequently are implemented as primitive functions for
efficiency. Other primitive functions are used to invoke
more complex operations that are fundamental to the
language, affect parameters and tables internal to the
system, and perform operations that could not be programmed
in source language by other means. In addition, facilities
are available for a programmer to define his own source
language functions.
1. PRIMITIVE FUNCTIONS
Consider the function SIZE, which has a single string
argument and returns as value an integer which is the length
(number of characters) of the string. The statements
APE = 'SIMIAN'
OUTPUT = SIZE(APE)
print the number 6 .
Arguments to all functions are passed by value, and an
arbitrarily complex exprssion may be used in the argument.
Thus the statements
N = 100
OUTPUT = SIZE('PART' N + 4)
print the number 7 , because the value of the argument is
the string PART104 .
The argument of SIZE is supposed to be a string. Therefore,
a call of the form
SIZE("APE" ! "MONKEY")
causes the program to terminate with the diagnostic message
"ILLEGAL DATA TYPE" because the value of the argument is a
pattern.
TRIM is another function that performs an operation
frequently required. TRIM(STRING) returns as value a string
which is equal to the argument with trailing blanks removed.
It is often used in a statement of the form
READ TEXT = TRIM(INPUT) :F(END)
PDP-10 Snobol4 User's Guide Page 24
CHAPTER 3
which assigns as value to TEXT the string on the next input
card, trimmed of trailing blanks. Notice that the use of
the variable INPUT in the argument causes a card to be read.
REPLACE is a function called with three string
valued arguments.
REPLACE(TEXT,CH1,CH2)
returns as value a string which is equal to TEXT with each
occurrence of a character appearing in CH1 replaced by the
corresponding character in CH2. For example the statements
STATEMENT = 'A(I,J) = A(I,J) + 3'
OUTPUT = REPLACE(STATEMENT,'()','<>')
print the line
A<I,J> = A<I,J> + 3
If the last two arguments of the function call do not have
the same length, the function fails. Function failure, like
INPUT failure, can be used in a conditional transfer.
Another example of the use of REPLACE is the following
program that produces a simple cryptographic encoding of an
input deck.
INALPH = 'ABCDEFGHIJLMNOPQRSTUVWXYZ'
OUTALPH = 'KLMNOPQRSTUVWXYZABCDEFGHIJ'
LOOP PUNCH =
REPLACE(INPUT,INALPH,OUTALPH) :S(LOOP)
END
The iteration is terminated by INPUT failure.
There are also several functions that return patterns as
their values. LEN is such a function. LEN(INTEGER) returns
a pattern that that matches any string of the length
specified by the integer.
The following example punches the value of STR centered on a
card.
BLANKS = '
'
BLANKS LEN((80 - SIZE(STR)) / 2) . PAD
PUNCH = PAD STR
If the size of STR is greater than 80, the argument of LEN
is negative, causing error termination with the message
"NEGATIVE NUMBER IN ILLEGAL CONTEXT."
DUPL(S,N duplicates a string S. The number of duplications
is determined by N. The value of
PDP-10 Snobol4 User's Guide Page 25
CHAPTER 3
DUPL('.*',5)
is '.*.*.*.*.*' . If S is the NULL string or N is zero,
DUPL returns the NULL string as value. DUPL fails if N is
negative.
DUMP(N) prints a dump of variable storage at the time DUMP
is called if N is nonzero. The dump is similar to the dump
provided after program termination, except that the
variables are not alphabetized. DUMP returns the NULL
string as value. No dump is given if N is zero.
The value of REMDR(N,M) is the remainder of the
integer division N / M. The sign of the remainder is the
same as the sign of the dividend. Thus the value of
REMDR(-5,2)
is -1, and the value of
REMDR(5,-2)
is 1.
2. PREDICATES
A predicate is a function or operation that returns the NULL
string as value if a given condition is satisfied.
Otherwise it fails.
LE is an example of a predicate used for comparing integers.
LE(N1,N2)
returns the NULL string as value if N1 is an integer less
than or equal to N2. Thus
PUNCH = LE(SIZE(TEXT),80) TEXT
punches the string TEXT if its length is not greater than
80. The NULL string value of the predicate does not affect
the string that is punched. If the predicate fails, no
assignment is made to PUNCH, and no card is punched. The
success of failure of a predicate can be used with a
conditional goto to control the flow of a program. For
example,
N = 0; SUM = 0
ADD N = LT(N,50) N + 1 :F(DONE)
SUM = SUM + N :(ADD)
DONE OUTPUT = SUM
sums the first 50 integers. Iteration continues as long as
N is less than 50. When the predicate fails, the
PDP-10 Snobol4 User's Guide Page 26
CHAPTER 3
conditional transfer to DONE is performed and the string
1275 is printed. There are several predicates for comparing
strings. For example,
DIFFER(ST1,ST2)
returns the NULL string as value if the values of two
arguments are not identical. Thus
OUPUT = DIFFER(FIRST,SECOND) FIRST SECOND
concatenates the values of FIRST and SECOND if they are not
the same, and then prints them.
For all functions, an omitted argument is assumed to be the
NULL string. Thus
PUNCH = DIFFER(TEXT) TEXT
punches the value of TEXT if it is not the NULL string.
LGT is a predicate that lexically compares two strings.
LGT(ST1,ST2)
succeeds if ST1 follows (is lexically greater than) ST2 in
alphabetical order. the statements
OUTPUT = LGT(TEXT1,TEXT2) TEXT2 :S(SKIP)
OUTPUT = TEXT1
OUTPUT = TEXT2 :(JUMP)
SKIP OUTPUT = TEXT1
JUMP
print the values of TEXT1 and TEXT2 in alphabetical order.
3. DEFINED FUNCTIONS
The SNOBOL4 language provides the programmer with the
capability to define functions in the source language. This
feature facilitates the organization of a program and may
improve its efficiency.
A programmer may define a function by executing the
primitive function DEFINE to specify the function name,
formal arguments, local variables, and the entry point of
the function. The entry point is the label of the first of
a set of SNOBOL4 statements constituting the procedure for
the function.
The first argument of DEFINE is a prototype describing the
form of the function call. The second argument is the entry
point. For example, execution of the statement
PDP-10 Snobol4 User's Guide Page 27
CHAPTER 3
DEFINE('DELETE(STRING,CHAR)','D1')
defines a function DELETE having two formal arguments,
STRING and CHAR, and entry point D1. The statements
D1 STRING CHAR = :S(D1)
DELETE = STRING :(RETURN)
form a procedure that deletes all occurrences of CHAR from
the value of STRING. The statement assigning the resulting
value to the variable DELETE illustrates the SNOBOL4
convention for returning a function value: The function
name may be used as a variable in the function procedure.
Its value on return from the procedure is the value of the
function call. Return from a procedure is accomplished by
transfer to the system label RETURN.
If the second argument is omitted from the call of DEFINE,
the entry point to the procedure is taken to be the same as
the function name. For example
DEFINE('DELETE(STRING,CHAR)')
could have the procedure
DELETE STRING CHAR = :S(DELETE)
DELETE = STRING :(RETURN)
A call of the function is illustrated in the following
statements
MAGIC = 'ABRACADABRA'
OUTPUT = DELETE(MAGIC,'A')
which print BRCDBR. Arguments are passed by value and may
be arbitrarily complex expressions. Thus the statement
TEXT = DELETE(TRIM(INPUT),' ')
deletes all blanks from the input string.
Functions can also fail under specified conditions. As an
example, consider the following version of DELETE, which
fails if STRING does not contain an occurrence of CHAR.
DELETE STRING CHAR = :F(FRETURN)
D2 STRING CHAR = :S(D2)
DELETE = STRING :(RETURN)
The transfer to the system label FRETURN indicates failure
of the function call. Consequently,
PUNCH = DELETE(TRIM(INPUT),'*')
PDP-10 Snobol4 User's Guide Page 28
CHAPTER 3
punches a card only if the input string contains an * .
Arguments to a function and the value returned can be any
type of data object. Consider, for example, the function
MAXNO where MAXNO(P,N) returns a pattern that matches up to
N adjacent strings matched by the pattern P. That is, if
PAT = MAXNO('A' ! 'B' ! 'C' ,2)
then in the statement
'EBCDIC' PAT 'D'
the pattern match succeeds with PAT matching the string BC.
MAXNO has the defining statement
DEFINE('MAXNO(P,N)')
and the procedure
MAXNO N = GT(N,0) N - 1 :F(RETURN)
MAXNO = NUL ! P MAXNO :(MAXNO)
Consider the function REVERSE that reverses a string. It
has the defining statement
DEFINE('REVERSE(STRING)','R1')
and the procedure
R1 ONECH = LEN(1) . CH
R2 STRING ONECH = :F(RETURN)
REVERSE = CH REVERSE :(R2)
There are two variables, ONECH and CH, used in the function
definition in addition to the function name and formal
argument. It is prudent to protect these variables so their
use outside the function is not affected when the function
is called. This is accomplished by declaring them to be
local variables in the defining statement:
DEFINE ('REVERSE(STRING)ONECH,CH','R1')
When the function is called, the current values of the local
variables, the formal arguments, and the function name are
saved before the procedure is entered. These values are
restored upon return from the procedure. This permits the
programmer considerable freedom in defining functions. For
example, a function can be recursive, i.e. include a call
of the function itself. Consider the binomial coefficient
C(N,M) which can be defined by equations
C(N,0) = 1
PDP-10 Snobol4 User's Guide Page 29
CHAPTER 3
C(N,M) = N*C(N-1,M-1)/M FOR M>0
Computational efficiency can be improved by employing the
relation
C(N,M) = C(N,N-M)
for M> N/2.
The corresponding programmer-defined function consists of
the defining statement DEFINE('C(N,M')
and the procedure
C M = LT(N - M,M) N - M
C = EQ(M,0) 1 :S(RETURN)
C = N * C(N - 1,M - 1) / M :(RETURN)
COMB is an example of another recursively defined
function. COMB(STR,N) lists all combinations of N
characters from the string STR. The defining statement and
procedure are
DEFINE('COMB(STR,N,HEAD)CH')
and
COMB OUTPUT = EQ(N,0) HEAD :S(RETURN)
C2 STR LE(N,SIZE(STR)) LEN(1) . CH = :F(RETURN)
COMB(STR,N - 1,HEAD CH) :(C2)
then
COMB('ABCD',3)
prints
ABC
ABD
ACD
BCD
Notice that COMB is defined with three formal
arguments but only two values are supplied in the initial
call. The missing value is taken to be NULL.
I. KEYWORDS
Several parameters and switches internal to the SNOBOL4
system can be accessed by means of keywords. Keywords are
specified by prefixing an ampersand to certain identifiers.
For example, if the value of the keyword &DUMP is a nonzero
integer when a program terminates, a dump of natural
PDP-10 Snobol4 User's Guide Page 30
CHAPTER 3
variables is printed. Thus the execution of the statement
&DUMP = 1
indicates that a dump is to be produced. &TRIM controls the
trimming of trailing blanks. If the value of &TRIM is
greater than zero, input records are trimmed. The default
value of &TRIM is zero.
&INPUT and &OUTPUT control input and output. If &INPUT is
greater than zero, automatic input is performed through
input accociations. If &INPUT is zero, however, such
associations are ignored and automatic input ceases.
&OUTPUT controls automatic output in a similiar manner. The
default value of &INPUT and &OUTPUT is 1.
J. ARRAYS
Arrays of variables can be created by using the primitive
function ARRAY. The arguments of ARRAY describe the number
of dimensions, the bounds of each dimension, and the initial
value of each variable in the array. Thus
V = ARRAY(10,1.0)
creates and assigns to V a one dimensional array of ten
variables, each initialized to the real value 1.0. The
created variables can be referenced by expressions of the
form V<I> where I = 1,...,10. the statement
N = ARRAY('3,5')
creates a 2-dimensional array of variables
N<1,1> N<1,2> N<1,3> N<1,4> N<1,5>
N<2,1> . . . .
N<3,1> . . . N<3,5>
the omission of the second argument causes each of the
variables to have the NULL string as initial value. The
arguments in the call of ARRAY can be expressions. Thus
A = ARRAY(TRIM(INPUT))
creates an array with dimensionality that is data dependent.
An array reference, A<I>, that is outside the bounds of the
array causes failure that can be used to control program
flow. The statements
I = 1
ST = ARRAY(TRIM(INPUT))
PDP-10 Snobol4 User's Guide Page 31
CHAPTER 3
MORE ST<I> = INPUT :F(GO)
I = I + 1 :(MORE)
GO
generate an array, ST, and assign values to each of the
variables. When all the variables in the array are assigned
values, or an end of file is encountered, the transfer to GO
is executed.
K. PROGRAMMER-DEFINED DATA TYPES
INTEGERS, REALS, STRINGS, PATTERNS, and ARRAYS are types of
data objects that are built into the SNOBOL4 language.
Facilities are provided in the language to permit a
programmer to define additional data types. This
facilitates representation of structural relationships
inherent in data. For example, a simple linear linked list
is made up of nodes, each containing a VALUE field and a
LINK field.
The primitive function DATA can be used to define the data
type NODE and the two field functions, VALUE and LINK.
DATA('NODE(VALUE,LINK)')
The statement
P = NODE('S',)
creates a node with VALUE field S and the NULL string in the
LINK field. The value of P is a data object with two fields
that can be referenced by means of the function calls
VALUE(P) and LINK(P). The insertion of a node with value T
at the head of the list is accomplished by the statement
P = NODE('T',P)
The following statement deletes a node from the head of the
list
P = LINK(P)
L. PROGRAM EXAMPLE
This is an example of a complete SNOBOL4 program
illustrating the use of comment lines, continuation lines,
and the END statement. The program reads in data cards that
follow the END statement.
************************************************************
* EXAMPLE OF A FUNCTION THAT PRINTS ALL
* PERMUTATIONS OF SIZE N FROM A GIVEN STRING.
************************************************************
PDP-10 Snobol4 User's Guide Page 32
CHAPTER 3
DUMP = 1
DEFINE('PERM(STRING,N,HEAD)CH,USED')
STRING = TRIM(INPUT) :F(ERROR)
N = TRIM(INPUT) :F(ERROR)
PERM(STRING,N) :(END)
PERM OUTPUT = EQ(N,0) HEAD :S(RETURN)
PERMA STRING LEN(1) . CH = :F(RETURN)
USED
. = PERM(STRING USED,N - 1,HEAD CH) USED
CH :(PERMA)
END
ABCD
3
M. TABLES
A TABLE is similar to an ARRAY except that it is limited to
one dimension, and its argument is not restricted to an
INTEGER, but may be any value. A TABLE may be thought of as
an ARRAY that permits associative references.
A TABLE is created by the TABLE function. For example,
T = TABLE()
creates a TABLE and assigns it as the value of T. Entries
in the table T may subsequently be referred to in much the
same way as ARRAY references are made. For example,
T<'A'> = 3
assigns the value 3 to the "Ath" element of T.
The referencing argument may be any value with any data
type. Simply by referring to the element, the appropriate
table element is referenced. If no such element exists, one
is created and given the NULL string as its initial value.
Tables cannot be copied using the COPY function. The
function ITEM can be used for tables as well as for arrays.
Programmers are cautioned that T<1> and T<'1'> reference
different elements of T. Particular care must be used when
the argument is the value of an expression.
The TABLE function actually has two arguments, both of which
may be omitted as illustrated in the example above. The
general form of the function is
TABLE(N,M)
PDP-10 Snobol4 User's Guide Page 33
CHAPTER 3
where N and M concern the size of the table. N determines
the initial size of the table, indicating how many elements
it can contain. M is the number of additional elements
provided if more are required. For example,
TABLE(20,15)
specifies a TABLE of 20 elements. If more are required, the
table size is increased to 35. If this is not sufficient,
the size is increased to 50, and so on. The default
values for N and M are 10. If either argument is omitted
(or zero), the corresponding default is used. Efficient use
of tables is obtained by specifying values corresponding
approximately to the expected TABLE sizes.
Conversion between tables and arrays may be
performed using the CONVERT function. If T is a TABLE,
A = CONVERT(T,'ARRAY')
assigns to A an ARRAY corresponding to the TABLE T. The
PROTOTYPE of A is 'N,2' where N is the number of items in T
that have nonnull values. A<I,1> is a reference element of
T and A<i,2> is the value of that element. The order of the
items in A is unpredictable. Only items with nonnull values
are included. Conversion from TABLE to ARRAY data type
fails if there is no item with a nonnull value.
A rectangular array with a second dimension that has
an extent of two can be converted to a TABLE. For example,
if R is an ARRAY with the PROTOTYPE '-3:3,2',
B = CONVERT(R,'TABLE')
creates a TABLE B of 7 items corresponding to R<I,1> and
with the values of these items being R<I,2> respectively.
The value used for additional items (corresponding
to M in TABLE(N,M) is the default, 10.
In output, trace messages, dumps and other
situations where data type representations are required,
tables appear as TABLE(N,M). For example, the statement
OUTPUT = B
results in the printout
TABLE(7,10)
PDP-10 Snobol4 User's Guide Page 34
CHAPTER 4
INPUT AND OUTPUT
INPUT and OUTPUT are accomplished by associating
variables with devices or filenames. In the case of a
variable associated in the OUTPUT sense, each time the
variable is assigned a value, a copy of the value is put out
onto the associated device or file. In the case of a
variable associated in the INPUT sense, each time the value
of the variable is used, a new value is read from the
associated device or file and becomes the new value of the
variable. Thus input and output go on during program
execution without any explicit I/O statements, as a result
of I/O associations. Variables having standard associations
are described in the following sections.
A. PRINTED OUTPUT
The variable OUTPUT is associated with a device or
file which is selected at run time by the user, for
instance, the line printer. Consequently, whenever OUTPUT
is assigned a value, printout is generated. For example,
OUTPUT = 'THE SELECTED VALUES ARE'
produces the output
THE SELECTED VALUES ARE
Output may also result from value assignment specified in
patterns. For example,
PEXP = BAL . EXP1 . OUTPUT '+' BAL . EXP2 .
OUTPUT
.
.
.
EXP PEXP
prints the two terms in EXP, and assigns their values to
EXP1 and EXP2. This type of output is often useful for
diagnostic purposes, and does not affect the pattern
matching or the assignments made to EXP1 and EXP2.
Ordinary printout is printed 132 characters per
line, with as many lines as necessary being generated. The
NULL string is treated as a blank character and a blank line
is printed for it. (On the PDP-10 this is actually output
as a CARRIAGE RETURN/LINE FEED). Strings are usually
assigned to output variables. Integers and real numbers
assigned to an output variable are automatically converted
PDP-10 Snobol4 User's Guide Page 35
CHAPTER 4
to strings. If an array is assigned to an output variable,
the printed output is ARRAY with the prototype of the array
enclosed in parentheses. For example, the statements
MATRIX = ARRAY('-2:2,-3:3',0)
OUTPUT = MATRIX
print
ARRAY('-2:2,-3:3')
If the prototype is longer than twenty characters, only the
string ARRAY is printed. If an object with any other data
type is assigned to an output variable, the formal
identification of its data type is printed. For example,
OUTPUT = LEN(7)
prints
PATTERN
B. PUNCHED OUTPUT
The variable PUNCH is associated with device number
7. Consequently, whenever PUNCH is assigned a value, a line
is punched on the card punch. For example,
PUNCH = 0
punches a card with a zero in column one.
All the remarks about print output apply to punch
output.
C. INPUT
The variable INPUT is associated with the standard
input data stream. Whenever the value of INPUT is used, a
card image is read from the input stream and becomes the new
value of INPUT. For example,
OUTPUT = INPUT
reads a card image and prints it. Similarly,
TRIM(INPUT) BAL . EXP
reads a card image and matches for a balanced string. All
eighty columns of the card images are read, but the value of
PDP-10 Snobol4 User's Guide Page 36
CHAPTER 4
INPUT is generally trimmed of trailing blanks.
Since each use of INPUT reads a card image, previous
values of INPUT are lost unless they are assigned to other
variables.
If an end of file is encountered when a value of
INPUT is requested, failure results. This failure can be
used to detect the end of a data file. For example,
I = 1
READ DATA<I> = INPUT :F(OUT)
I = I + 1 :(READ)
OUT
reads card images into the array DATA until the input data
stream is exhausted (or I exceeds the range of data).
Control is then transferred to OUT.
D. THE I/O SYSTEM
All input/output is handled by FORTRAN IV I/O
routines. That is, SNOBOL4 I/O is done by the same system
that does I/O for FORTRAN IV object programs. Consequently,
the conventions and I/O concepts specified for the FORTRAN
IV language also apply to SNOBOL4. In addition, the version
of the language described here operates under the PDP-10
Time-Sharing Systems, either 10/40 or 10/50. It is
necessary to understand both the fundamentals of FORTRAN IV
I/O and the PDP-10 standard CUSP to user interface in order
to do SNOBOL4 I/O effectively.
in FORTRAN, devices and files have associated
numbers. These numbers are referred to in source language
programs and are associated with specific devices and files
at run time. These numbers correspond to an index into the
FORTRAN operating system's device table, called DEVTB. A
copy of this table is listed in Appendix B. Filenames for
disk and DECtape files are established for the standard
INPUT and OUTPUT streams by the user at startup time.
Filenames can also be established via the IFILE and OFILE
primitive functions as described later.
The FORTRAN I/O used in SNOBOL4 only handles
sequential data sets. In particular, it cannot handle
random accessing of files.
SNOBOL on the PDP-10 handles multiple segment source
files for input. This allows the user to segment his coding
into short routines and to use common routines residing on
the system area of the disk.
PDP-10 Snobol4 User's Guide Page 37
CHAPTER 4
Thus, for example, a user may specify the following
command string
LPT:_SYS:COMMON,DSK:ONE,TWO,THREE
which would place the output listing file on the line
printer and compile the file named COMMON (located on the
system area of the disk) followed by the files named
ONE,TWO,THREE located on the user's disk area.
If after this command string has been exhausted and
no END statement has been seen, the system will then accept
further input from the user's terminal. To let the user
know additional input is expected from him, the message
WAITING FOR TTY INPUT
is printed on this terminal. This syntax allows the user to
specify at runtime which associations he desires for the
standard input and output streams. This specification
determines where the results of INPUT are to come from and
where the results of OUTPUT are to go.
Additional examples are
LPT:_CDR:
TTY:_CDR:
LPT:_DSK:PROG1
TTY:_TTY:
In general any device capable of output can be specified on
the left side of the arrow and any device capable of input
can be specified to the right of the arrow. These are
summarized below.
GENERAL FORMAT
LISTING-DEVICE:FILENAME.EXT_SOURCE-DEVICE:FILENAME.EX
T, ...
(1) LISTING-DEVICE: The device on which the
OUTPUT produced by SNOBOL is to be written.
MTAn: Magnetic Tape
DTAn: DEC Tape
DSK: Disk
PTP: Paper Tape Punch
LPT: Line Printer
TTY: Teletype
CDP: Card Punch
(1) SOURCE-DEVICE: The device from which the
source program INPUT to compilation is to be read.
PDP-10 Snobol4 User's Guide Page 38
CHAPTER 4
MTAn: Magnetic Tape
DTAn: DEC Tape
DSK: Disk
TTY: Teletype
CDR: Card Reader
PTR: Paper Tape Reader
FILENAME.EXT (DSK: and DTAn:only) The filename and filename
extension of the listing and the source files.
if .EXT is omitted, .LST is assumed for the
listing file and .SNO is assumed for the
source file.
(1) if a device is not specified, "DSK:" is always assumed.
E. OUTPUT ASSOCIAITONS
The variables OUTPUT AND PUNCH have predefined output
associations. Programmer-defined associations may be made
using the function OUTPUT. The form of the function is
OUTPUT(NAME,NUMBER,FORMAT)
OUTPUT associates the name with the device reference number
according to the given format. The format is a string
specifying a FORTRAN IV FORMAT. The following statements
correspond to the associations for the variables OUTPUT and
PUNCH:
OUTPUT('OUTPUT',6,'(1X,27A5)')
OUTPUT('PUNCH',7,'(16A5)')
Using the OUTPUT function, any variable can be associated
with any device reference number. For example,
PRFORM = '(1X,27A5)'
TEST = ARRAY('8,8')
OUTPUT(.TEST<1,1>,6,PRFORM)
OUTPUT(.TEST<8,8>,6,PRFORM)
associate the array elements TEST<1,1> and TEST<8,8> with
the ordinary print file and with the standard print format.
As a result, whenever either TEST<1,1> or TEST<8,8> is
assigned a value, the new value is printed.
Device reference numbers are not restricted to 5 and 6, but
can range from 1 through 37 . Associations can be made with
reference numbers other than the standard ones. In this
case, just set up the appropriate OUTPUT statement, perhaps
in conjunction with the IFILE primitive function if the
PDP-10 Snobol4 User's Guide Page 39
CHAPTER 4
device is file oriented.
Formats used in OUTPUT association must specify the
conversion of at least one element by A-conversion.
(Normally nA5-conversion is used.) Integers are converted
into strings and I conversion must not be used. In addition
to A conversion, quoted literals, X , H , and T conversion
may be specified. Carriage control must be provided for
printing; otherwise the first character of the string is
consumed for this purpose. Consider
OUTPUT('TITLE',6,'(1H1,27A5/(1X,27A5))')
When a value is assigned to TITLE, a page is ejected and the
value titles the next page of output. The use of literals
is illustrated by
OUTPUT('SUM',6,"(' SUM='25A5/(1X,27A5))")
which includes identifying information with the format.
Subsequently,
SUM = 300
causes the printout
SUM=300
The predefined associations can be changed. Thus,
OUTPUT('OUTPUT',6,'(1X,24A5)')
shortens the line length for OUTPUT to 120 characters.
F. INPUT ASSOCIATIONS
Programmer-defined input associations can be made
using the function INPUT. The form of this function is
INPUT(NAME,NUMBER,LENGTH)
INPUT associates the name with the device reference number,
and specifies that the resulting string is to have the given
length. (Notice in particular that no FORMAT is specified.)
INPUT has a predefined association equivalent to
INPUT('INPUT',5,80)
The specified length has some special properties. If the
length is less than the record size on the file being read,
the last part of the record is lost. Hence,
PDP-10 Snobol4 User's Guide Page 40
CHAPTER 4
INPUT('INPUT',5,72)
changes the association for INPUT so that only 72 columns
are read. Columns 73 through 80 are lost if data set
reference number 5 is associated with ordinary card INPUT.
A length longer than the record is usually recommended to
avoid any problems with truncation. Even though a longer
length is asked for, the actual string length will always be
used.
For example, if the user specifies a length of 130
characters in the INPUT function, and a string of 5
characters is read, the system will assign the string length
to be 5 and not 130.
G. OTHER I/O FUNCTIONS
Several other functions are provided for I/O-related
operations. All of these functions return the NULL string
as value.
1. DETACH
DETACH(NAME) removes any INPUT and OUTPUT association which
the name may have. For example,
DETACH('OUTPUT')
terminates normal print output.
2. ENDFILE
ENDFILE(NUMBER) writes an end of file on (closes) the file
specified by the number. For example,
ENDFILE(20)
closes the file associated with device reference number 20.
3. REWIND
REWIND(NUMBER) repositions the file associated with the
number to the beginning. For example,
REWIND(10)
rewinds the file associated with device reference number 10.
Subsequently, reference to 10 refers to the beginning of the
file specified. REWIND will cause any IFILE function
PDP-10 Snobol4 User's Guide Page 41
CHAPTER 4
associated with this file to be cancelled.
4. BACKSPACE
BACKSPACE(NUMBER) backspaces one record on the file
associated with the number.
5. IFILE
IFILE(NUMBER,FILENAME) allows the SNOBOL programmer to
select the name of INPUT disk or DECtape files at runtime.
This function is a link to the FORTRAN IFILE subroutine.
This function will signal a failure return if the file does
not exist on the given device.
For example,
IFILE(20,'SURVEY.OMA')
FILENAME = 'SNIP.SNO'
IFILE(25,FILENAME)
INPUT('ACCEPT',2,80)
IFILE(1,TRIM(ACCEPT))
are all valid uses of IFILE
6. OFILE
OFILE(NUMBER,FILENAME) allows the SNOBOL programmer to
select the name of OUTPUT disk or DECtape files at runtime.
This function is a link to the FORTRAN OFILE subroutine.
This function will signal a failure return if the file
cannot be entered on the given device.
I = I + 1
OUTPUT.NAME = SEQ '.' I
OFILE(22,OUTPUT.NAME)
OFILE(FINDEVICE('DTA0'),'THISIS.IT')
Are all valid examples of the use of OFILE.
7. TTCALL INTERFACE
The PDP-10 time sharing system has a special teletype
interface designed to allow character at a time I/O as
opposed to line at a time I/O.
To take advantage of this feature, any I/O to unit number 99
will be directed to or from the user's teletype.
PDP-10 Snobol4 User's Guide Page 42
CHAPTER 4
For example,
INPUT('CHARIN',99,1)
OUTPUT('TTYOUT',99)
Note that only one character is input each time an INPUT
association is referenced.
An entire string will be output each time an OUTPUT
association is referenced. A free CARRIAGE-RETURN LINE FEED
will not be supplied, however.
Since on input, control characters can now be referenced, a
means has been provided via the ASCII primitive function to
handle this case.
8. ASCII
ASCII(NUMBER) treats 'NUMBER' as octal and generates one
equivalent ASCII character. This mechanism is provided to
allow referencing of control characters.
For example,
CARRIAGE.RETURN.LINE.FEED = ASCII(15) ASCII(12)
Octal 15 is the CARRIAGE RETURN character and octal 12 is
the LINE FEED character. In the above example the
concatenation of the two resulting characters is assigned to
the variable name CARRIAGE.RETURN.LINE.FEED for later use.
9. TTY 'SWITCHES'
Several switches have been defined which allow the user to
specify options at runtime without modifying his program.
These switches are entered by the "/" character followed by
a single letter. They are defined as follows:
/D is equivalent to &DUMP = 1, and causes a dump of variable
storage at program termination.
/U is equivalent to -UNLIST, and suppresses printout of the
source program listing.
/I for each occurrence of this switch additional I/O buffer
space for one more disk file is allocated. The system
currently allows enough buffering for six simultaneous disk
files. If this number is exceeded, the I switch must be
used enough times to increase the buffering area by an
appropriate amount.
PDP-10 Snobol4 User's Guide Page 43
CHAPTER 5
STRUCTURE OF A SNOBOL4 RUN
A SNOBOL4 run consists of three distinguishable parts:
1) COMPILATION,
2) EXECUTION, AND
3) TERMINATION.
A. COMPILATION
During compilation, the SNOBOL4 system is
initialized and the source program is compiled into an
intermediate object code in a form suitable for
interpretation during program execution. Compilation uses
the same processes as conversion of a string to object code
using the CODE function. Additional processes are involved
in the reading of lines to be compiled from the input data
set, printing of a source listing on an output data set, and
noting errors in the source program.
1. SOURCE PROGRAM INPUT
Input to the compiler comes from a device associated
with unit reference number 5. The actual source device is
specified by the user at run time by using the relatively
standard PDP-10 command string syntax. If no device is
specified, DSK is assumed. In this case the user would
specify a filename. Only 72 characters per line are read,
so that columns 73-80 of the card image input may be used
for sequential numbering. The compiler continues to read
until it encounters the END statement. If an end of file is
encountered before the END statement is found, the compiler
will read from the next file specified by the user. If no
additional files are specified, control will revert to the
user's terminal so he can type additional statements. If no
further input is desired, the user can type END<CARRIAGE
RETURN> to terminate the compilation phase.
2. SOURCE LISTING
The listing of the program with sequential statement
numbers goes on the standard print output. When the END
statement is encountered, the compilation process stops. A
listing of the compilation and placement of statement
numbers can be controlled by control lines. A minus sign at
the beginning of a line identifies a control line. Program
listing is suppressed by the control line.
-UNLIST
PDP-10 Snobol4 User's Guide Page 44
CHAPTER 5
Program listing is restored by the control line
-LIST
The normal positioning of statement numbers is at the
left side of the source listing. Statement numbers
optionally may be placed at the right side of the listing.
The control line
-LIST LEFT
changes statement numbering to the left. Right positioning
of the statement numbers is restored by
-LIST RIGHT
or simply
-LIST
Blanks may appear between the minus sign and LIST or
UNLIST. One or more blanks must appear between the LIST and
the LEFT or RIGHT. Any characters other than LEFT following
blanks on the LIST control line cause the same action as
RIGHT. An erroneous control line is ignored.
-EJECT
causes a page eject to occur in the compilation listing when
encountered.
3. ERRORS DETECTED DURING COMPILATION
Certain kinds of errors in the source program are
detected during compilation. When an error is detected in a
statement, compilation of that statement is terminated and
an error message is printed below the statement, describing
the nature of the error. A list of compilation error
messages is given below. A marker pointing to the vicinity
of the error is also printed. This marker may be somewhat
before or after the error, depending on the nature of the
error. Since compilation of a statement stops when an error
is encountered, only the first error in any on statement is
detected. Compilation continues in spite of erroneous
statements. However, if more than fifty erroneous
statements are found, error termination occurs and the
program is not executed.
B. EXECUTION
Execution of the compiled object code begins when
compilation is complete. Ordinarily, program execution
begins with the first statement of the program. Program
execution may be started at any labelled statement by
PDP-10 Snobol4 User's Guide Page 45
CHAPTER 5
specifying that label in the END statement. The label of
the first statement to be executed is placed in the position
of the subject. For example,
END INIT
causes program execution to begin with the statement
labelled INIT.
Data read from the standard input source beings with
the first line after the END statement. Data printed during
execution follows the source listing.
C. TERMINATION
Upon termination, a statistics summary is printed to
provide timing information and counts of certain program
operations. If the keyword &DUMP is on at program
termination, a dump of natural variables and unprotected
keywords is also provided. Only natural variables with
nonnull values are included. If the value of a variable is
not a string, the same representation of the value is given
as would be given if the value were printed as the result of
an output association.
There are four kinds of termination:
1) normal,
2) error,
3) intervention, and
4) catastrophic.
1. Normal Termination
Normal termination occurs when the program transfers
to END or flows into the END statement. The number of the
last statement executed and the function level are printed.
2. Error Termination
Error termination occurs in case of a programming
error or internal condition sufficiently serious to prevent
continued execution. The statement number in which
execution terminated and the function level are printed. An
error message is printed indicating the cause of the
termination. Dumps and statistics are then printed as for
normal termination. The error messages are as follows:
THE CONDITIONALLY FATAL ERRORS ARE:
1. ILLEGAL DATA TYPE
2. ERROR IN ARITHMETIC OPERATION
3. ERRONEOUS ARRAY OR TABLE REFERENCE
PDP-10 Snobol4 User's Guide Page 46
CHAPTER 5
4. NULL STRING IN ILLEGAL CONTEXT
5. UNDEFINED FUNCTION OR OPERATION
6. ERRONEOUS PROTOTYPE
7. UNKNOWN KEYWORD
8. VARIABLE NOT PRESENT WHERE REQUIRED
9. ENTRY POINT OF FUNCTION NOT LABEL
10. ILLEGAL ARGUMENT TO PRIMITIVE FUNCTION
11. READING ERROR
12. ILLEGAL I/O UNIT
13. LIMIT ON DEFINED DATA TYPES EXCEEDED
14. NEGATIVE NUMBER IN ILLEGAL CONTEXT
15. STRING OVERFLOW
16. OVERFLOW DURING PATTERN MATCHING
THE UNCONDITIONALLY FATAL ERRORS ARE:
17. ERROR IN SNOBOL4 SYSTEM
18. RETURN FROM LEVEL ZERO
19. FAILURE DURING GOTO EVALUATION
20. INSUFFICIENT STORAGE TO CONTINUE
21. STACK OVERFLOW
22. LIMIT ON STATEMENT EXECUTION EXCEEDED
23. OBJECT EXCEEDS SIZE LIMIT
24. UNDEFINED OR ERRONEOUS GOTO
25. INCORRECT NUMBER OF ARGUMENTS
26. LIMIT ON COMPILATION ERRORS EXCEEDED
27. ERRONEOUS END STATEMENT
28. EXECUTION OF STATEMENT WITH COMPILATION ERROR
29. IO BUFFER SPACE EXHAUSTED, RESTART AND USE
THE I SWITCH
30. INSUFFICIENT STORAGE, NOT ENOUGH CORE FOR
STARTING
When program execution is terminated by an error,
the error number as well as the descriptive phrase is
printed on the program listing.
3. INTERVENTION TERMINATION
On the PDP-10 intervention termination can be forced
by the user With the REENTER command. When the user
suspects that his program is looping he can get control by
typing two control C's to get into monitor mode again.
Should be desire to resume processing the CONTINUE or
CCONTINUE commands can be used to continue where the
operation was interrupted. If, however, the user desired to
terminate the run in a somewhat graceful fashion, he can use
the REENTER command. This will automatically cause the DUMP
keyword to be set so the user will get as much useful
information as possible. The message "CUT BY SYSTEM IN
STATEMENT N AT LEVEL M" is printed and the dumps and
statistics are then printed as for normal termination.
PDP-10 Snobol4 User's Guide Page 47
CHAPTER 5
There are a number of situations on the PDP-10 where the
FORTRAN operating system will detect an error, print an
error message and return you to monitor mode. The user has
no recourse but to correct the error condition and restart
his program.
4. CATASTROPHIC TERMINATION
Catastrophic termination occurs when system or
machine malfunction causes a situation so serious that
intervention termination is impossible. In the case of a
catastrophic termination, there may be no indication of the
source or cause of the termination. Print and punch output
may be incomplete or lacking altogether..;appendix a edited
9-5-70 lp wade
PDP-10 Snobol4 User's Guide Page 48
APPENDIX A
SYSTEM PROGRAMMER'S NOTES
1. A fixed amount of space is reserved for the user's IO
buffers. The buffers are set up at run time by FORSE and
their size is variable depending upon device. The user can
increase this amount with the "I" switch. Each occurrence
of this switch allows space for double buffering one more
device.
The global variable NUMIOB (NUMber of IO Buffers) controls
the buffering space. It is initially set to four to provide
space for four devices in addition to the standard input and
output devices.
If your users tend to use more devices change NUMIOB either
with DDT or with the I switch before putting SNOBOL on SYS.
2. The internal design of SNOBOL is such that key constants
are destroyed upon program execution. This creates a
problem when the user tries to execute many programs in
succession or tries to stop and restart a program. For this
reason a file called SNOBOL.INI is read in each time a
program is compiled in order to reset these constants.
SNOBOL looks for this file on SYS so be sure to put it there
when putting on SNOBOL.SHR and SNOBOL.LOW. For non disk
systems the user should assign the DECtape drive containing
SNOBOL.INI to SYS. This file is created using the "C"
switch as described below.
The C switch is intended for use by the system's programmer
when SNOBOL is first put on the system. SNOBOL has the
property of destroying key constants during a run, and in
order to allow restarts these constants must be
reinitialized prior to every run.
The intended procedure is to LOGIN, run SNOBOL, and type
"/C". This will write SNOBOL.INI on DSK:. Then PIP
SNOBOL.* to SYS:. Hereafter, any user running SNOBOL will
always access this file for his initialization. See
SNOBOL.OPR on the system tape for a better description.
3. Since IO is done through FORSE you should be aware of
some of the limitations which result.
At execution time all strings are read via the STREAD macro
which executes the FORSE IN. UUO with a FORMAT of 16A5.
This means only 80 characters are read and longer strings
are truncated. To read in a long string it is necessary to
concatenate the portions of the input.
FORSE will strip off all CR and LF characters on input and
append them on output.
PDP-10 Snobol4 User's Guide Page 49
APPENDIX A
When outputting strings at execution time, an attempt is
made to not merely truncate the string to 132 characters but
to output the string in its entirety. The string is placed
in a previously zeroed buffer of 27 words and enough DATA.
UUOs are executed to output the characters in the buffer If
more words remain, the internal buffer is again zeroed,
filled and output. After each output, a CR and LF will be
added by FORSE.
At compilation time all input is read with a FORMAT of 16A5
to limit the source to card image input.
All of the magtape operations are also done by FORSE such as
REWIND and BACKSPACE. Any problems encountered here are
likely in FORSE.
4. Adding new functions is fairly easy. I suggest looking
at the common functions of SIZE or OFILE and pattern your
additions after these. Keywords will be added in much the
same way.
5. Each installation may wish to change the so called
attribution printed each time a run is started. This is
actually a FORMAT statement at the label SOURCF in the file
named COMMON, which typically prints "DIGITAL EQUIPMENT
CORP. PDP-10".
6. I suggest you stick with the loading procedure noted in
SNOBOL.OPR. This leaves DDT at the very end of the low
segment thereby taking a simple patch to reclaim the space
in the production version but offering the benefit of having
DDT around for quick fixes.
7. A few edits were made to the FORTRAN operating system in
order to handle the SNOBOL interface.
a. The RESET. UUO executes a CALLI 0 which cannot be
tolerated since program execution has begun when this is
called.
b. The RESET.UUO releases all channels 0-17. A change
was made to release only 0-16 because channel 17 is kept
open for the CCL feature.
c. The CHINN routine which does character input was
modified to not change characters less than 24 octal
(control characters) to blanks. This was primarily done
because of TAB being converted to a single blank character.
d. The ALPHO routine was modified to not convert
control characters to blanks, again primarily for TAB.
8. The command scanner in EXEC accepts project-programmer
numbers and passes them to a modified IFILE routine.
PDP-10 Snobol4 User's Guide Page 50
APPENDIX A
Consequently, users can specify PPNS, i.e. FOO_FOO[30,112].
9. Dynamic core expansion is done in two parts, and is
always associated with the garbage collection routine.
The first part is invoked if the garbage collector fails to
find enough free storage. In this case we attempt to get 2K
more, or 1K if that is all that remains. If core is
exhausted the program is terminated with an appropriate
error message.
The second part is invoked on every fifth entry to the
garbage collector. On these occasions a 2K (or 1K)
preexpansion is performed in order to prevent reaching a
state where just enough core is obtained and an inordinate
number of collections is required. This preexpansion is
only performed as long as the free storage area is less than
15K.
At proper termination the amount of core used is printed as
a part of the "STATISTICS" printout. Before giving up
control, the program shrinks back to the original starting
size.
10. As a means of getting more information from the system
i added the "V" switch which will cause the number of string
lookups to be printed as part of the statistics printout.
This number is really comparable to the number of symbol
table look- ups. Each time the VARID macro is called to
hash code a string, it increments a count. The printing of
this count is controlled by the global VARPRT which in turn
is controlled by the "V" switch.
If you desire this printout to always be included in your
user's printout, set VARPRT non zero with DDT before putting
SNOBOL on the system.
PDP-10 SYNTAX TABLE LAYOUTS
GENERAL FORM
XXXTAB:
1 0
3 2
5 4
7 6
11 10
PDP-10 Snobol4 User's Guide Page 51
APPENDIX A
13 12
. .
177 176
THERE ARE 64 DECIMAL WORDS IN EACH SYNTAX TABLE,
WITH ONE HALFWORD ENTRY FOR EACH CHARACTER.
TYPICAL HALFWORD ENTRY
2 free bits
1 bit for ERROR
1 bit for CONTIN
1 bit for STOPSH
1 bit for STOP
6 bits for SYNTAB index
6 bits for PUTTAB index
SYNTAB is a table of 18 bit addresses which point to the
next syntax table to search through. The index into this
table is stored as opposed to the actual address in order to
make the tables compact.
PUTTAB is a table containing either constants or function
addresses (possibly 18 bits). The index into this table is
stored as opposed to the actual value in order to make the
tables compact. The six bit size was chosen by counting the
number of possible entries.
There are less that 32 separate syntax tables so five bits
is sufficient for the index. However, six bits was chosen
for readability.
The particular entry is retrieved by the STREAM macro (which
calls the STREEM subroutine) by picking up successive
characters, dividing the ASCII value by two observing
whether the result is odd or even and indexing the
appropriate table half.
The GEN macro generates the tables. Care must be taken if
these tables are changed. The appearance of the arguments
is opposite of what the core image will generate. For
example,
GEN 102, 103, A, B
will be the equivalent of saying
XWD B, A
I felt it was easier to read the syntax table source coding
PDP-10 Snobol4 User's Guide Page 52
APPENDIX A
by doing it this way..;appendix b edited 9-5-70 lp wade
PDP-10 Snobol4 User's Guide Page 53
APPENDIX B
DEVICE NUMBER ASSIGNMENTS
* THE FOLLOWING ARE THE DEVICE DEFINITIONS AS USED BY SNOBOL
*
* THIS PROGRAM CAN BE ASSEMBLED BEFORE YOUR PROGRAM
* TO PROVIDE A FUNCTION CALLED 'FINDEVICE' WHICH WILL
* ALLOW YOU MORE FLEXIBILTY IN HANDLING I/O.
*
* FOR EXAMPLE, IF THIS PROGRAM IS ON SYS:FIND.SNO
* YOU WOULD TYPE
*
* .R SNOBOL
* *FOO_SYS:FIND,YOURS.SNO
*
DEVTB = TABLE(40)
DEVTB<'DSK'> = 1
DEVTB<'TTY'> = 2
DEVTB<'PTR'> = 3
DEVTB<'PTP'> = 4
DEVTB<'DSK10'> = 5
DEVTB<'DSK11'> = 6
DEVTB<'CDP'> = 7
DEVTB<'CDR'> = 8
DEVTB<'LPT'> = 9
DEVTB<'DTA0'> = 10
DEVTB<'DTA1'> = 11
DEVTB<'DTA2'> = 12
DEVTB<'DTA3'> = 13
DEVTB<'DTA4'> = 14
DEVTB<'DTA5'> = 15
DEVTB<'DTA6'> = 16
DEVTB<'DTA7'> = 17
DEVTB<'PLT'> = 18
DEVTB<'FORTR'> = 19
DEVTB<'DSK0'> = 20
DEVTB<'DSK1'> = 21
DEVTB<'DSK2'> = 22
DEVTB<'DSK3'> = 23
DEVTB<'DSK4'> = 24
DEVTB<'DSK5'> = 25
DEVTB<'DSK6'> = 26
DEVTB<'DSK7'> = 27
DEVTB<'DSK8'> = 28
DEVTB<'DSK9'> = 29
DEVTB<'MTA0'> = 30
DEVTB<'MTA1'> = 31
DEVTB<'MTA2'> = 32
DEVTB<'MTA3'> = 33
DEVTB<'MTA4'> = 34
DEVTB<'MTA5'> = 35
DEVTB<'MTA6'> = 36
DEVTB<'MTA7'> = 37
*
DEFINE('FINDEVICE(NAME)') :(FINDEND)
PDP-10 Snobol4 User's Guide Page 54
APPENDIX B
*
FINDEVICE FINDEVICE = DEVTB<NAME>
IDENT(FINDEVICE) :S(FRETURN)F(RETURN)
FINDEND
PDP-10 Snobol4 User's Guide Page 55
INDEX
----- INDEX -----
$ operator . . . . . . . . . . 20
&DUMP . . . . . . . . . . . . 29, 42
&INPUT . . . . . . . . . . . . 30
&OUTPUT . . . . . . . . . . . 30
&TRIM . . . . . . . . . . . . 30
. . . . . . . . . . . . . . . 20
.LST . . . . . . . . . . . . . 6
.SNO . . . . . . . . . . . . . 6
A FORMAT . . . . . . . . . . . 39
A1 FORMAT . . . . . . . . . . 8
A5 FORMAT . . . . . . . . . . 8
Addition . . . . . . . . . . . 12
ADDITIONS . . . . . . . . . . 9
Alternation . . . . . . . . . 8, 18
Alternation symbol . . . . . . 8
APE . . . . . . . . . . . . . 23
Arithmetic expressions . . . . 13
Arithmetic operations . . . . 12
ARRAY . . . . . . . . . . . . 30-33, 35
ASCII . . . . . . . . . . . . 9, 42
Assignment statement . . . . . 11
Assignments . . . . . . . . . 11
Asterisk . . . . . . . . . . . 12
BACKSPACE . . . . . . . . . . 41, 49
Beginner's notes . . . . . . . 9
BLANK . . . . . . . . . . . . 8, 10-12, 18-19
C Switch . . . . . . . . . . . 48
Carriage control . . . . . . . 39
CARRIAGE RETURN . . . . . . . 34
CHANGES . . . . . . . . . . . 8
CHARACTER SET . . . . . . . . 8
Colon . . . . . . . . . . . . 21
COMB . . . . . . . . . . . . . 29
Command . . . . . . . . . . . 37
Command string . . . . . . . . 37
Command syntax . . . . . . . . 37
Comment line . . . . . . . . . 8, 12
COMPILATION . . . . . . . . . 43
Compilation errors . . . . . . 44
Concatenation . . . . . . . . 15, 17-20
Conditional assignment . . . . 20
Conditional transfer . . . . . 21
Conditional value assignment . 20
CONDITIONALLY FATAL ERRORS . . 45
Continuation lines . . . . . . 12
CONVERT . . . . . . . . . . . 33
COPY . . . . . . . . . . . . . 32
Core . . . . . . . . . . . . . 5
Core expansion . . . . . . . . 9, 50
PDP-10 Snobol4 User's Guide Page 56
INDEX
Core size . . . . . . . . . . 5
Current version . . . . . . . 5
CUT BY SYSTEM . . . . . . . . 46
D Switch . . . . . . . . . . . 7, 9, 42
DATA . . . . . . . . . . . . . 31
DEFINE . . . . . . . . . . . . 26, 28
Defined functions . . . . . . 26
DELETE . . . . . . . . . . . . 27
DETACH . . . . . . . . . . . . 40
Device assignments . . . . . . 53
Device numbers . . . . . . . . 8, 36, 38
Device reference number . . . 39
Device reference numbers . . . 8, 38
Device table . . . . . . . . . 36
DEVTB . . . . . . . . . . . . 36, 53
DIFFER . . . . . . . . . . . . 26
DIFFERENCES . . . . . . . . . 8
Division . . . . . . . . . . . 12
Dollar sign operator . . . . . 20
Dot operator . . . . . . . . . 20
DUMP . . . . . . . . . . . . . 7-10, 25, 29, 42
DUPL . . . . . . . . . . . . . 24
EJECT . . . . . . . . . . . . 44
END . . . . . . . . . . . . . 11, 21, 37, 45
End of file . . . . . . . . . 36
END statement . . . . . . . . 21
ENDFILE . . . . . . . . . . . 40
Error termination . . . . . . 45
ERRORS . . . . . . . . . . . . 44-46
Exclamation mark . . . . . . . 8
EXECUTION . . . . . . . . . . 44
Exponentiation . . . . . . . . 12
Expressions . . . . . . . . . 13
EXTERNAL FUNCTIONS . . . . . . 8
F . . . . . . . . . . . . . . 21
Failure goto . . . . . . . . . 21
FEATURES . . . . . . . . . . . 8
FINDEVICE FUNCTION . . . . . . 53
FORM FEED . . . . . . . . . . 8
FORMAT . . . . . . . . . . . . 8, 10, 38-39, 49
Format statement . . . . . . . 39
FORSE . . . . . . . . . . . . 48-49
FORTRAN . . . . . . . . . . . 36
FRETURN . . . . . . . . . . . 27
Function . . . . . . . . . . . 4
FUNCTIONS . . . . . . . . . . 23
Functions . . . . . . . . . . 26
Garbage collection . . . . . . 50
Goto field . . . . . . . . . . 22
H FORMAT . . . . . . . . . . . 39
High segment . . . . . . . . . 5
I Switch . . . . . . . . . . . 7, 42, 48
I/O . . . . . . . . . . . . . 34
I/O buffers . . . . . . . . . 42
I/O SYSTEM . . . . . . . . . . 36
IFILE . . . . . . . . . . . . 9, 36, 41
ILLEGAL DATA TYPE . . . . . . 15, 22-23
Immediate value assignment . . 20
Indirect . . . . . . . . . . . 22
Indirect reference . . . . . . 22
INPUT . . . . . . . . . . . . 8-9, 16, 30, 34-35, 40
INPUT ASSOCIATIONS . . . . . . 39
INPUT failure . . . . . . . . 36
Input length . . . . . . . . . 40
INTEGER . . . . . . . . . . . 31
Integer . . . . . . . . . . . 12
Interpreter . . . . . . . . . 5
Interpretive . . . . . . . . . 5
INTERVENTION TERMINATION . . . 46
INTRODUCTION . . . . . . . . . 11
IO BUFFERS . . . . . . . . . . 7
Keywords . . . . . . . . . . . 29
LE . . . . . . . . . . . . . . 25
LEN . . . . . . . . . . . . . 24
LGT . . . . . . . . . . . . . 4, 26
LINE FEED . . . . . . . . . . 34
LIST . . . . . . . . . . . . . 44
LIST LEFT . . . . . . . . . . 9, 44
LIST RIGHT . . . . . . . . . . 44
Listing . . . . . . . . . . . 37
Listing device . . . . . . . . 37
Listing file . . . . . . . . . 37
LISTING-DEVICE . . . . . . . . 5
Low segment . . . . . . . . . 5
MAXNO . . . . . . . . . . . . 28
Minus sign . . . . . . . . . . 43
Mixed mode expressions . . . . 13
MOD . . . . . . . . . . . . . 13
MSTIME . . . . . . . . . . . . 9
Multiple source files . . . . 36
Multiplication . . . . . . . . 12
Negation . . . . . . . . . . . 8
Negation symbol . . . . . . . 8
Normal termination . . . . . . 45
NULL . . . . . . . . . . . . . 10, 14-15, 34
NULL STRING . . . . . . . . . 10
NULL string . . . . . . . . . 14
NUMIOB . . . . . . . . . . . . 48
OFILE . . . . . . . . . . . . 9, 36, 41
OMISSIONS . . . . . . . . . . 8
OTHER I/O FUNCTIONS . . . . . 40
PDP-10 Snobol4 User's Guide Page 58
INDEX
OUTPUT . . . . . . . . . . . . 8, 16, 30, 34, 36, 38
OUTPUT asociaitons . . . . . . 10
OUTPUT ASSOCIATIONS . . . . . 38
Parentheses . . . . . . . . . 13
Patern matching . . . . . . . 16
Pattern . . . . . . . . . . . 4, 16
Pattern matching . . . . . . . 4, 16
PATTERNS . . . . . . . . . . . 31
Patterns . . . . . . . . . . . 16, 18
Precedence . . . . . . . . . . 15
Predicates . . . . . . . . . . 25
Primitive functions . . . . . 4, 23
PRINTED OUTPUT . . . . . . . . 34
PROGRAM EXAMPLE . . . . . . . 31
Programmer defined . . . . . . 31
PUNCH . . . . . . . . . . . . 35, 38
PUNCHED OUTPUT . . . . . . . . 35
Quotation marks . . . . . . . 14
Quotes . . . . . . . . . . . . 14
Random access . . . . . . . . 36
Reading . . . . . . . . . . . 16
REAL . . . . . . . . . . . . . 31
Real numbers . . . . . . . . . 13
Recursive . . . . . . . . . . 28
REENTER COMMAND . . . . . . . 46
Reentrant . . . . . . . . . . 9
REMDR . . . . . . . . . . . . 25
REPLACE . . . . . . . . . . . 4, 24
Replacement . . . . . . . . . 17
Replacement statement . . . . 17
RETURN . . . . . . . . . . . . 27
REVERSE . . . . . . . . . . . 28
REWIND . . . . . . . . . . . . 40, 49
S . . . . . . . . . . . . . . 21
Semicolon . . . . . . . . . . 8, 12
SIZE . . . . . . . . . . . . . 23
SNOBOL.INI . . . . . . . . . . 48
SNOBOL.OPR . . . . . . . . . . 49
SOURCE DEVICE . . . . . . . . 5
Source device . . . . . . . . 37
Source file . . . . . . . . . 37
Source files . . . . . . . . . 36
SOURCE LISTING . . . . . . . . 43
SOURCE PROGRAM INPUT . . . . . 43
SOURCE-DEVICE . . . . . . . . 6
Standard input . . . . . . . . 5
Standard output . . . . . . . 5
STRINGS . . . . . . . . . . . 31
Subtraction . . . . . . . . . 12
Success goto . . . . . . . . . 21
PDP-10 Snobol4 User's Guide Page 59
INDEX
Switches . . . . . . . . . . . 6, 42
SYNTAX TABLES . . . . . . . . 50
SYSTEM PROGRAMMER'S NOTES . . 48
T FORMAT . . . . . . . . . . . 39
TAB . . . . . . . . . . . . . 8
TABLE . . . . . . . . . . . . 32
TERMINATION . . . . . . . . . 45
Transfers . . . . . . . . . . 21
TRIM . . . . . . . . . . . . . 10, 23, 30, 35
TTCALL . . . . . . . . . . . . 9
TTCALL interface . . . . . . . 41
TTY SWITCHES . . . . . . . . . 42
U Switch . . . . . . . . . . . 7, 9, 42
Unary . . . . . . . . . . . . 22
Unconditional transfer . . . . 21
UNCONDITIONALLY FATAL ERRORS . 46
Underline . . . . . . . . . . 8
Underline symbol . . . . . . . 8
UNLIST . . . . . . . . . . . . 7, 9, 42-43
User's Guide . . . . . . . . . 5
Version . . . . . . . . . . . 5
VERTICAL TAB . . . . . . . . . 8
VORMAT . . . . . . . . . . . . 48
WAITING FOR TTY INPUT . . . . 37
Writing . . . . . . . . . . . 16
X FORMAT . . . . . . . . . . . 39
Zero . . . . . . . . . . . . . 15