Trailing-Edge
-
PDP-10 Archives
-
decuslib10-12
-
43,50547/runlib.doc
There is 1 other file named runlib.doc in the archive. Click here to see a list.
RUNLIB.DOC - Description of routines in FOR:RUNLIB.REL
This library of routines was started in 1976 for use by the DRAW package.
The DRAW package is a set of FORTRAN programs which require some monitor calls
not available in FORLIB. RUNLIB fills this requirement by including subroutines
to read and write TMPCOR files, get the user's name and job number, and execute
the RUN UUO. The subroutines originally used by DRAW were:
EXITGO Exit to the monitor unless a /RUN: switch was specified.
HELPER Type the help file.
INCHWL Read in one line from the terminal, or from an indirect file.
JBINFO Job info, such as job number and user name.
MATCH Check if a word matches a list of commands.
RESCAN Read TMPCOR, or the monitor command line.
RUNUUO Run the next .EXE file in the package.
SAVRUN Check for /RUN:, /RUNOFF, /HELP, or /EXIT in command line.
TMPCOR Write files in TMPCOR, giving commands to the next program.
Later on, more routines were added to increase functionality. These are:
EXIT0 Return to monitor level, type "EXIT".
EXIT1 Return to monitor level quietly, the "CONTINUE" command will work.
OUTSTR Type a string on the terminal, complement of INCHWL.
SUBTTL Calling sequence -- Quick summary
CALL EXIT0
CALL EXIT1
CALL EXITGO
CALL HELPER (0)
CALL INCHWL (NAME, BUFFER, KOUNT, LENGTH, LASTC)
CALL MATCH ('LIST,OF,COMMANDS,ETC',BUFFER,KOUNT,LENGTH,INDEX,DNAME)
GOTO (100, 200, 300, 400) INDEX
CALL OUTSTR (ICC, BUFFER, KOUNT)
CALL RESCAN (NAME, BUFFER, KOUNT, LENGTH, LASTC)
CALL RUNUUO (IERR, PRGNAM, KOUNT, ICCL)
CALL SAVRUN (IOPT, BUFFER, KOUNT, LENGTH, LASTC)
CALL TMPCOR (NAME, BUFFER, KOUNT)
IVALUE = JBINFO(ITABLE)
SUBTTL Calling sequence -- Introduction
These routines are provided to allow FORTRAN programs to act like
CUSP's (Commonly Used System Programs). In particular, these routines
can be used to check for command-input, exit to the monitor, or
chain-off to another program.
=============== Introduction to TMPCOR and RESCAN ====================
Commonly Used System Programs have many ways to pick up commands.
Let's take DIRECT for example. You can give commands to DIRECT in 5
different ways. 1) Monitor command; ".DIRECT TEST.FOR". 2) The R or
RUN command; ".R DIRECT (TEST.FOR)". 3) The temp-core file 'DIR';
"TEST.FOR". 4) Temp disk file 'nnnDIR.TMP'; "TEST.FOR". 5) When the
program prompts; "*TEST.FOR".
1) The monitor recognizes the word "DIRECT" and runs SYS:DIRECT.
DIRECT does a RESCAN to re-read the same command that the monitor read.
It skips over the first word, and takes the rest of the line as a
command.
2) The monitor recognizes the "R" command to run a program off of
SYS:. It ignores anything in parentheses. DIRECT does a RESCAN,
recognizes the "R", and expects its command to be enclosed in
parentheses.
3) The monitor has space for short files in temp-core (TMPCOR).
Each file goes by a three letter name, such as 'DIR' for DIRECT, 'FOR'
for FORTRAN, 'LNK' for LINK, 'MCR' for MACRO, etc. When your program
writes the words "TEST.FOR" into the 'DIR' temp-file. DIRECT reads
'TMP:DIR' and uses it as a command.
4) If TMPCOR is full, the temp-file can be put on DSK:. If your job
is number 12, then the name of the file is 'DSK:012DIR.TMP'. DIRECT
searches for this file if it cannot find anything in TMPCOR.
5) If DIRECT connot find a command anywhere, it prints a prompt and
waits for you to type a command. DIRECT uses an asterisk "*" as its
prompt. Only in case 5 will DIRECT expect more commands. As soon as it
is dones with the first command, it will give another prompt and wait
for another one, it does not return to the monitor. Typing a Control-Z
or "/EXIT" will get you to the monitor. If you type "TEST.FOR^Z", DIRECT
will give a listing for the file TEST.FOR and then return to the monitor.
The temp files in steps 3 and 4 are often referred to as CCL files.
CCL stands for Concise Command Language, and were first used by the
COMPIL program.
The RESCAN routine handles cases 1 through 4. For case 5, RESCAN
will report that it could not find anything, and your program will have
to call INCHWL to give a prompt and pick up a command.
============== Common Switches (Commands to SAVRUN) ==================
Most system programs understand comments and at least three
switches. The routine SAVRUN scans an array (buffer) and interprets the
standard switches and comments. A comment is anything after a semicolon
or an exclaimation point, ";" and "!". SAVRUN will remove comments,
remove leading spaces, convert tabs to spaces, reduce multiple
spaces to a single space, and convert lowercase to upper.
SAVRUN recognizes four switches; /HELP, /EXIT, /RUN:, and /RUNOFF.
When SAVRUN sees "/H" or "/HELP", it will type the help file for the
program. "/EXIT" and "/RUN:PROGRAM" cause LASTC to be set to 26, as a signal
to call the EXITGO routine.
SUBTTL Calling sequence -- RESCAN
RESCAN checks for command input. The commands may come from monitor
level, from a TMPCOR file, or from the temp file on disk.
CALL RESCAN (NAME, BUFFER, KOUNT, LENGTH, LASTC)
NAME = (INPUT) Three letter name of the temp-core file.
-1 means to use the name of the program, 0 to not check CCL files.
BUFFER = (OUTPUT) Array receiving the command, 5 characters per word.
KOUNT = (OUTPUT) Number of characters read in. Zero if nothing was found,
negative if a CCL file was input, to be read by INCHWL.
LENGTH = (INPUT) Size that BUFFER is dimensioned for. RESCAN will read
binary data if LENGTH is negative.
LASTC = (OUTPUT) ASCII code for the last character read in.
RESCAN first trys checking for the monitor command which started
your program. Then it checks temp-core, and finally the disk file for
commands. Because the CCL files in temp-core and disk can have more than
one line of commands, RESCAN will only check for the existance of such files
if LENGTH is positive. When this occurs, your program should call INCHWL to
get lines from the command file. Each call to INCHWL will read one line from
the CCL file, your program should continue reading until LASTC=26 (End of File).
In order to make it possible to read arbitrary binary data from TMPCOR
files, RESCAN will do input differently if you specify a negative number for
LENGTH. In this case, the entire file is read in all at once, KOUNT is 5
times the number of words read in, and LASTC is set to zero. RESCAN will not
check the monitor command line when LENGTH is negative.
KOUNT = 0 means that no command was found. This is the usual case.
KOUNT positive means that RESCAN has read the command into BUFFER.
KOUNT negative means that RESCAN found a CCL file for INCHWL to read.
SUBTTL Calling sequence -- INCHWL
INCHWL gets a line of input from the terminal (or command file). <<
CALL INCHWL (NAME, BUFFER, KOUNT, LENGTH, LASTC)
NAME = (INPUT) Three letter prompt, such as 'ABC' for "ABC>".
A value of zero or all blanks will suppress the prompt.
If NAME = -1, INCHWL will use the first three letters of the
name of your program.
BUFFER = (OUTPUT) Array receiving the command, 5 characters per word.
KOUNT = (OUTPUT) Number of characters read in. 0 for a blank line,
-1 (and LASTC=26) at end of CCL file read in by RESCAN.
LENGTH = (INPUT) Size that BUFFER is dimensioned for.
LASTC = (OUTPUT) ASCII code for the last character read in.
Your program should call EXITGO if LASTC=26 (End-Of-File).
INCHWL reads commands from the terminal, or from the CCL file if
RESCAN found one. When reading from the terminal, INCHWL prompts the
user if NAME is not zero or blanks, and then waits for the user to type
in a line. If NAME='ABC', then INCHWL would type "ABC>" on the terminal
to signify that it is waiting for input. If the user types in a blank
line (just hits the RETURN key), then INCHWL will return BUFFER as
blanks, KOUNT=0, and LASTC=13 (the code for RETURN). The only time
INCHWL returns with KOUNT negative is if it was reading from a command
file, and hit the end of file.
The end-of-line character gets stored in LASTC, right justified in
an (R1) format. Usually the user will type a carriage return so LASTC
will be 13. Other characters often used is the 'ESCape' to signal
special processing and Control-Z to exit when done.
Character Code Decimal Octal
-------- ------ ------- -----
Bell CTRL-G 7 "07
Linefeed CTRL-J 10 "12
Vertical Tab CTRL-K 11 "13
Formfeed CTRL-L 12 "14
Return CTRL-M 13 "15
End-of-file CTRL-Z 26* "32 *Control-Z means "/EXIT"
Escape $ CTRL-[ 27 "33
SUBTTL Calling sequence -- TMPCOR and RUNUUO
TMPCOR can be used to leave temporary messages for other programs.
CALL TMPCOR (NAME, BUFFER, KOUNT)
NAME = (INPUT) Three letter name of the temp-core file.
BUFFER = (INPUT) Array or literal containing the message.
KOUNT = (INPUT) Number of characters in the message.
In the 6.03A and previous monitors, temp-core was limited to 8
blocks of 20 characters each. TMPCOR was easily filled by medium length
messages. In the 7.01 monitor, the maximum size of any single TMPCOR
file is 2550 characters, and there is no limit to the number of TMPCOR
files.
-----------------------------------------------------------
RUNUUO will start the execution of another program.
CALL RUNUUO (IERR, PRGNAM, KOUNT)
CALL RUNUUO (IERR, PRGNAM, KOUNT, ICCL)
IERR = (OUTPUT) Error code if the next program cannot be run.
Error codes are 0=No such program, 1=No such PPN, 2=Protection
failure, 12 octal (10 decimal)=No such device.
PRGNAM = (INPUT) Array or literal containing the name of the program to
run. Must be in the form of 'DEV:PROG.EXT[ppn]'. EXT is
usually left off. If a PPN is given, it must be last. DEV is
optional and defaults to 'DSK:', so you may run your programs.
You must specify 'SYS:' for system programs. Examples:
'SYS:FORTRA', 'DSK:TEST.SAV[60,60]'.
KOUNT = (INPUT) Number of characters in the program name.
ICCL = (Optional INPUT) RUN-offset. If you leave a TMPCOR file for a
system program, ICCL must be 1 or else the program will not even
look for the TMPCOR file.
All files must be explicitly closed befor calling RUNUUO. Another
way to run a new program is by calling EXITGO. See the descriptions of
SAVRUN and EXITGO.
SUBTTL Calling sequence -- OUTSTR
OUTSTR outputs the buffer, with or without a <CR><LF> at the end.
This routine is not intended to replace FORTRAN formatted output, but
provides a simple way of typing character strings to the TTY.
CALL OUTSTR (ICRLF, BUFFER, KOUNT)
ICRLF = (INPUT) Carriage control. ICRLF=0 works like $ format.
-2 = Output a formfeed before BUFFER, but no CRLF after.
-1 = Output a formfeed before BUFFER, and a CRLF after.
0 = Do not output CRLF after BUFFER, used as a prompt.
1 = Output a CRLF after BUFFER, this is the normal case.
N = Output N CRLFs, creating N-1 blank lines after BUFFER.
BUFFER = (INPUT) Literal or array of characters to be output
KOUNT = (INPUT) Number of characters in BUFFER. If the characters to
be output are in a literal, KOUNT can be zero. Example:
CALL OUTSTR (0, 'What is your answer? ', 0)
SUBTTL Calling sequence -- SAVRUN
The primary function of SAVRUN is to look for a /RUN: command. It also
does general clean-up on the BUFFER.
CALL SAVRUN (IOPT, BUFFER, KOUNT, LENGTH, LASTC)
IOPT = (INPUT) Options. These may be added, ie, IOPT=2+4+8+16
0 or -1 = Do everything
1 = Act upon /RUN, /RUNOFFSET, /EXIT, or /HELP switches and start
reading an indirect file if the first character is "@".
2 = Remove comments which start with ";" or "!".
4 = Remove all control characters except tab.
8 = Remove leading spaces and/or tabs.
16 = Change tabs or multiple spaces to a single space.
32 = Convert lowercase to upper.
64 = Convert <> to [] (for APPLEs and 2741 terminals).
128 = Convert tabs to multiple spaces, if option 16 is not included.
BUFFER = (INPUT) The array of characters to be searched.
(OUTPUT) The cleaned-up array.
KOUNT = (INPUT) The number of characters to search.
(OUTPUT) The number of character left in BUFFER.
LENGTH = (INPUT) Number for the size of BUFFER in words.
LASTC = (INPUT) The last character in the BUFFER. If the user typed
Control-Z or if /EXIT was seen for IOPT=32, LASTC will be 26.
IF (LASTC.EQ.26) CALL EXITGO ! Time to exit
This routine will allow your FORTRAN programs to respond to commands
much like the system CUSPS. After SAVRUN gets done, the significant
characters in the BUFFER will be shifted to the left and all extra
characters removed. You can then check what's left and let your program
decide what to do. Note that you will not have to worry about checking
for lowercase or tabs since SAVRUN has converted these characters.
The /HELP switch can be abbreviated to /H. SAVRUN uses the name of
your program in finding help, which can be in your disk area or on HLP:.
The /RUN switch must be followed by the name of a program, such as
"/RUN:SYS:FORTRA". The device defaults to SYS: since that is the
behavior of the system CUSPS. The /RUN command is not executed
immediately, but sets LASTC to 26.
For all you RSTS/E users, you can call SAVRUN with "PUSHJ P,CVT$$".
Options 4, 8, 16, 32, and 64 work like RSTS, but trailing spaces are
always suppressed and characters in quotes are never changed.
If you want to output a message but without trailing blanks, use
option 4 to set KOUNT, the number of words to output is (KOUNT+4)/5.
KOUNT = LENGTH * 5 ! Set to max, scan entire BUFFER
CALL SAVRUN (4,BUFFER,KOUNT,LENGTH,LASTC) ! Throw away control chars
IWORDS = (KOUNT + 4) / 5 ! Get number of A5 words in message
TYPE 10,(BUFFER(I),I=1,IWORDS) ! Suppress all but last 4 spaces
SUBTTL Calling sequence -- JBINFO
JBINFO will return information about your job.
IVALUE = JBINFO(ICODE)
IVALUE = (OUTPUT) The information returned.
ICODE = (INPUT) The code for what piece of information to return.
"0 = 0 = The value in the KA or KI CPU console switches (0 for KL or KS)
"1 = 1 = Your job number
"2 = 2 = Your PPN (octal in both halves)
"3 = 3 = Name of your program (in SIXBIT)
"4 = 4 = The runtime accumulated (in ticks) since LOGIN
(Divide by 60.0 to get runtime in seconds)
"5 = 5 = The kilo-core ticks charged to your job
(Divide by 60.0 to get kilo-core seconds)
"6 = 6 = Your privilege bits (octal)
"7 = 7 = Causes your job to sleep for one second
"10 = 8 = Get line characteristics and number, ITTY=(JBINFO(8).AND."777)
"11 = 9 = The date as (((year-1964)*12 + month-1)*31 + day-1
"12 = 10 = Time of day, in integer milliseconds since midnight
"13 = 11 = Universal date/time, divide by 262144 to get days since 17-Nov-1858
"14 = 12 = The day of the week (Sunday=1, Saturday=7)
ICODE 13-18 return meaningless data from GETTAB tables.
"23 = 19 = Check typeahead, 0=none, 1=some characters, 2=complete line ready
"24 = 20 = Input a single character (for 'Y' or 'N' answer) in an A1 format
"25 = 21 = Input a single character, right justified in an R1 format (1-127)
"26 = 22 = Node number. At CSM, KL1091 = 1 and KS2020 = 2
"30 = 24 = Get first 5 letters of user name, in an A5 format
"31 = 25 = Get next 5 letters of user name
"32 = 26 = Get last 2 letters of user name and 3 blanks
Other codes match those for the GETTAB TOPS10 Monitor Call.
SUBTTL Calling sequence -- EXIT0, EXIT1, and EXITGO
All files must be explicitly closed before calling these routines.
CALL EXIT0
CALL EXIT1
CALL EXITGO
EXIT0 Returns to the monitor and types the message "EXIT". Cannot be
continued. The standard FORTRAN routine "CALL EXIT" is the one
that closed all files and types "END OF EXECUTION ...". EXIT0
is a little quieter. NOTE: RANDOM and BINARY output files must
be closed by CLOSE(UNIT=n).
EXIT1 Returns to the monitor by typing a dot. Can be continued. EXIT1
does not check for open files. If you type anything other than
".CONTINUE", any open files may be lost.
EXITGO Stops execution of the program. Returns to the monitor if there
is not another program to run. The program to run is set up by
SAVRUN if it receives a command like "/RUN:FORTRA". EXITGO will
complain if it finds any files open, and close them for you.
EXITGO is the suggested way of to stop your program.
SUBTTL Calling sequence -- HELPER
HELPER types the help file for your program.
CALL HELPER (0)
CALL HELPER (IARG)
IARG = (INPUT) Octal number representing the name in SIXBIT, or zero
to use the name of your program.
Ask a MACRO programmer if you need to know the translation of a
particular name. For example, 'DIRECT' is 445162454364 so you could use
CALL HELPER ("445162454364)
Usually you want to use zero. This means that if your program has been
saved as TEST01, HELPER will look for DSK:TEST01.HLP
SUBTTL Calling sequence -- MATCH
MATCH checks to see if the command typed in by the user matches a
list of commands. It accepts valid abbreviations to commands.
CALL MATCH ('LIST,OF,COMMANDS,ETC',BUFFER,KOUNT,LENGTH,INDEX)
GOTO (100, 200, 300, 400) INDEX
CALL MATCH ('ONE111,TWO222',BUFFER,KOUNT,LENGTH,INDEX,DNAME)
GOTO ( 1000, 2000) INDEX
LIST = (INPUT) A list of commands in quotes, separated by commas. The
commands can be up to 6 letters and numbers each, no spaces.
BUFFER = (INPUT) The array with the command, usually read in by INCHWL.
= (OUTPUT) The array with the command removed, if there is a match.
KOUNT = (INPUT) The number of characters in BUFFER.
= (OUTPUT) The number of characters left in BUFFER.
LENGTH = (INPUT) The size of BUFFER.
INDEX = (OUTPUT) Small positive number if a match was found.
DNAME = (optional OUTPUT) The matched command is stored in this
DOUBLE PRECISION variable in an (A6) format.
If INDEX is returned as +1, it means that the command matched the 1st
one on the list, +2 for the second, etc. DNAME gets the full command,
even if it was abbreviated in the BUFFER.
INDEX= 0 means that BUFFER is all blanks.
INDEX=-1 means that the command in BUFFER does not match any on the list.
INDEX=-2 means that the command is ambiguous.
The MATCH routine always removes any leading spaces or tabs from BUFFER.
If a match was found, the command and the first space or tab is removed from
BUFFER. This is so that MATCH can be called with a second list to decode
any sub-commands.
SUBTTL Calling sequence -- Examples
CC This shows how to use SAVRUN
100 CALL INCHWL ('*', BUFFER, KOUNT, LENGHT, LASTC) ! Get command
CALL SAVRUN (-1, BUFFER, KOUNT, LENGTH, LASTC) ! Look at it
CALL MYPROG (BUFFER) ! Do your processing
IF (LASTC.EQ.26) CALL EXITGO ! Stop if we should
GOTO 100 ! Else loop
END
---------------------------------------------------------------------
CC This shows a complete program using the RUNLIB routines
CC This program understands only "STOP" and "CHAIN" (and /EXIT/HELP/RUN)
DIMENSION BUFFER(27) !135 characters
LENGTH=27 !Size of buffer in words
CCLNAM='ABC' !Prompt and name of file
CALL RESCAN (CCLNAM, BUFFER, KOUNT, LENGTH, LASTC) !Fill buffer
IF (KOUNT .GT. 0) GOTO 110 !Skip INCHWL if have command
100 CALL INCHWL (CCLNAM, BUFFER, KOUNT, LENGTH, LASTC) !Get another command
CC Here with a command, process it
110 CALL SAVRUN (-1, BUFFER, KOUNT, LENGTH, LASTC)
LEN = (KOUNT + 4) / 5 !Round up to next full word
TYPE 120, (BUFFER(JJ), JJ=1,LEN) !No trailing spaces
120 FORMAT (' You typed: ', 27A5)
CALL MATCH ('CHAIN,STOP',BUFFER,KOUNT,LENGTH,INDEX,DNAME)
IF (INDEX.GT.0) TYPE 130, DNAME
130 FORMAT (' The command was ', A6)
GOTO ( 200, 300 ) INDEX !Go of INDEX=1 or 2
IF (LASTC.EQ.26) CALL EXITGO !Stop on Control-Z or /EXIT
GOTO 100 !Loop until done
CC Here if we get a "CHAIN" command
200 CALL RUNUUO (IERR, BUFFER, KOUNT) !Run next program
TYPE 210, IERR, (BUFFER(JJ), JJ=1, LEN) !Type error message
210 FORMAT (' ?Error code ', O2, 3X, 27A5)
CALL EXIT0 !Return to the monitor, never to continue
CC Here if we get a "STOP" command
300 CALL EXITGO !Give /RUN a chance
END
SUBTTL Calling sequence -- Writing a FORTRAN program that compiles itself
PROGRAM TESTER
CC To run this program, do the following:
CC .COPY = FOR:TESTER.REL, F.FOR, RUNLIB.REL
CC .EXECUTE TESTER.REL, F.FOR, RUNLIB.REL
CC If you type in an illegal function, you must start over by:
CC .COPY = FOR:F.FOR
CC .EXECUTE
DIMENSION BUFFER(27) !135 characters
LENGTH=27 !Size of BUFFER
CALL RESCAN ('TST', BUFFER, KOUNT, -LENGTH, LASTC) !Check for F(X)
IF (KOUNT .GE. 0) GOTO 2000 !If first time thru
IWORDS = (KOUNT + 4) / 5 !Number of words
1000 TYPE 1010, (BUFFER(I), I=1,IWORDS) !Type the function
1010 FORMAT ('0The function is F(X) = ', 27A5)
TYPE 1015 !Ask for values
1015 FORMAT ('0What are XMIN, XMAX, and XINC? ',$)
ACCEPT 1020, XMIN, XMAX, XINC !Get parameters
1020 FORMAT (3G)
IF (XINC .EQ. 0.0) XINC = 1.0 !Default increment
TYPE 1030, (BUFFER(I), I=1,IWORDS) !Print heading
1030 FORMAT ('0 X', 14X, 27A5)
DO 1040 XX = XMIN, XMAX, XINC !Set up loop
X = XX !Prevents "Possible modification of index in loop"
Y = F(X) !Evaluate function
1040 TYPE 1020, X, Y !Show the values
CALL OUTSTR (0,Do you want more values? ',0)
IANS = JBINFO(20) ! Get single letter ans
IF (IANS .EQ. 'Y' .OR. IANS .EQ. 'y') GOTO 1000 !Lowercase too
CALL OUTSTR (0,' Do you want to try another function? ',0)
IANS = JBINFO(20) !Get answer
IF (IANS .EQ. 'Y' .OR. IANS .EQ. 'y') GOTO 2000 !Lowercase too
CALL EXITGO !Return to monitor
Continued on next page
Compiler program continued
CC Here to get a new function
CC Note that this section does not use any FORTRAN I/O to the TTY
2000 CALL OUTSTR (0, 'Type in the function; F(X) = ', 0) !Give prompt
CALL INCHWL (' ', BUFFER, KOUNT, LENGTH, LASTC) !Get reply
CALL SAVRUN (-1,BUFFER, KOUNT, LENGTH, LASTC) !Clean it up
IF (KOUNT .LE. 0) GOTO 2000 !Ask again
IF (LASCT.EQ.26) CALL EXITGO !Stop if /EXIT
IWORDS = (KOUNT + 4) / 5 !Number of words
OPEN (UNIT=1, DEVICE='DSK', FILE='F.FOR', ACCESS='SEQOUT')
WRITE (1,2010) (BUFFER(I), I=1,IWORDS) !Write the function
2010 FORMAT (' FUNCTION F(X)', /, ' F = ', 27A5)
WRITE (1,2030) !Finish it up
2030 FORMAT (' RETURN', /, ' END')
CLOSE (UNIT=1) !Finish the file
CALL TMPCOR ('TST', BUFFER, KOUNT) !Remember the function
CALL TMPCOR ('LNK', 'TESTER,F,RUNLIB/E/G', 19) !Message for LINK
CALL TMPCOR ('FOR', 'F=F/RUN:LINK/RUNOFF', 19) !Message for FORTRA
CALL RUNUUO (IERR, 'SYS:FORTRA', 10, 1) !Run the compiler
STOP '?Cannot run SYS:FORTRA'
END !Of TESTER
SUBTTL Appendix - Calling RUNLIB from MACRO programs
These routines preserve all accumulators.
Most routines have alternate entry names, so that MACRO programs can
avoid using names of monitor calls when referring to subroutines. The
alternate names start with a dollar-sign and have the first five
characters of the FORTRAN entry names. For instance, "$INCHW" is the
alternate name for "INCHWL" - a subroutine which does TTCALL's and more.
The MACRO calling sequences are:
L=16 ;Link to arg list
P=17 ;Push-down-list pointer
MOVEI L,TMPARG ;Args for TMPCOR
PUSHJ P,$TMPCO ;Call TMPCOR
MOVEI L,RUNARG ;Args for RUNUUO
PUSHJ P,$RUNUU ;Call RUNUUO
MOVEI L,CMDARG ;Args for RESCAN
PUSHJ P,$RESCA ;Call RESCAN
MOVEI L,CMDARG ;Same args for INCHWL
PUSHJ P,$INCHW ;Call INCHWL
MOVEI L,SAVARG ;Args for SAVRUN
PUSHJ P,$SAVRU ;Call SAVRUN (also known as CVT$$)
PUSHJ P,EXITGO ;No args for EXITGO
PUSHJ P,EXIT0 ;No args for EXIT0
PUSHJ P,EXIT1 ;No args for EXIT1
MOVE 1,[SIXBIT /NAME/] ;Put name in AC1
PUSHJ P,.HELPR ;Call HELPER
MOVEI L,OUTARG ;Args for OUTSTR
PUSHJ P,$OUTST ;Call OUTSTR
MOVEI L,MATARG ;Args for MATCH
PUSHJ P,$MATCH ;Call MATCH
;Example of argument blocks for MACRO routines
-3,,0 ;3 args for TMPCOR
TMPARG: NAME ;Addr of name of TMP file
BUFFER ;Starting addr of array for buffer
KOUNT ;Addr of integer for count
-3,,0 ;Or -4,,0 ;3 or 4 args for RUNUUO
RUNARG: IERR ;Addr to put error code
PRGNAM ;Start of program name in ASCII
KOUNT1 ;Addr of number of chars in PRGNAM
ICCL ;Optional addr of the run offset
-5,,0 ;5 args for RESCAN and INCHWL
CMDARG: NAME ;Addr of prompt text
BUFFER ;Start addr of array
KOUNT ;Addr of integer
LENGTH ;Addr of word containing size of BUFFER
LASTC ;Addr to store last character
-5,,0 ;5 args for SAVRUN
SAVARG: FLAG ;Addr of flag, bit 0 gets set (negative=.TRUE.)
BUFFER ;Starting addr of array
KOUNT ;Addr of integer, count of characters
LENGTH ;Addr of word containing size of BUFFER
LASTC ;Addr to store last character
-3,,0 ;3 args for OUTSTR
OUTARG: ICC ;Addr of carriage control
BUFFER ;Starting addr of array
KOUNT ;Addr of number of chars
-6,,0 ;6 args for MATCH (the last 1 is optional)
MATARG: [ASCIZ /LIST,OF,COMMANDS,SEPARATED,BY,COMMAS/]
BUFFER ;Array with command to be processed
KOUNT ;Addr of integer
LENGTH ;Addr of word containing size of BUFFER
INDEX ;Addr of integer for match
DNAME ;(optional) Addr of double-precision variable
NAME: ASCII /ABC / ;Prompt or name of TMP file
BUFFER: BLOCK BUFSIZ ;Array
KOUNT: BLOCK 1 ;Integer character count
LENGTH: BUFSIZ ;Word containing size of BUFFER
LASTC: BLOCK 1 ;Integer for last char, right justified
FLAG: -1 ;-1 to do everything
PRGNAM: ASCII /DSKB:TESTER.EXE[10,10]/ ;Name of program in ASCII
KOUNT1: ^D22 ;Number of characters in PRGNAM
IERR: BLOCK 1 ;Gets error code if RUNUUO fails
ICC: 0 ;0 for CRLF, -1 to suppress CRLF
ICCL: 1 ;Run-offset, 0 or 1
INDEX: BLOCK 1 ;Number denoting match
DNAME: BLOCK 2 ;Command name stored in A6 format
[End of RUNLIB.DOC]