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 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 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 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 = A + 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 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, 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 = 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 is a reference element of T and A 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 and with the values of these items being R 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 = 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 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 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