CVLLIB Fortran Interface Manual Release 3D (Manual Edit Ref 3-0/I) 30-May-85 C G Wilson 71 Galatea St, Charleville 4470 Australia CVLLIB is a (personal) general-purpose library for the RT-11 Macro, Fortran or C programmer. Routines cover facilities such as reading and writing decimal (up to triple precision) and octal (up to double precision) and hexadecimal (up to double precision) integers, money format (double or triple precision), dates and times, filenames and Radix50 formats. Multiple-precision arithmetic routines are included, none of which requires an EIS or FIS. This manual provides the details of the interfaces and programmes designed to allow use of CVLLIB from Fortran programmes. CVLLIB Manual - Fortran Section Page 2 With many thanks to Dan McCracken though he hasn't a clue why. CVLLIB Manual - Fortran Section Page 3 Table of Contents Table of Contents ----------------- a) Update History 1. GENERAL DETAILS Nomenclature General Argument Patterns Writing to a string Reading Generally Flag values Hexadecimal Conventions Fortran I/O Facility 2. SPECIAL BLOCK FORMATS DATE block CALEND Common Block TIME Block FILENAME block Terminal I/O 3. Date 4. Time 5. Filename & Radix50 6. Triple Precision Money 7. Triple Precision Integer I/O 8. Triple Precision Arithmetic 9. Double Precision Money 10. Double Precision Integer I/O Writing Double-Precision Reading Double-Precision 11. Double Precision Arithmetic 12. Single Precision Integer I/O Writing Single-Precision Integers Reading Single-Precision Integers 13. String Comparison Routines 14. Various Additional Routines Size Conversion Additional Utilities etc 15. Ancillary Subroutines Appendix I - Index CHAPTER 1 Update History 3-0/I: [30-May-85] Bug fixes to LSCG, LSGX, LSCGV & LSCGX routines, whereby they died on 11/73 processors. CHAPTER 2 General Details 2.1 Nomenclature: There has been an attempt made to get all the programmes in CVLLIB to have names consistent with their purposes. Due to the restriction to six characters this has not always been possible, but here are the ideas behind it. Routines which write have names starting with "W" (eg WD writes a decimal number), and those which read have names beginning with "R" (eg RDAT reads a date). Conversion routines begin with "C" (eg C50A converts radix50 to ascii). Numeric routines are either decimal (D) or octal (8), and this may be followed by a number indicating the precision (eg RD3 reads a triple precision decimal number, and W8 writes a single precision octal number). Real (floating-point, 2-word precision) routines use the letter "R" - eg RR reads a real, and WRFT writes a real number in F format (a la FORTRAN) to the user's terminal. The suffix "T" indicates I/O involving the user's terminal. Without this, I/O involves a string (in Macro, pointed to in R1; in Fortran, provided as an argument). The suffix "P" indicates that a minimum number of positions may be specified as an argument, thereby writing a number right-justified in a fixed-length field. Thus WD2PT writes a double precision decimal number in a fixed number of places to the user's terminal. In octal I/O and single & double precision decimal reading, an additional suffix "S" indicates that the number may be signed. (Triple precision numbers may always be signed, and any decimal number on being written will have a "-" sign if negative). Thus R82ST will read a double precision signed octal integer from the user's terminal. The money format is $ddd.cc, with the number stored as an integral number of cents. The numbers used may be double or triple precision integers. Thus RM3 will read a triple precision sum of money from the CVLLIB Manual - Fortran Section Page 2-2 General Details string pointed to in R1, and WMDT will write a double precision integer in money format with a leading floating dollar sign (the "D") to the user's terminal. The "P" suffix is available in money routines. Money routines are either double or triple precision - THERE ARE NO SINGLE PRECISION MONEY ROUTINES. Fortran-callable interfaces for nearly all the routines are included in this library. To determine the Fortran-callable routine, prefix the name of the desired routine with an "L". WFT writes a filename to the terminal; LWFT is the subroutine called from Fortran to do the same job. Routines already having 6-letter names are a problem (eg W82SPT becomes LW82SX, and CRDATW {converts RT-11 date format to words} becomes LCRDW). Note also that the Macro Radix50 reading routines read up to 3 characters, whereas their Fortran equivalents read up to 6. The exceptions to the above rule are the real (floating-point) functions which return a real value. These have names beginning with "R". Specifically, these functions are RFRAC, RFLT1, and RFLT2. The choosing of the prefix "L" came about after originally the prefix "F" was used. This caused so many hassles remembering to declare routines which returned values as INTEGER, that the change in convention to an implicitly integer series of names was instituted. CVLLIB Manual - Fortran Section Page 2-3 General Details 2.2 General Argument Patterns: Throughout this manual, the following names for arguments have these meanings: a single-word integer value <2.value> a double-word integer value, with the high-order bits in the first word (lower address). This is the opposite way round from the SYSLIB INTEGER*4 support functions, but the same way round as the RT11 Timer functions. <3.value> a triple-word integer value with the highest order bits in the first word through to the lowest order bits in the last word. As there is no 3-word declaration in RT11 Fortran, these will have to be programmed either as arrays of single precision integers or as 4 word (eg REAL*8) allocations. Any number suffixed to any of the above (eg <2.value-2> is used to differentiate between different arguments of the same type in describing their purpose for that particular subroutine or function. the locations into which or from which data will be written or read. (Not used in routines doing direct terminal I/O). The string should be terminated by a null (=0) character rather than any control characters (eg carriage-return or line-feed). will usually be specified as a BYTE or LOGICAL*1 array. is an integer which is increased by the number of bytes read from or written to by any Fortran routine which uses the . Thus after using a routine which writes into , if originally contained 1 and now contains 10, 9 characters (excluding the terminating null provided by routines which write to the ) were added to the . STRING(10) will contain the terminating null, and will be the next byte available for writing into to continue that line of information. For example, if STRING (a byte array) contain "FILE FRED.DAT/RHUBARB" and the routine to read a filename from a string is called as follows: LAST=6 I=LRF(IFILE,STRING(6),LAST) the filename FRED.DAT will be read into the IFILE array (as the start of the string to be decoded was the sixth CVLLIB Manual - Fortran Section Page 2-4 General Details character in the STRING array), and LAST will return containing a value 14. Eight characters were read from STRING, and STRING(LAST) now points to the delimiting character, the slash. Thus successive reads from the one input line may be handled by initially setting LAST to 1, and using the returned value from each routine for the call to the succeeding routine. refers to a 1-byte location which receives the character which delimited input on a read from the user's terminal. This can be used to check validity of the user's type-in. For example if a user typed "39" as input to CALL LR8T(value,char), would receive the number 3, and would receive the character "9", whereas had he typed "37", would receive 37 and would receive the terminating null (=0). 2.3 Writing to a string: When information (eg numbers) is written to a string (using a argument from Fortran), the characters are written into that string sequentially with no check as to the available length of that string. Fortran routines clear the terminating byte, and provide a pointer to it using . 2.4 Reading Generally: Routines which read ignore leading spaces and tabs, except for routines which read Radix50 values. 2.5 Flag values Many routines require minor information to be provided in the form of a word. Some routines provide the ability to include or exclude spaces either preceding or embedded within output fields. Including these spaces allows columns of information to be accurately lined up no matter what the content of the information; excluding the spaces makes for tidier formatting on a one-off basis (for example dates, times, and filenames). The sign bit of the argument is used to control spaces; other bits will be routine dependent. If the sign bit be clear, no leading or embedded spaces will be included. If it is set (ie the value is negative) they will be included as relevant. CVLLIB Manual - Fortran Section Page 2-5 General Details 2.6 Hexadecimal Conventions: Various systems use various conventions to define a hexadecimal number. Some use merely the digit string, some use a prefix character (for example a "0" or a colon), and some use a suffix (for example an "X" or an "H"). In a vain attempt to provide all things for all men, CVLLIB provides the option for a prefix &/or a suffix character for hexadecimal numbers. The default is a "0" (digit zero) prefix character, and no suffix character. To alter either, define it in a common block as follows: COMMON/HEXPRE/HEXPRE INTEGER HEXPRE DATA HEXPRE /0/ COMMON/HEXSUF/HEXSUF INTEGER HEXSUF DATA HEXSUF /'H'/ will lead to no hex prefix character (HEXPRE=0), and an "H" hex suffix. On hexadecimal output the hex prefix character (if defined) will prefix any hex number written, and the hex suffix character (if defined) will follow any number. [All hex output is unsigned.] On reading a hex number using the specific hex reading routines (LRH2T, LRH2, LRHT, and LRH) any prefix or suffix characters will be ignored. On reading a number using the generic number reading routines (LRN2T, LRN2, LRNT, and LRN) any prefix or suffix character will be taken to mean that the particular digit string constitutes a hexadecimal number, and the relevant hex reading routine will be used. If either the prefix or suffix character be alphabetic, either upper or lower case will be accepted on reading a hex number. If either prefix or suffix character be alphabetic, on reading the number either case will be acceptable. 2.7 Fortran I/O Facility: N12FIL I=N12FIL(inflag,outflag,defext,'Version') Allows setting up an input and an output file within Fortran with the standard CSI format (*outfile=infile), setting up the input file on Fortran logical unit 1 and the output file on unit 2. The and tell the user whether or not the relevant file was specified in the user's type-in. Before returning, checking is performed for the existence of the input file and the possibility of writing the CVLLIB Manual - Fortran Section Page 2-6 General Details output file. If reading and writing the specified files is impossible, the user is told and asked for another specification. There is no switch handling by this routine. CHAPTER 3 Special Block Formats 3.1 DATE block DATE routines require a 5-word block (referred to as a "dateblock") in the following format: 1st word DAY eg 31 for 31-Mar-81 2nd word MONTH eg 3 for 31-Mar-81 3rd word YEAR eg 81, or 1981 4th word DYEAR day of year - eg 90 for 31-Mar-81 5th word RTDAT date in RT-11 format - ie sign bit 0 next 5 bits - month next 5 bits - day last 5 bits - year-1972 eg 7751 (octal) for 31-Mar-81. Various routines place relevant values in these locations, use values from them, or convert values between locations within the block. For convenience, a 5-word block is provided in this library. The first location is the global DATBLK, and the locations are sequentially named globally DAY ... RTDAT. They are in a Psect DATBLK (with characteristics RW, D, GBL, REL, OVR) so that they may be accessible via the Fortran COMMON block: INTEGER DAY,MONTH,YEAR,DYEAR,RTDAT COMMON /DATBLK/ DAY,MONTH,YEAR,DYEAR,RTDAT 3.1.1 CALEND Common Block A Fortran COMMON block, /CALEND/, containing calendar information, is defined in RDAT and IDAY. It contains 3-letter versions of names of days of the week and months, the number of days in each month, and a series of offsets for calculating day of week dependent upon month. It CVLLIB Manual - Fortran Section Page 3-2 Special Block Formats should be noted that the number of days in the month of February is altered on a call to IDAY such that it will be correct for the particular year passed in the argument to IDAY in that call. This common block has the form: REAL DAYNAM,MONNAM BYTE MONTHS,MOFSET COMMON/CALEND/DAYNAM(7),MONNAM(12),MONTHS(12),MOFSET(12) and is initialized as follows: DAYNAM: .ASCII /Sun Mon Tue Wed Thu Fri Sat / MONNAM: .ASCII /Jan Feb Mar Apr May Jun / .ASCII /Jul Aug Sep Oct Nov Dec / MONTHS: .BYTE 31.,28.,31.,30.,31.,30. .BYTE 31.,31.,30.,31.,30.,31. MOFSET: .BYTE 0,3,3,6,1,4,6,2,5,0,3,5 3.2 TIME Block TIME routines require a 7-word block (referred to as a "timeblock") in the following format: 1st word HOURS hours (in 24-hour format) 2nd word MINS minutes 3rd word SECS seconds 4th word TICKS clock ticks 5th word RTIM1 two words containing RT-11 6th word RTIM2 double-precision time, high order word first, in clock ticks since the previous midnight. 7th word TCLOCK number of clock ticks per second (set by the user, or by the LRSTIM routine; used for time conversions. Various routines place relevant values in these locations, use values from them, or convert values between locations within the block. For convenience, a 7-word block is provided in this library. The first location is the global TIMBLK, and the locations are sequentially named globally HOURS, MINS, ... , TCLOCK. They are in a Psect TIMBLK (characteristics RW, D, GBL, REL, OVR) so that if desired they may be accessed also as the Fortran COMMON block: INTEGER HOURS,MINS,SECS,TICKS,RTIM1,RTIM2,TCLOCK COMMON /TIMBLK/ HOURS,MINS,SECS,TICKS,RTIM1,RTIM2,TCLOCK CVLLIB Manual - Fortran Section Page 3-3 Special Block Formats 3.3 FILENAME block: Routines concerning filenames require a 4 or 5 word block (referred to as a "fileblock") in the following format: 1st word DEVICE device name 2nd word FILE1 first 3 chars of filename 3rd word FILE2 last 3 chars of filename 4th word EXT extension (file type) (First 4 words in Radix50 format) 5th word SIZE file size (integer) - optional on routines which write filenames - an integral number of 256-word blocks. No equivalent block is provided in this library - the user is expected to provide his own! 3.4 Terminal I/O Routines which appear to do direct terminal I/O (eg LRMT - Read money value from the terminal) actually operate by using a temporary buffer (TLINB for input, and TLOUB for output), and the equivalent string interpreting or writing routine. In this library a routine TLINB is defined as a 90 (decimal) character block, and TLOUB a 140 (decimal) character block - sufficient for a full 132-column printer line. Should these be excessive or insufficient for your purpose, either use your own buffer and don't use the direct terminal I/O routines, or define TLINB and/or TLOUB in your own programme - for example: COMMON/TLINB/ILINE BYTE ILINE(40) COMMON/TLOUB/LINE BYTE LINE(400) Note that routines which read from the terminal and routines which write to the terminal now use different buffers (change from Release 2 to Release 3). Routines which read from the terminal normally do so using the .TTYIN programmed request. This means that they will NOT take input from command files. Should this be desired, either use your own .GTLIN request (or, in Fortran, CALL GTLIN - see system subroutine library), or when linking use the /INCLUDE switch to force loading the global "R$G". With this, all teletype input requests (including TLIN, with Release 3) _________ will use .GTLIN requests and track command files. CHAPTER 4 Date Routines On output, Date format is the unambiguous dd-Mmm-yy. If the day value be less than 10 a space may precede the date. A flag may be passed to date writing routines to suppress this space. On input, there are three acceptable formats for the date. The form specifying the month in alphabetic characters (eg 3-Feb-82) will always be recognized, and either the British numeric month pattern (3/2/82, dd/mm/yy) or the American (2/3/82, mm/dd/yy) may be recognized additionally if desired. A flag passed to the date reading routine should be zero if only the alphabetic form of the month is to be recognized (recommended for programmes handed around internationally), positive if the British form is allowed, and negative if the American form is desired. The fields may be delimited by any character with an ascii value less than the character "0" - eg space, tab, comma, or slash. Spaces are permitted on either side of the delimiting character. The month field may be numeric (see above), or may be alpha. If alpha, only the first three letters are checked for validity, the remainder being ignored (thus 14-Dec-76 is exactly the same as 14.decadent.76). Letters may be either upper or lower case. The delimiter for the month may be any of the ones mentioned for the day. The year follows, as an integer. Many of the date routines can cope with the year either as the full four-digit value (eg 1981) or the truncated form (81), but the latter is assumed to be always modulo 1900 (ie 98 is 1998, not 1898). At least one digit must be specified for the year (note difference from general numeric read routines which will return zero on the first non-numeric character even if that were the first character encountered). If the value to Date writing routines be zero, any leading space will be suppressed. If negative, there may be a leading space. 4.1 Date Routines: For details of , see chapter 1. CVLLIB Manual - Fortran Section Page 4-2 Date Routines LTODAT I = LTODAT(dateblock) Types today's day and date to the terminal. Returns 0 if all OK, -1 if system date not set up. The receives system date information. LTODAY I = LTODAY(dateblock,string,last) Types today's day and date to . Returns 0 if all OK, -1 if system date not set up. The receives system date information. LWDAYT CALL LWDAY(value) Types name of day to terminal. should be from 1 to 7 for Sunday to Saturday. Values outside this range will provide the name "Illegal". LWDAY CALL LWDAY(value,string,last) Types name of day to . should be as per LWDAYT. LWSDTT I = LWSDTT(dateblock,flag) Writes system date to terminal, returning relevant values in . Returns 0 if all OK, -1 if system date not set up. LWSDAT I = LWSDAT(dateblock,string,last,flag) Writes system date to , returning relevant values in . Returns 0 if all OK, -1 if system date not set up. LWDATT CALL LWDATT(dateblock,flag) Writes date from to terminal. No validity checking is done, illegal months producing the name "XXX". LWDAT CALL LWDAT(dateblock,string,last,flag) Writes date from to . No validity checking is done, illegal months producing the name "XXX". LRSDAT I = LRSDAT(dateblock) Reads system date information into . This is read in RT11 format into the RTDAT offset in , and if non-zero (ie a date has been entered on the system) conversion of this date into the relevant offsets DAY, MONTH, and YEAR is performed. 0 is returned if all is well, and -1 if no system date has been set up. CVLLIB Manual - Fortran Section Page 4-3 Date Routines LRDATT I = LRDATT(dateblock,char,flag) Reads a date from the terminal into the relevant offsets in . Any of the date formats mentioned at the top of this section are valid. Perform relevant conversions to set up the RTDAT and DYEAR offsets within , and returns the value 1-7 (Sunday to Saturday) for the day of the week corresponding to that date. On an error -1 is returned. This routine only works on dates after 1600. For details of see the top of this chapter. (0=alpha month only; 1=British dd.mm.yy; -1=American mm.dd.yy). LRDAT I = LRDAT(dateblock,string,last,flag) Reads a date from as per LRDATT. LDTDIF I = LDTDIF(dateblock-1,dateblock-2,2.value) Calculate the difference in days between 2 dates, starting from up to . The value is a double precision integer returned in <2.value>. The function returns 0 normally, and -1 should an error be detected in one of the dates, or one of the dates be earlier than 1600. (For example, the difference between 31-Dec-80 and 1-Jan-81 will be 1 day, and if reversed in order will be -1 days.) LDTCAL I = LDTCAL(dateblock) Calculates the date using the YEAR and DYEAR (day of year) information provided in the . The DYEAR information may be positive or negative, and may extend across several year boundaries. Note that 1-Jan is day 1 of a year, so day 0 is 31-Dec of the previous year. The function returns 0 unless calculations take the date back before 1600, when -1 will be returned. LAGE I=LAGE(dateblock-1,dateblock-2,iyears,months) Takes date of birth in and the date on which the age is to be calculated in and calculates age in years (returned in ) and months (returned in ). The value returned from this function (I) is 0 if all was well, and -1 if the date of birth is after the date for calculation (ie not born yet!). LIDAY I = LIDAY(dateblock) Checks the validity of a date in , setting up the DYEAR and RTDAT offsets (year field zero if outside RT-11 range), and returning the value 1-7 (Sunday - Saturday) for the day of the week corresponding to that date. On an error -1 is returned. This routine only works on dates after 1600. CVLLIB Manual - Fortran Section Page 4-4 Date Routines LCRDW CALL LCRDW(dateblock) Convert RT-11 date in RTDAT offset in to words in DAY, MONTH, and YEAR offsets in the same . No validity checking is performed. LCWDR CALL LCWDR(dateblock) Convert date in day, month and year offsets in to RT-11 date format in the RTDAT offset in the same . No validity checking is performed, except that years outside the RT-11 range return with a zero year field (= 1972). validity checking is performed, except that years outside the RT-11 range return with a zero year field (= 1972). CHAPTER 5 Time Routines The RT-11 format for time is a two-word integer using the same format as the other two-word routines in this library - having the highest order bits in the first (lowest address) word, and the low order bits in the second word. (This is the opposite to the INTEGER*4 support offered in SYSLIB.) The format is described in an earlier chapter of this manual. Routines which write time values require a argument. If the low-order byte of be zero, the hours and minutes only are typed (hh:mm). If non-zero, the seconds are also typed (hh:mm:ss). [There are no routines for typing fractions of a second in this library.] If the sign bit of is not set, no leading space will precede the HOURS value, even if that value is less than 10. If the sign bit is set, a space will precede the HOURS value if its value is less than 10. (Minute and second fields always have 2 digits, even if the first be a leading zero.) Routines which read time expect a series of decimal numbers, taken in sequence as hours, minutes, seconds, and clock ticks. Unused fields will be taken to be zero. Any non-alphanumeric character may be used as the delimiter. AM or PM may be suffixed to the last field, but the hours returned will always be in 24-hour format. (The "M" in AM or PM is optional. Upper or lower case may be used.) An addition in Release 3 permits time to be specified using a single number (eg "1230" for 12:30). If the number first found be greater than or equal to 100 this format is assumed. Seconds and ticks will be taken as zero, and only the first number (if more be typed) will be read. 5.1 Time Routines: For details of , see chapter 1. LWSTMT CALL LWSTMT(timeblock,flag) Writes the present time from the system to the user's terminal, returning relevant values in offsets. The TCLOCK offset is set by this routine to the number of CVLLIB Manual - Fortran Section Page 5-2 Time Routines clock ticks per second on the system being used. LWSTIM CALL LWSTIM (timeblock,string,last,flag) Writes present time from the system to , as per LWSTMT. LWTIMT CALL LWTIMT(timeblock,flag) Writes the time from the offsets HOURS, MINS, (and, depending upon , SECS) to the user's terminal. LWTIM CALL LWTIM(timeblock,string,last,flag) Writes the time from the offsets to , as per LWTIMT. LRSTIM CALL LRSTIM(timeblock) Reads the current time from the system, at the same time setting up the TCLOCK offset within the to the relevant value (50 or 60) for the system clock. The time is converted into HOURS, MINS, SECS, and TICKS each in its relevant offset within , as well as remaining in RT11 time format in the RTIM1 and RTIM2 offsets. LRTIMT I = LRTIMT(timeblock,char) Reads a time value (in any of the forms mentioned at the head of this chapter) into the offsets HOURS, MINS, SECS, and TICKS. No conversion to RT-11 time format is done - an explicit call to LCWTR (v.i.) must be made for this. The value returned from this function is 0 if all went well, and -1 if there were an error in the time specification. LRTIM I = LRTIM(timeblock,string,last) Reads a time value and returns 0 or -1 as per LRTIMT, but from . LCRTW CALL LCRTW(timeblock) Converts RT-11 time format in offsets RTIM1 and RTIM2 using the ticks per second value supplied in the TCLOCK offset of the same into hours, minutes, seconds and clock ticks in their relevant offsets. No error checking is done. CVLLIB Manual - Fortran Section Page 5-3 Time Routines LCWTR CALL LCWTR(timeblock) Converts hours, minutes, seconds and ticks from their relevant offsets into RT-11 time format in the RTIM1 and RTIM2 offsets of the same . The conversion factor used is the number of clock ticks per second as provided by the user in the TCLOCK offset of the same . CHAPTER 6 Filename & Radix50 Formats Routines which handle filenames require a "fileblock" of 4 or 5 words as described in the chapter on Special Block Formats earlier in this manual. This block contains or receives details of a file - the device, filename, and extension (file type) in Radix50 format, and (optionally for writing) the file size as an integral number of blocks, each block being 512 characters long. Routines which write filenames require a to determine output format. If the sign bit of be set, spaces in the device, filename, and extension subfields will be left in the final result. If not set, trailing spaces will be suppressed from each subfield. [Thus =neg "DK: FRED .C " vs =pos "DK:FRED.C"] If the low order byte in be non-zero, the file size will be output. If zero, no size will be appended to the filename. In Radix50 output, the unassigned Radix50 code is encoded as "*", and on input the "*" sign is converted into that unassigned code. In filename format output, the "." character will be converted to the wildcard "%" character, as per CSI filename conversions. Macro routines which read Radix50 codes read up to three characters. Their Fortran equivalents read up to six characters into a double precision argument. 6.1 Filenames & Radix50 Routines: For details of , see chapter 1. LWFT CALL LWFT(fileblock,flag) Writes the filename from to the user's terminal according to as described at the start of this chapter. CVLLIB Manual - Fortran Section Page 6-2 Filename & Radix50 Formats LWF CALL LWF(fileblock,string,last,flag) Writes the filename from to the according to as described at the start of this chapter. LRFDT I = LRFDT(fileblock,char) Reads a filename from the user's terminal into the relevant locations in , allowing the user to set up defaults for the device and extension fields in the . These fields will not be changed unless the filename as typed by the user explicitly specifies these fields. A value of 0 returned from this function means all has gone well; a value of -1 signifies an error (of syntax) was detected in the filename specification. LRFD I = LRFD(fileblock,string,last) Reads a filename from , otherwise as per LRFDT above. LRFT I = LRFT(fileblock,char) Reads a filename from the user's terminal into the relevant locations in , returning nulls for unspecified fields. A value of -1 returned from this function means an error was detected in the filename; 0 is returned normally. LRF I = LRF(fileblock,string,last) Reads a filename from into the relevant locations in , else as per LRFT above. LW50FT CALL LW50FT(value) Writes as 3 Radix50 characters to the user's terminal. The unassigned Radix50 code is translated to a "*" sign, and the "." character is converted to the wildcard "%". LW50T CALL LW50T(value) Writes as 3 Radix50 characters to the user's terminal. The unassigned Radix50 code is translated to a "*" sign. LW50F CALL LW50F(value,string) Writes as 3 Radix50 characters to . 3 characters are always written. The unassigned Radix50 code is translated to a "*" sign, and the "." is converted to the wildcard "%". CVLLIB Manual - Fortran Section Page 6-3 Filename & Radix50 Formats LW50 CALL LW50(value,string) Writes as 3 Radix50 characters to . 3 characters are always written. The unassigned Radix50 code is translated to a "*" sign. LR50ST CALL LR50ST(2.value,char) Reads up to 6 Radix50 characters from the user's terminal into <2.value>, restricting input to the "symbol set" - ie full-stop is a legal character, but space is a delimiter. The "%" sign is translated into the unassigned Radix50 code. LR50FT CALL LR50FT(2.value,char) Reads up to 6 Radix50 characters from the user's terminal into <2.value>, restricting input to the "filename set" - ie both full stop and space are delimiters. The "%" sign is translated into the unassigned Radix50 code. LR50T CALL LR50T(2.value,char) Reads up to 6 Radix50 characters (including space and full stop) from the user's terminal into <2.value>. The "%" sign is translated into the unassigned Radix50 code. LR50S CALL LR50S(2.value,string,last) As per LR50ST, but reads from . LR50F CALL LR50F(2.value,string,last) As per LR50FT, but reads from . LR50 CALL LR50(2.value,string,last) As per LR50T, but reads from . LCA50 I = LCA50(ascii-character) Converts the Ascii character to its Radix50 equivalent, returning -1 should there be no equivalent. LC50A I = LC50A(rad50-character) Converts the Radix50 character to its Ascii equivalent, returning -1 should there be no equivalent. CVLLIB Manual - Fortran Section Page 6-4 Filename & Radix50 Formats LDIG3 I = LDIG3(number,ir50num) Converts the integer in (with an unsigned value of <1000.) into a Radix50 representation of that number in , with leading zeroes as necessary to make the 3 digits. This is useful when it is necessary to set up a series of files - eg TST001.DAT, TST002.DAT etc. The function normally returns 0, but returns -1 should exceed 999. CHAPTER 7 Triple-Precision Money Routines The triple precision format comprises three consecutive words. The highest order bits are in the first word (word with the lowest address), then the intermediate order bits, then the lowest order bits in the third word. The numbers are taken as a 48-bit twos-complement signed integer, expressing the number of cents in the value concerned. This leads to an upper limit of approximately $14 x 10**11 (1.4 {British} billion). On output, values may be preceded by a dollar sign (routines with a "D" in the name). If the value be negative, the minus sign will precede the dollar. On input, values may be preceded by a dollar sign and/or a minus sign which may be before or after the dollar sign. Overflow on input is indicated by the Carry bit being set (Macro routines) or a value of -1 being returned as the value of the function (Fortran routines). A single digit after the decimal point is taken to be a decimal of a dollar (eg "$12.34" returns the value 1234, but "$12.5" returns 1250). 7.1 Triple-Precision Money Routines: For details of , see chapter 1. LWM3DX CALL LWM3DX(3.value,nplaces) Writes a triple precision integer from <3.value> in money format to the user's terminal. A floating dollar sign is added, and the field width must be specified in . CVLLIB Manual - Fortran Section Page 7-2 Triple-Precision Money Routines LWM3PT CALL LWM3PT(3.value,nplaces) Writes a triple precision integer from <3.value> in money format to the user's terminal. There is no floating dollar sign, but the field width must be specified in . LWM3DT CALL LWM3DT(3.value) Writes a triple precision integer from <3.value> in money format to the user's terminal. A floating dollar sign precedes the number. LWM3T CALL LWM3T(3.value) Writes a triple precision integer from <3.value> in money format to the user's terminal. No floating dollar sign preceded the number. LWM3DP CALL LWM3DP(3.value,string,last,nplaces) Writes a triple precision integer from <3.value> in money format to . A floating dollar sign precedes the number, and the field width must be specified in . LWM3P CALL LWM3P(3.value,string,last,nplaces) Writes a triple precision integer from <3.value> in money format to . No floating dollar sign precedes the number, and the field width must be specified in . LWM3D CALL LWM3D(3.value,string,last) Writes a triple precision integer from <3.value> in money format to . A floating dollar sign precedes the number. LWM3 CALL LWM3(3.value,string,last) Writes a triple precision integer from <3.value> in money format to . No floating dollar sign precedes the number. LRM3T I = LRM3T(3.value,char) Reads a triple precision integer in money format from the user's terminal. This function returns the value -1 if overflow occurred on reading the number, 0 otherwise. CVLLIB Manual - Fortran Section Page 7-3 Triple-Precision Money Routines LRM3 I = LRM3(3.value,string,last) Reads a triple precision integer in money format from . This function returns the value -1 if overflow occurred on reading the number, 0 otherwise. CHAPTER 8 Triple-Precision Integers - I/O Triple-precision integers are stored in three consecutive words with the highest-order bits occupying the first word (with the lowest address). They are treated as 48-bit two's-complement signed numbers. Routines are provided to read, write, and arithmetically manipulate (see next chapter) these numbers. Decimal radix only is provided for triple precision numbers in this library (octal & hexadecimal are provided only in single & double precision). The maximum value for a triple-precision number is slightly over 14 x 10**13 or 140 {British} billion. 8.1 Triple-Precision I/O Routines: For details of , see chapter 1. LWD3PT CALL LWD3PT(3.value,nplaces) Writes a triple precision integer from <3.value> to the user's terminal, right-justified in a field wide. LWD3T CALL LWD3T(3.value) Writes a triple precision integer from <3.value> to the user's terminal. LWD3P CALL LWD3P(3.value,string,last,nplaces) Writes a triple precision integer from <3.value> to , right-justified in a field wide. CVLLIB Manual - Fortran Section Page 8-2 Triple-Precision Integers - I/O LWD3 CALL LWD3(3.value,string,last) Writes a triple precision integer from <3.value> to . LRD3T I = LRD3T(3.value,char) Reads a triple precision integer from the user's terminal, storing it in <3.value>. The function returns -1 if overflow occurred reading the number, 0 otherwise. LRD3 I = LRD3(3.value,string,last) Reads a triple precision integer from , storing it in <3.value>. The function returns -1 if overflow occurred reading the number, 0 otherwise. CHAPTER 9 Triple-Precision Arithmetic 9.1 Triple Precision Arithmetic Routines: LMUL31 I = LMUL31(3.value-1,value,3.value-2) Multiplies triple precision integer <3.value-1> by single precision integer , returning the triple precision result in <3.value-2>. The function returns -1 if overflow occurred, 0 otherwise. LMUL33 I = LMUL33(3.value-1,3.value-2,6.value) Multiplies two triple precision integers <3.value-1> and <3.value-2> to produce a six-word integer in <6.value>. Returns -1 if the result was too long to fit in a triple precision integer. LDIV31 I = LDIV31(3.value-1,value-1,3.value-2,value-2) Divides triple precision integer <3.value-1> by single precision integer , returning a triple precision quotient <3.value-2> and a single precision remainder . The function returns -1 on attempted divide-by-zero, 0 otherwise. LDIV33 I=LDIV33(3.value-1,3.value-2,3.value-3,3.value-4) Divides triple precision integer <3.value-1> by triple precision integer <3.value-2>, producing a triple precision quotient <3.value-3> and a triple precision remainder <3.value-4>. The function returns -1 on attempted divide-by-zero, 0 otherwise. CVLLIB Manual - Fortran Section Page 9-2 Triple-Precision Arithmetic LCMP3 I = LCMP3(3.value-1,3.value-2) Compares two triple precision integers, returning 0 if <3.value-1> .EQ. <3.value-2>, 1 if .GT., and -1 if .LT.. LADD3 I = LADD3(3.value-1,3.value-2,3.value-3) Adds triple precision integers <3.value-1> and <3.value-2> producing a triple precision result <3.value-3>. The function returns a negative value if overflow occurred, 0 otherwise. LSUB3 I = LSUB3(3.value-1,3.value-2,3.value-3) Subtracts triple precision integer <3.value-1> from triple precision integer <3.value-2>, producing a triple precision difference in <3.value-3>. The function returns a negative value if overflow occurred, 0 otherwise. LNEG3 CALL LNEG3(3.value) Negates the triple precision integer <3.value> in situ. LMOV3 CALL LMOVE(3.value-1,3.value-2) Provides a means of moving triple precision integers from one group of 3 words to another. Moves the contents of <3.value-1> to <3.value-2>. CHAPTER 10 Double-Precision Money Format Money values are internally stored as an integral number of cents. They are output as $ddd.cc (eg 3680 becomes $36.80), optionally with the floating dollar sign (routines with "D" in the name). On output negative numbers will have the minus sign before the leading dollar. On input numbers may be preceded by a dollar sign and/or a minus sign for negative numbers. This may come before or after the dollar sign. Spaces may precede the dollar sign, or come between the dollar sign and the number itself. On input, a number with no decimal point will be taken as dollars only. (Thus $4 produces 400). A number with only one digit after the decimal point will be taken in the arithmetic sense of that decimal fraction of a dollar - ie $3.5 becomes 350. Scanning of the input line stops either at an invalid character or after two digits have been read after the decimal point. 10.1 Double-Precision Money Format Routines: For details of , see chapter 1. LWMDPT CALL LWMDPT(2.value,nplaces) Writes a double precision integer in <2.value> to the user's terminal, with a floating dollar sign, right justified within the field of width . LWMPT CALL LWMPT(2.value,nplaces) Writes a double precision integer in <2.value> to the user's terminal, without a dollar sign, right justified within the field of width . CVLLIB Manual - Fortran Section Page 10-2 Double-Precision Money Format LWMDT CALL LWMDT(2.value) Writes a double precision integer in <2.value> to the user's terminal, with a floating dollar sign. LWMT CALL LWMT(2.value) Writes a double precision integer in <2.value> to the user's terminal, without a dollar sign. LWMDP CALL LWMDP(2.value,string,last,nplaces) Writes a double precision integer in <2.value> to , with a floating dollar sign, right justified within the field of width . LWMP CALL LWMP(2.value,string,last,nplaces) Writes a double precision integer in <2.value> to , without a dollar sign, right justified within the field of width . LWMD CALL LWMD(2.value,string,last,nplaces) Writes a double precision integer in <2.value> to , with a floating dollar sign. LWM CALL LWM(2.value,string,last,nplaces) Writes a double precision integer in <2.value> to , without a dollar sign. LRMT I = LRMT(2.value,char) Reads a double precision money value (formats available as per start of this chapter) into <2.value>, returning the delimiter in . This function returns -1 should overflow occur during reading the number, and 0 otherwise. LRM I = LRM(2.value,string,last) Reads a double precision money value (formats available as per start of this chapter) into <2.value>, from . This function returns -1 should overflow occur during reading the number, and 0 otherwise. CHAPTER 11 Double-Precision Integer I/O Double precision integers as handled by this library are stored with their high order word first (ie lowest address) and their low order word in the second word (higher address). This is the same as the RT-11 time format, but the reverse of the format offered in SYSLIB INTEGER*4 support. On input, either decimal or octal numbers may be read as signed (31 bits plus sign) two's complement values, or as unsigned (32 bit) values. On output decimal numbers are always signed, and octal output may be signed or unsigned. 11.1 Double-Precision Writing Routines: For details of , see chapter 1. LWD2PT CALL LWD2PT(2.value,nplaces) Writes double precision integer from <2.value> in decimal format to the user's terminal, right justified in a field of minimum width . LWD2T CALL LWD2T(2.value) Writes double precision integer from <2.value> in decimal format to the user's terminal. LWD2P CALL LWD2P(2.value,string,last,nplaces) Writes double precision integer from <2.value> in decimal format to , right justified in a field of minimum width . CVLLIB Manual - Fortran Section Page 11-2 Double-Precision Integer I/O LWD2 CALL LWD2(2.value,string,last) Writes double precision integer from <2.value> in decimal format to . LW82SX CALL LW82SX(2.value,nplaces) Writes double precision integer from <2.value> in signed octal format to the user's terminal, right justified in a field of minimum width . LW82PT CALL LW82PT(2.value,nplaces) Writes double precision integer from <2.value> in unsigned octal format to the user's terminal, right justified in a field of minimum width . LW82ST CALL LW82ST(2.value) Writes double precision integer from <2.value> in signed octal format to the user's terminal. LW82T CALL LW82T(2.value) Writes double precision integer from <2.value> in unsigned octal format to the user's terminal. LW82SP CALL LW82SP(2.value,string,last,nplaces) Writes double precision integer from <2.value> in signed octal format to , right justified in a field of minimum width . LW82P CALL LW82P(2.value,string,last,nplaces) Writes double precision integer from <2.value> in unsigned octal format to , right justified in a field of minimum width . LW82S CALL LW82S(2.value,string,last) Writes double precision integer from <2.value> in signed octal format to . LW82 CALL LW82(2.value,string,last) Writes double precision integer from <2.value> in unsigned octal format to . CVLLIB Manual - Fortran Section Page 11-3 Double-Precision Integer I/O LWH2T CALL LWH2T(2.value) Writes double precision integer from <2.value> as an unsigned hexadecimal number to the user's terminal, using any defined hex prefix or suffix characters (see chapter 1). LWH2 CALL LWH2(2.value,string,last) Writes double precision integer from <2.value> into as an unsigned hexadecimal number, using any defined hex prefix or suffix characters (see chapter 1). 11.2 Double-Precision Reading Routines: The reading functions normally return a value of zero, but return -1 should overflow occur on reading the number. In this case, the scan of the input string will continue to the end of the string of digits. Overflow on unsigned reading is full 32 bit overflow. Overflow on reading signed numbers is 31 bit overflow. LRN2T I = LRN2T(2.value,char) Reads a double precision integer from the user's terminal into <2.value>, returning the delimiting character in . The number is taken to be hexadecimal should it contain A-F (or a-f), or if it should be prefixed by a hex prefix character (see chapter 1) or followed by a hex suffix character (ibid). Otherwise it will be taken to be decimal if it contain 8 or 9, or be followed by a decimal point (the decimal point will be read, and the character following it will be the delimiting character). Otherwise it will be taken as octal. LRN2 I = LRN2(2.value,string,last) As per LRN2T (see above), but reads the number from the string. LRD2ST I = LRD2ST(2.value,char) Reads a double precision signed decimal number from the user's terminal into <2.value>, returning the delimiter in . LRD2T I = LRD2T(2.value,char) Reads a double precision unsigned decimal number from the user's terminal into <2.value>, returning the delimiter in . CVLLIB Manual - Fortran Section Page 11-4 Double-Precision Integer I/O LRD2S I = LRD2S(2.value,string,last) Reads a double precision signed decimal number from into <2.value>. LRD2 I = LRD2(2.value,string,last) Reads a double precision unsigned decimal number from into <2.value>. LR82ST I = LR82ST(2.value,char) Reads a double precision signed octal number from the user's terminal into <2.value>, returning the delimiter in . LR82T I = LR82T(2.value,char) Reads a double precision unsigned octal number from the user's terminal into <2.value>, returning the delimiter in . LR82S I = LR82S(2.value,string,last) Reads a double precision signed octal number from into <2.value>. LR82 I = LR82(2.value,string,last) Reads a double precision unsigned octal number from into <2.value>. LRH2T I = LRH2T(2.value,char) Reads a double precision hexadecimal number (may be signed) from the user's terminal into <2.value>, returning the delimiting character in . Any hexadecimal prefix or suffix character (see chapter 1) will be skipped, and if a suffix were defined and present the character following it will be used as the delimiter. Signs (+/-) may be on either side of any hex prefix character (or both, God help us!). LRH2 I = LRN2(2.value,string,last) Reads a double precision hexadecimal number from into <2.value> as per LRH2T (see above). CHAPTER 12 Double-Precision Arithmetic 12.1 Double-Precision Arithmetic Routines: LMUL21 I = LMUL21(2.value-1,value,2.value-2) Performs signed multiplication of <2.value-1> by , returning the product in <2.value-2>. The function returns -1 if overflow occurred during the multiplication, 0 otherwise. LMUL22 I = LMUL22(2.value-1,2.value-2,2.value-3) Performs signed multiplication of <2.value-1> by <2.value-2>, returning the product in <2.value-3>. The function returns -1 if overflow occurred during the multiplication, 0 otherwise. LDIV21 I = LDIV21(2.value-1,value-1,2.value-2,value-2) Performs signed integer division of <2.value-1> by , returning the quotient in <2.value-2> and the remainder in . The function returns -1 if division by zero were attempted, 0 otherwise. LADD2 I = LADD2(2.value-1,2.value-2,2.value-3) Performs double precision addition of <2.value-1> and <2.value-2>, returning the sum in <2.value-3>. The function returns a negative value if overflow occurred during the addition, 0 otherwise. LSUB2 I = LSUB2(2.value-1,2.value-2,2.value-3) Performs double precision subtraction of <2.value-1> from <2.value-2>, returning the difference in <2.value-3>. The function returns a negative value if overflow occurred during the subtraction, 0 otherwise. CVLLIB Manual - Fortran Section Page 12-2 Double-Precision Arithmetic LCMP2 I = LCMP2(2.value-1,2.value-2) Provides a means of comparing double precision values. Returns 1 if <2.value-1> .GT. <2.value-2>, 0 if .EQ., and -1 if .LT.. LNEG2 CALL LNEG2(2.value) Negates the double precision integer <2.value> in situ. CHAPTER 13 Single-Precision Integer I/O 13.1 Single Precision Integer Writing Routines: For details of , see chapter 1. LWDPT CALL LWDPT(value,nplaces) Writes a decimal number to the user's terminal, right justified in a field with minimum width . LWDT CALL LWDT(value) Writes a decimal number to the user's terminal. LWDP CALL LWDP(value,string,last,nplaces) Writes a decimal number to , right justified in a field with minimum width . LWD CALL LWD(value,string,last) Writes a decimal number to . LW8SPT CALL LW8SPT(value,nplaces) Writes a signed octal number to the user's terminal, right justified in a field with a minimum width . LW8PT CALL LW8PT(value,nplaces) Writes an unsigned octal number to the user's terminal, right justified in a field with a minimum width . CVLLIB Manual - Fortran Section Page 13-2 Single-Precision Integer I/O LW8ST CALL LW8ST(value) Writes a signed octal number to the user's terminal. LW8T CALL LW8T(value) Writes an unsigned octal number to the user's terminal. LW8SP CALL LW8SP(value,string,last,nplaces) Writes a signed octal number to , right justified in a field with a minimum width of . LW8P CALL LW8P(value,string,last,nplaces) Writes an unsigned octal number to , right justified in a field with a minimum width of . LW8S CALL LW8S(value,string,last) Writes a signed octal number to . LW8 CALL LW8(value,string) Writes an unsigned octal number to . LWHT CALL LWHT(value) Writes integer from as an unsigned hexadecimal number to the user's terminal, using any defined hex prefix or suffix characters (see chapter 1). LWH CALL LWH(value,string,last) Writes integer from into as an unsigned hexadecimal number, using any defined hex prefix or suffix characters (see chapter 1). CVLLIB Manual - Fortran Section Page 13-3 Single-Precision Integer I/O 13.2 Single Precision Integer Reading Routines: Functions which read numbers normally return zero as the value of the function, unless overflow occurs, in which case they return -1. In this case the scan of the input string will continue until the end of the digit string. Overflow on reading unsigned numbers is full 16 bit overflow. On reading signed numbers overflow occurs should there be a flow out of the low order 15 bits (eg reading 66600 with LRDT). LRNT I = LRNT(value,char) Reads a signed number (either octal or decimal) from the user's terminal. The number is taken to be hexadecimal should it contain A-F (or a-f), or if it should be prefixed by a hex prefix character (see chapter 1) or followed by a hex suffix character (ibid). Otherwise it will be taken to be decimal if it contain 8 or 9, or be followed by a decimal point (the decimal point will be read, and the character following it will be the delimiting character). Otherwise it will be taken as octal. LRN I = LRN(value,string,last) Reads a signed number (either octal or decimal) from . This function is analogous to LRNT (v.s.). LRDST I = LRDST(value,char) Reads a signed decimal number from the user's terminal. The delimiting character is returned in . LRDT I = LRDT(value,char) Reads an unsigned decimal number from the user's terminal. The delimiting character is returned in . LRDS I = LRDS(value,string,last) Reads a signed decimal number from . LRD I = LRD(value,string,last) Reads an unsigned decimal number from . CVLLIB Manual - Fortran Section Page 13-4 Single-Precision Integer I/O LR8ST I = LR8ST(value,char) Reads a signed octal number from the user's terminal, returning the delimiting character in . LR8T I = LR8T(value,char) Reads an unsigned octal number from the user's terminal, returning the delimiting character in . LR8S I = LR8S(value,string,last) Reads a signed octal number from . LR8 I = LR8(value,string,last) Reads an unsigned octal number from . LRHT I = LRHT(value,char) Reads a hexadecimal number (may be signed) from the user's terminal into , returning the delimiting character in . Any hexadecimal prefix or suffix character (see chapter 1) will be skipped, and if a suffix were defined and present the character following it will be used as the delimiter. Signs (+/-) may be on either side of any hex prefix character (or both, God help us!). LRH I = LRN(value,string,last) Reads a double precision hexadecimal number from into as per LRHT (see above). CHAPTER 14 String Comparison Routines String comparisons are provided in CVLLIB in a rather elementary form. No wildcard comparisons are provided for. Facilities include: COMPARISON: Performed on ASCII values, byte by byte, with handling of case and parity as mentioned below. TERMINATION: Strings are regarded as being terminated by either a zero or a <200> byte. PARITY BIT: Ignored on all searches. GENERAL COMPARISON: Upper case alphabetic characters are regarded as the same as their lower case equivalents (ie "a" = "A") EXACT COMPARISON: Upper case alphabetic characters are regarded as different from their lower case equivalents (ie "z" <> "Z") FIXED LENGTH: Strings must be the same length to match. Inequality of length in strings equal to the length of the lesser leads to the longer string being counted as the greater. VARIABLE LENGTH: The first string specified as an argument to the variable length comparisons may be shorter than the second, and provided the strings are equal up to the length of this first string, equality will be returned. 14.1 String Comparisons (Fortran Routines) The calling sequence for Fortran String Comparison routines is: I = ROUTINE(string1,index,string2) where and are the strings to be compared, and is an integer which receives the index to the byte which terminated the comparison. The value returned by the function will be zero for equality, 1 if be greater than , and -1 if be greater than . CVLLIB Manual - Fortran Section Page 14-2 String Comparison Routines LSCG String compare, general LSCX String compare, exact LSCGV String compare, general, variation in length still allows equality LSCXV String compare, exact, variation in length still allows equality For example: byte s1(50),s2(10) accept 10,s1 10 format(50a1) [say s1 now = 'prop'] ... i = lscg(s1,j,'PROP') [returns i=0, j=5] i = lscx(s1,j,'PROP') [returns i=1, j=1] i = lscgv(s1,j,'PROPELLOR') [returns i=0, j=5] i = lscxv(s1,j,'PROPELLOR') [returns i=1, j=1] It is possible to determine on a variable length search whether or not an exact match occurred by examining the last byte of as follows: [assume s2='PROP'] i = lscgv(s1,j,'PROP') if((i.eq.0).and.(s2(j).eq.0))exact match! CHAPTER 15 Various Additional Routines 15.1 Size Conversion Routines: Routines which convert between single, double, and triple precision integers are provided for both Macro and Fortran use. On reduction in precision, error indication is given should it not be possible to contain the number in the reduced space. 15.1.1 Size Conversion (Fortran Routines): LC12 CALL LC12(value,2.value) Converts single precision to double precision <2.value>. LC13 CALL LC13(value,3.value) Converts single precision to triple precision <3.value>. LC23 CALL LC23(2.value,3.value) Converts double precision <2.value> to triple precision <3.value>. LC21 I = LC21(2.value,value) Converts double precision <2.value> to single precision . The function returns -1 if it didn't fit, 0 if it did. CVLLIB Manual - Fortran Section Page 15-2 Various Additional Routines LC32 I = LC32(3.value,2.value) Converts triple precision <3.value> to double precision <2.value>. The function returns -1 if it didn't fit, 0 if it did. LC31 I = LC31(3.value,value) Converts triple precision <3.value> to single precision . The function returns -1 if it didn't fit, 0 if it did. 15.2 Additional Utilities etc LWAT CALL LWAT(value) Types an ascii character to the user's terminal printing control characters in a visible format for example "", with the name and the octal value of the character concerned. The more common characters (tab [rather than "ht"], lf, ff, cr, esc, and rubout [rather than "del"] do not get their octal values printed. Characters with the parity bit set are sent in the form "<200+x>", or "<200+>". LWA CALL LWA(value,string,last) Sends an ascii character to in a manner analogous with LWAT (see above). TCRLF CALL TCRLF Types a carriage-return and a line-feed to the user's terminal. This routine may be called from Macro, Fortran, or C. TUC CALL TUC Clears bit in Job Status Word which allows lower case from the user's terminal, thereby forcing upper case input. This routine may be called from Macro, Fortran, or C. TLC CALL TLC Sets bit in Job Status Word which allows lower case from the user's terminal, thereby allowing lower case input. This routine may be called from Macro, Fortran or C. CVLLIB Manual - Fortran Section Page 15-3 Various Additional Routines TSPM CALL TSPM Sets bit in Job Status Word which allows for special mode input from the user's terminal - ie single character input without echo. This routine may be called from Macro, Fortran or C. TNSPM CALL TNSPM Clears bit in Job Status Word (converse of TSPM) resetting the user's terminal back to echoing and reading line by line. This routine may be called from Macro, Fortran, or C. TNIOW CALL TNIOW Sets bit in Job Status Word allowing immediate return for .TTINR (read a single character from the terminal) routines when using the Foreground Background RT-11 monitor. This allows the user to test for availability of terminal input. This routine may be called from Macro, Fortran, or C. TIOW CALL TIOW This is the converse of TNIOW, allowing RT11 to place the job in a wait state until terminal input is available. This routine may be called from Macro, Fortran, or C. LTLIN I = LTLIN(string,last) Reads a line from the user's terminal using .TTYIN requests (so it does not track a command file), returning that line null terminated in . receives an value such that STRING(LAST) points to that terminating null. Should the control-C intercept be operating, LTLIN will return a value -1 if the input line were terminated by a control-C character (leaving that character in for the user should he desire to use it). Otherwise LTLIN returns 0. LCHR CALL LCHR(char[,char-2, ... ,char-n]) Types the individual 's as one character each to the user's terminal. There is no restriction on the number of arguments. LPRINT CALL LPRINT('This is a sample string') Types the supplied string to the user's terminal (as per PRINT) but does not terminate it with a carriage return line feed combination. It is useful for prompting the user. CVLLIB Manual - Fortran Section Page 15-4 Various Additional Routines LYES I = LYES() Reads a line from the user's terminal (into TLINB buffer). Returns the value 0 if the first character in the line were "Y" or "y", -1 otherwise. LYESNO I = LYESNO() Reads a line from the user's terminal (into TLINB buffer). Returns the value 0 if the first character in the line were "Y" or "y", and -1 if the first character were "N" or "n". For any other response LYESNO prompts the user to try again. LIRAN I = LIRAN(value) LRNSET CALL LRNSET(value) LIRAN returns a single-precision integral random number from 0 to . (No statistical analyses have been made on this routine - it is fine for games, but should be checked further before using it for heavy statistical work!). LRNSET initializes the random number generator with . Normally the starting value is 0 (though this seed is not the value returned). JSWSET CALL JSWSET(value) Sets the bits which are set in in the Job Status Word. JSWCLR CALL JSWCLR(value) Clears the bits which are set in in the Job Status Word. LLTRIM I = LLTRIM(string) Returns the number of bytes from which contain leading spaces or tabs. Thus if contain " 123" the call to LLTRIM will return the value 3, for the three leading spaces. A value of zero will be returned should there be no leading spaces. The string itself is not altered. LRTRIM I = LRTRIM(string) Returns the number of bytes (working BACKWARDS) from ) which contain spaces or tabs. Thus if contain "fred.dat " and the call I=LRTRIM(STRING(12)) be used, the value 4 will be returned (for the four trailing spaces). The string itself is not altered. CHAPTER 16 Ancillary Subroutines Subroutines with names containing a dollar sign are to be found in source files named with the same string of letters (and numerals) but without the dollar sign. For example, W$CT is found in WCT.MAC, and LW$2PT is found in LW2PT.MAC. 16.1 Ancillary Subroutines: These are routines used by Fortran routines to interface with the Macro equivalents for the facilities provided in this library. They may be useful to the user who wishes to set up his own routines along similar patterns, or to the helpful fellow who wishes to help debugging this collection! LW$2PT Final common pathway for fortran routines writing double precision integers with a specified field width to the user's terminal. These have a calling sequence in the form CALL LWx2PT(2.value,nplaces) where <2.value> is the double precision integer to be printed, and the minimum number of places for it to occupy, right justified and padded to the left with spaces as necessary. LWD2PT:: CALL LW$2PT .WORD WD2PT returns to caller, not here LW$2T Final common pathway for fortran routines writing double precision integers to the user's terminal. These have a calling sequence in the form CALL LWx2T(2.value) where <2.value> is the double precision integer to be printed. LW82T:: CALL LW$2T CVLLIB Manual - Fortran Section Page 16-2 Ancillary Subroutines .WORD W82T returns to caller, not here LW$2P Final common pathway for fortran routines writing double precision integers with a specified field width to a string. These have a calling sequence in the form CALL LWx2P(2.value,string,last,nplaces) where <2.value> is the double precision integer to be printed into , receives an index to the next free byte in , and is the field width. LWD2P:: CALL LW$2P .WORD WD2P returns to caller, not here LW$2 Final common pathway for fortran routines writing double precision integers to a string. These have a calling sequence in the form CALL LWx2(2.value,string,last) where <2.value> is the double precision integer to be printed into , and receives an index to the next free byte in . LW82:: CALL LW$2 .WORD W82 returns to caller, not here LW$P Final common pathway for fortran routines writing single precision integers specifying a field width. These have a calling sequence in the form CALL LWxP(value,string,last,nplaces) where is the integer to be printed into , receives an index to the next free byte in , and is the field width. LWDP:: CALL LW$P .WORD WDP returns to caller, not here CVLLIB Manual - Fortran Section Page 16-3 Ancillary Subroutines LR$2T Common pathway for fortran routines reading double precision integers from the user's terminal. These have a calling sequence in the form I = LRx2T(2.value,char) where <2.value> receives the double precision integer read, and receives the byte which delimited the number. The value returned (I) is zero unless Carry has been set by the number-reading routine, in which case -1 is returned. LR$2T has been placed in the general section of CVLLIB (CVGLIB) as it is used by the Fortran floating point routines. LRD2T:: CALL RD2T JMP LR$2T LR$2 Common pathway for fortran routines reading double precision integers from strings. These have a calling sequence in the form I = LRx2(2.value,string,last) where <2.value> receives the double precision value read from , and receives an index to the character which delimited the number. The returned value (I) is -1 if carry is set by the number reading routine, 0 otherwise. LR$2 has been placed in the general section of CVLLIB (CVGLIB) as it it used by the Fortran floating point routines. LR82T:: CALL LR$2 .WORD R82T returns to caller, not here LR$ Common pathway for fortran routines reading single precision integers from strings. These have a calling sequence in the form I = LRx(value,string,last) where receives the number read from , and receives an index to the delimiting character. The returned value (I) is -1 if carry was set on return from the number reading routine, 0 otherwise. LR8:: CALL LR$ .WORD R8 returns to caller, not here CVLLIB Manual - Fortran Section Page 16-4 Ancillary Subroutines LRETC Returns -1 in R0 if the Carry bit is set, and 0 in R0 if not. It is used terminally in numerous routines. Routines which use in the calling sequence can call LRETC to set up R0 before using LR$ADJ to set up , as this latter routine does not alter R0. [LRETC is provided in the general section of the library, as it is common to both Fortran and C interfaces.] 16.1.1 LW$ADJ and LR$ADJ This pair of routines comes in the file LWADJ.MAC. They provide a mechanism for Fortran routines with calling sequences in the form CALL ROUTINE(value,string,last, ... ) which after reading from or writing into need to calculate the number of bytes read or written and add this to . LW$ADJ - (for routines which WRITE only) - should be entered with a pointer to the routine to be used on the stack, and registers other than R1 (string pointer) already set up. LW$ADJ sets up the string pointer, calls the routine, clears the next byte in , then adjusts . LR$ADJ - purely adjusts the value in . R1 is altered, but R0 may be used to return a value to the calling programme. LR$ADJ and LW$ADJ have been placed in the general section of CVLLIB (CVGLIB) as they are used by the Fortran floating point routines. [CALL LWD(value,string,last] LWD:: MOV @2(R5),R0 {value} CALL LW$ADJ .WORD WD returns to caller, not here APPENDIX I Index <2.value> . . . . . . . . . . . . . . . . . . . . 2-3 <3.value> . . . . . . . . . . . . . . . . . . . . 2-3 . . . . . . . . . . . . . . . . . . . . . . 2-4 . . . . . . . . . . . . . . . . . . . 3-1 . . . . . . . . . . . . . . . . . . . 3-3 - general information . . . . . . . . . . . 2-4 for Date Reading Routines . . . . . . . . . 4-1 for Date Writing Routines . . . . . . . . . 4-1 for filename routines . . . . . . . . . . . 6-1 for Time routines . . . . . . . . . . . . . 5-1 . . . . . . . . . . . . . . . . . . . . . . 2-3 . . . . . . . . . . . . . . . . . . . . . 2-3 . . . . . . . . . . . . . . . . . . . 3-2 Addition of 2.precis integers - LADD2 . . . . . . 12-1 Additional Routines . . . . . . . . . . . . . . . 15-1 Additional Utilities . . . . . . . . . . . . . . . 15-2 Adjustment routine, reading - LR$ADJ . . . . . . . 16-4 Adjustment routine, writing - LW$ADJ . . . . . . . 16-4 Age - Determine given DOB and date - LAGE . . . . 4-3 Ancillary for LRx routines - LR$ . . . . . . . . . 16-3 Ancillary for LRx2 - LR$2 . . . . . . . . . . . . 16-3 Ancillary for LRx2T - LR$2T . . . . . . . . . . . 16-3 Ancillary for LWx2 - LW$2 . . . . . . . . . . . . 16-2 Ancillary for LWx2P - LW$2P . . . . . . . . . . . 16-2 Ancillary for LWx2PT - LW$2PT . . . . . . . . . . 16-1 Ancillary for LWx2T - LW$2T . . . . . . . . . . . 16-1 Ancillary for LWxP - LW$P . . . . . . . . . . . . 16-2 Ancillary Subroutines . . . . . . . . . . . . . . 16-1 Argument Patterns . . . . . . . . . . . . . . . . 2-3 Arithmetic Routines - 2.precis-Precision . . . . . 12-1 Arithmetic Routines - 3.precision . . . . . . . . 9-1 Ascii character to string - LWA . . . . . . . . . 15-2 Ascii character to TTY - LWAT . . . . . . . . . . 15-2 Ascii from radix50 conversion - LCA50 . . . . . . 6-3 CVLLIB Manual - Fortran Section Page I-2 Ascii to radix50 conversion - LCA50 . . . . . . . 6-3 Block Format - DATE . . . . . . . . . . . . . . . 3-1 Block Format - TIME . . . . . . . . . . . . . . . 3-2 Block Formats - FILENAME . . . . . . . . . . . . . 3-3 Buffer, TTY I/O . . . . . . . . . . . . . . . . . 3-3 Calculate date given year and day of year - LDTCAL 4-3 Calculate difference between dates . . . . . . . . 4-3 CALEND Common Block . . . . . . . . . . . . . . . 3-1 Calendar Information . . . . . . . . . . . . . . . 3-1 Check (none!) on string length . . . . . . . . . . 2-4 Check validity of date - LIDAY . . . . . . . . . . 4-3 Clear bits in JSW - JSWCLR . . . . . . . . . . . . 15-4 Command Files and TTY I/O . . . . . . . . . . . . 3-3 Common Block - CALEND . . . . . . . . . . . . . . 3-1 Common Block - DATBLK . . . . . . . . . . . . . . 3-1 Common Block - TIMBLK . . . . . . . . . . . . . . 3-2 Comparison of 2.precis integers - LCMP2 . . . . . 12-2 Comparison of Strings . . . . . . . . . . . . . . 14-1 Conversion between diff precis integers . . . . . 15-1 Convert 1.precis integer to 2.precis - LC12 . . . 15-1 Convert 1.precis integer to 3.precis - LC13 . . . 15-1 Convert 2.precis integer to 1.precis - LC21 . . . 15-1 Convert 2.precis integer to 3.precis - LC23 . . . 15-1 Convert 3.precis integer to 1.precis - LC31 . . . 15-2 Convert 3.precis integer to 2.precis - LC32 . . . 15-2 Convert ascii to radix50 - LCA50 . . . . . . . . . 6-3 Convert number to 3 rad50 digits - LDIG3 . . . . . 6-4 Convert radix50 to ascii - LCA50 . . . . . . . . . 6-3 Convert RT11 date to words - LCRDW . . . . . . . . 4-4 Convert RT11 time to words - LCRTW . . . . . . . . 5-2 Convert word date to RT11 - LCWDR . . . . . . . . 4-4 Convert word time to RT11 - LCWTR . . . . . . . . 5-3 DATBLK block . . . . . . . . . . . . . . . . . . . 3-1 Date - Calculate difference between dates - LDTDIF 4-3 Date - Calculate from year and day of year - LDTCAL 4-3 Date - check validity of - LIDAY . . . . . . . . . 4-3 Date - Convert RT11 date to words - LCRDW . . . . 4-4 Date - Convert word date to RT11 - LCRDW . . . . . 4-4 Date - day of week from - LIDAY . . . . . . . . . 4-3 Date - Read from string - LRDAT . . . . . . . . . 4-3 Date - Read from system - LRSDAT . . . . . . . . . 4-2 Date - Read from TTY - LRDATT . . . . . . . . . . 4-3 Date - Write system date to string - LWSDAT . . . 4-2 Date - Write system date to TTY - LWSDTT . . . . . 4-2 Date - Write to string - LWDAT . . . . . . . . . . 4-2 Date - Write to TTY - LWDATT . . . . . . . . . . . 4-2 Date - Write today and date to string - LTODAY . . 4-2 Date - Write today and date to TTY - LTODAT . . . 4-2 DATE Block Format . . . . . . . . . . . . . . . . 3-1 DATE Routines . . . . . . . . . . . . . . . . . . 4-1 Day name to string - LWDAY . . . . . . . . . . . . 4-2 CVLLIB Manual - Fortran Section Page I-3 Day name to TTY - LWDAYT . . . . . . . . . . . . . 4-2 Day of week from date - LIDAY . . . . . . . . . . 4-3 DAY offset . . . . . . . . . . . . . . . . . . . . 3-1 DEVICE offset (fileblock) . . . . . . . . . . . . 3-3 Division of 2.precis integer by 1.precis - LDIV21 . 12-1 Double-precis Money Routines . . . . . . . . . . . 10-1 Double-Precision Arithmetic . . . . . . . . . . . 12-1 Double-Precision Integer Format . . . . . . . . . 11-1 Double-Precision Integer I/O . . . . . . . . . . . 11-1 DYEAR offset (dateblock) . . . . . . . . . . . . . 3-1 EXT offset (fileblock) . . . . . . . . . . . . 3-3 FILE1 offset (fileblock) . . . . . . . . . . . . 3-3 FILE2 offset (fileblock) . . . . . . . . . . . . 3-3 Filename - Read from string - LRF . . . . . . . . 6-2 Filename - Read from TTY - LRFT . . . . . . . . . 6-2 Filename - Read with defaults from string - LRFD . 6-2 Filename - Read with defaults from TTY - LRFDT . . 6-2 Filename - Write to string - LWF . . . . . . . . . 6-2 Filename - Write to TTY - LWFT . . . . . . . . . . 6-1 FILENAME Block . . . . . . . . . . . . . . . . . . 3-3 Filename Formats . . . . . . . . . . . . . . . . . 6-1 Filename routines - . . . . . . . . . . . . 6-1 Flag for Date Reading Routines . . . . . . . . . . 4-1 Flag for Date Writing Routines . . . . . . . . . . 4-1 Flag for filename routines . . . . . . . . . . . . 6-1 Flags (generally) . . . . . . . . . . . . . . . . 2-4 Forced linking of R$G . . . . . . . . . . . . . . 3-3 Format - 2.precis-Precision Integer . . . . . . . 11-1 Formats for DATES . . . . . . . . . . . . . . . . 4-1 Fortran Interfaces for Programmes . . . . . . . . 2-2 General Details . . . . . . . . . . . . . . . . . 2-1 GTLIN vs TTYIN TTY Input . . . . . . . . . . . . . 3-3 Hex prefix - HEXPRE . . . . . . . . . . . . . . . 2-5 Hex suffix - HEXSUF . . . . . . . . . . . . . . . 2-5 Hexadecimal Conventions . . . . . . . . . . . . . 2-5 HEXPRE - Hex prefix . . . . . . . . . . . . . . . 2-5 HEXSUF - Hex suffix . . . . . . . . . . . . . . . 2-5 HOURS offset (timeblock) . . . . . . . . . . . . 3-2 I/O Wait on TTY - TNIOW & TIOW . . . . . . . . . . 15-3 Ideas behind Names of Routines . . . . . . . . . . 2-1 Integer - Read 2.precis dec from string - LRD2 . . 11-4 Integer - Read 2.precis dec from TTY - LRD2T . . . 11-3 Integer - Read 2.precis dec oct or hex from string - LRN2 11-3 Integer - Read 2.precis dec oct or hex from TTY - LRN2T 11-3 Integer - Read 2.precis hex from string - LRH2 . . 11-4 Integer - Read 2.precis hex from TTY - LRH2T . . . 11-4 Integer - Read 2.precis oct from string - LR82 . . 11-4 Integer - Read 2.precis oct from TTY - LR82T . . . 11-4 Integer - Read 2.precis signed dec fr str - LRD2S . 11-4 CVLLIB Manual - Fortran Section Page I-4 Integer - Read 2.precis signed dec fr TTY - LRD2ST 11-3 Integer - Read 2.precis signed oct fr str - LR82S . 11-4 Integer - Read 2.precis signed oct fr TTY - LR82ST 11-4 Integer - Read dec from string - LRD . . . . . . . 13-3 Integer - Read dec from TTY - LRDT . . . . . . . . 13-3 Integer - Read dec signed from string - LRDS . . . 13-3 Integer - Read dec signed from TTY - LRDST . . . . 13-3 Integer - Read hex from string - LRH . . . . . . . 13-4 Integer - Read hex from TTY - LRHT . . . . . . . . 13-4 Integer - Read oct dec or hex integer from string - LRN 13-3 Integer - Read oct dec or hex integer from TTY - LRNT 13-3 Integer - Read oct from string - LR8 . . . . . . . 13-4 Integer - Read oct from TTY - LR8T . . . . . . . . 13-4 Integer - Read oct signed from string - LR8S . . . 13-4 Integer - Read oct signed from TTY - LR8ST . . . . 13-4 Integer - Write 2.precis dec to string - LWD2 . . 11-2 Integer - Write 2.precis dec to string - LWD2P . . 11-1 Integer - Write 2.precis dec to TTY - LWD2PT . . . 11-1 Integer - Write 2.precis dec to TTY - LWD2T . . . 11-1 Integer - Write 2.precis hex to string - LWH2 . . 11-3 Integer - Write 2.precis hex to terminal - LWH2T . 11-3 Integer - Write 2.precis oct to string - LW82 . . 11-2 Integer - Write 2.precis oct to string - LW82P . . 11-2 Integer - Write 2.precis oct to string - LW82S . . 11-2 Integer - Write 2.precis oct to string - LW82SP . 11-2 Integer - Write 2.precis oct to TTY - LW82PT . . . 11-2 Integer - Write 2.precis oct to TTY - LW82ST . . . 11-2 Integer - Write 2.precis oct to TTY - LW82SX . . . 11-2 Integer - Write 2.precis oct to TTY - LW82T . . . 11-2 Integer - Write dec to string - LWD . . . . . . . 13-1 Integer - Write dec to string - LWDP . . . . . . . 13-1 Integer - Write dec to TTY - LWDPT . . . . . . . . 13-1 Integer - Write dec to TTY - LWDT . . . . . . . . 13-1 Integer - Write hex to string - LWH . . . . . . . 13-2 Integer - Write hex to terminal - LWHT . . . . . . 13-2 Integer - Write oct signed to string - LW8S . . . 13-2 Integer - Write oct signed to string - LW8SP . . . 13-2 Integer - Write oct signed to TTY - LW8SPT . . . . 13-1 Integer - Write oct signed to TTY - LW8ST . . . . 13-2 Integer - Write oct to string - LW8 . . . . . . . 13-2 Integer - Write oct to string - LW8P . . . . . . . 13-2 Integer - Write oct to TTY - LW8PT . . . . . . . . 13-1 Integer - Write oct to TTY - LW8T . . . . . . . . 13-2 Integer I/O - 1.precis-Precision . . . . . . . . . 13-1 Integer I/O - 2.precis-Precision . . . . . . . . . 11-1 Integers - 3.precision . . . . . . . . . . . . . . 8-1 Job status word - clear bits in - JSWCLR . . . . . 15-4 Job status word - set bits in - JSWSET . . . . . . 15-4 JSWCLR - Clear bits in JSW . . . . . . . . . . . . 15-4 JSWSET - Set bits in JSW . . . . . . . . . . . . . 15-4 LADD2 - Addition of 2.precis integers . . . . . . 12-1 LADD3 - 3.precis addition . . . . . . . . . . . . 9-2 CVLLIB Manual - Fortran Section Page I-5 LAGE - Determine age given DOB and date . . . . . 4-3 LC12 - Convert 1.precis integer to 2.precis . . . 15-1 LC13 - Convert 1.precis integer to 3.precis . . . 15-1 LC21 - Convert 2.precis integer to 1.precis . . . 15-1 LC23 - Convert 2.precis integer to 3.precis . . . 15-1 LC31 - Convert 3.precis integer to 1.precis . . . 15-2 LC32 - Convert 3.precis integer to 2.precis . . . 15-2 LC50A - Convert radix50 to ascii . . . . . . . . . 6-3 LCA50 - Convert ascii to radix50 . . . . . . . . . 6-3 LCHR - Type characters . . . . . . . . . . . . . . 15-3 LCMP2 - Comparison of 2.precis integers . . . . . 12-2 LCMP3 - 3.precis comparison . . . . . . . . . . . 9-2 LCRDW - Convert RT11 date to words . . . . . . . . 4-4 LCRTW - Convert RT11 time to words . . . . . . . . 5-2 LCWDR - Convert words to RT11 date . . . . . . . . 4-4 LCWTR - Convert word time to RT11 . . . . . . . . 5-3 LDIG3 - Convert number to 3 rad50 digits . . . . . 6-4 LDIV21 - Division of 2.precis integer by 1.precis . 12-1 LDIV31 - 3.precis / 1.precis divide . . . . . . . 9-1 LDIV33 - 3.precis / 3.precis divide . . . . . . . 9-1 LDTCAL - Calculate date given year and day of year 4-3 LDTDIF - Calculate difference between dates . . . 4-3 Leading Spaces and Tabs . . . . . . . . . . . . . 2-4 LIDAY - Check validity of date . . . . . . . . . . 4-3 Limit - 3.precision Values . . . . . . . . . . . . 8-1 Limits - 3.precision . . . . . . . . . . . . . . . 7-1 Linking for GTLIN TTY Input . . . . . . . . . . . 3-3 LIRAN - Random number generator . . . . . . . . . 15-4 LLTRIM - Trim left of string . . . . . . . . . . . 15-4 LMOV3 - 3.precis replacement . . . . . . . . . . . 9-2 LMUL21 - Multiply 2.precis integer * 1.precis . . 12-1 LMUL22 - Multiply 2.precis integer * 2.precis . . 12-1 LMUL31 - 3.precis * 1.precis multiply . . . . . . 9-1 LMUL33 - 3.precis * 3.precis multiply . . . . . . 9-1 LNEG2 - Negation of 2.precis integer . . . . . . . 12-2 LNEG3 - 3.precis negation . . . . . . . . . . . . 9-2 Lower case from TTY - TLC . . . . . . . . . . . . 15-2 LPRINT - Print a prompt . . . . . . . . . . . . . 15-3 LR$ - Ancillary for LRx routines . . . . . . . . . 16-3 LR$2 - Ancillary for LRx2 . . . . . . . . . . . . 16-3 LR$2T - Ancillary for LRx2T . . . . . . . . . . . 16-3 LR$ADJ - Adjustment routine, reading . . . . . . . 16-4 LR50 - Read radix50 (full set) from string . . . . 6-3 LR50F - Read radix50 (filename set) from string . 6-3 LR50FT - Read radix50 (filename set) from TTY . . 6-3 LR50S - Read radix50 (symbol set) from string . . 6-3 LR50ST - Read radix50 (symbol set) from TTY . . . 6-3 LR50T - Read radix50 (full set) from TTY . . . . . 6-3 LR8 - Read oct from string . . . . . . . . . . . . 13-4 LR82 - Read 2.precis oct from string . . . . . . . 11-4 LR82S - Read 2.precis signed oct from string . . . 11-4 LR82ST - Read 2.precis signed oct from TTY . . . . 11-4 LR82T - Read 2.precis oct from TTY . . . . . . . . 11-4 LR8S - Read oct signed from string . . . . . . . . 13-4 CVLLIB Manual - Fortran Section Page I-6 LR8ST - Read oct signed from TTY . . . . . . . . . 13-4 LR8T - Read oct from TTY . . . . . . . . . . . . . 13-4 LRD - Read dec from string . . . . . . . . . . . . 13-3 LRD2 - Read 2.precis dec from string . . . . . . . 11-4 LRD2S - Read 2.precis signed dec from string . . . 11-4 LRD2ST - Read 2.precis signed dec from TTY . . . . 11-3 LRD2T - Read 2.precis dec from TTY . . . . . . . . 11-3 LRD3 - Read 3.precis from string . . . . . . . . . 8-2 LRD3T - Read 3.precis from TTY . . . . . . . . . . 8-2 LRDAT - Read date from string . . . . . . . . . . 4-3 LRDATT - Read date from TTY . . . . . . . . . . . 4-3 LRDS - Read dec signed from string . . . . . . . . 13-3 LRDST - Read dec signed from TTY . . . . . . . . . 13-3 LRDT - Read dec from TTY . . . . . . . . . . . . . 13-3 LRETC - Return R0/-1 if CS . . . . . . . . . . . . 16-4 LRF - Read filename from string . . . . . . . . . 6-2 LRFD - Read filename with defaults from string . . 6-2 LRFDT - Read filename with defaults from TTY . . . 6-2 LRFT - Read filename from TTY . . . . . . . . . . 6-2 LRH - Read hex from string . . . . . . . . . . . . 13-4 LRH2 - Read 2.precis hex from string . . . . . . . 11-4 LRH2T - Read 2.precis hex from TTY . . . . . . . . 11-4 LRHT - Read hex from TTY . . . . . . . . . . . . . 13-4 LRM - Read 2.precis money from string . . . . . . 10-2 LRM3 - Read 3.precis money from string . . . . . . 7-3 LRM3T - Read 3.precis money from TTY . . . . . . . 7-2 LRMT - Read 2.precis money from TTY . . . . . . . 10-2 LRN - Read oct dec or hex integer from string . . 13-3 LRN2 - Read 2.precis dec oct or hex from string . 11-3 LRN2T - Read 2.precis dec oct or hex from TTY . . 11-3 LRNSET - initialize random numbers . . . . . . . . 15-4 LRNT - Read oct dec or hex integer from TTY . . . 13-3 LRSDAT - Read date from system . . . . . . . . . . 4-2 LRSTIM - Read time from system . . . . . . . . . . 5-2 LRTIM - Read time from string . . . . . . . . . . 5-2 LRTIMT - Read time from TTY . . . . . . . . . . . 5-2 LRTRIM - Trim right of string . . . . . . . . . . 15-4 LSUB2 - Subtraction of 2.precis integers . . . . . 12-1 LSUB3 - 3.precis subtraction . . . . . . . . . . . 9-2 LTLIN - TTY line input . . . . . . . . . . . . . . 15-3 LTODAT - Write today and date to TTY . . . . . . . 4-2 LTODAY - Write today and date to string . . . . . 4-2 LW$2 - Ancillary for LWx2 . . . . . . . . . . . . 16-2 LW$2P - Ancillary for LWx2P . . . . . . . . . . . 16-2 LW$2PT - Ancillary for LWx2PT . . . . . . . . . . 16-1 LW$2T - Ancillary for LWx2T . . . . . . . . . . . 16-1 LW$ADJ - Adjustment routine, writing . . . . . . . 16-4 LW$P - Ancillary for LWxP . . . . . . . . . . . . 16-2 LW50 - Write radix50 to string . . . . . . . . . . 6-3 LW50F - Write radix50 (file set) to string . . . . 6-2 LW50FT - Write radix50 (file set) to TTY . . . . . 6-2 LW50T - Write radix50 to TTY . . . . . . . . . . . 6-2 LW8 - Write oct to string . . . . . . . . . . . . 13-2 LW82 - Write 2.precis oct to string . . . . . . . 11-2 CVLLIB Manual - Fortran Section Page I-7 LW82P - Write 2.precis oct to string . . . . . . . 11-2 LW82PT - Write 2.precis oct to TTY . . . . . . . . 11-2 LW82S - Write 2.precis oct to string . . . . . . . 11-2 LW82SP - Write 2.precis oct to string . . . . . . 11-2 LW82ST - Write 2.precis oct to TTY . . . . . . . . 11-2 LW82SX - Write 2.precis oct to TTY . . . . . . . . 11-2 LW82T - Write 2.precis oct to TTY . . . . . . . . 11-2 LW8P - Write oct to string . . . . . . . . . . . . 13-2 LW8PT - Write oct to TTY . . . . . . . . . . . . . 13-1 LW8S - Write oct signed to string . . . . . . . . 13-2 LW8SP - Write oct signed to string . . . . . . . . 13-2 LW8SPT - Write oct signed to TTY . . . . . . . . . 13-1 LW8ST - Write oct signed to TTY . . . . . . . . . 13-2 LW8T - Write oct to TTY . . . . . . . . . . . . . 13-2 LWA - Type an ascii character to a string . . . . 15-2 LWAT - Type an ascii character to TTY . . . . . . 15-2 LWD - Write dec to string . . . . . . . . . . . . 13-1 LWD2 - Write 2.precis dec to string . . . . . . . 11-2 LWD2P - Write 2.precis dec to string . . . . . . . 11-1 LWD2PT - Write 2.precis dec to TTY . . . . . . . . 11-1 LWD2T - Write 2.precis dec to TTY . . . . . . . . 11-1 LWD3 - Write 3.precis to string . . . . . . . . . 8-2 LWD3P - Write 3.precis to string . . . . . . . . . 8-1 LWD3PT - Write 3.precis to TTY . . . . . . . . . . 8-1 LWD3T - Write 3.precis to TTY . . . . . . . . . . 8-1 LWDAT - Write date to string . . . . . . . . . . . 4-2 LWDATT - Write date to TTY . . . . . . . . . . . . 4-2 LWDAY - Write name of day to string . . . . . . . 4-2 LWDAYT - Write name of day to TTY . . . . . . . . 4-2 LWDP - Write dec to string . . . . . . . . . . . . 13-1 LWDPT - Write dec to TTY . . . . . . . . . . . . . 13-1 LWDT - Write dec to TTY . . . . . . . . . . . . . 13-1 LWF - Write filename to string . . . . . . . . . . 6-2 LWFT - Write filename to TTY . . . . . . . . . . . 6-1 LWH - Write hex to string . . . . . . . . . . . . 13-2 LWH2 - Write 2.precis hex to string . . . . . . . 11-3 LWH2T - Write 2.precis hex to terminal . . . . . . 11-3 LWHT - Write hex to terminal . . . . . . . . . . . 13-2 LWM - Write 2.precis money to string . . . . . . . 10-2 LWM3 - Write 3.precis money to string . . . . . . 7-2 LWM3D - Write 3.precis money to string . . . . . . 7-2 LWM3DP - Write 3.precis money to string . . . . . 7-2 LWM3DT - Write 3.precis money to TTY . . . . . . . 7-2 LWM3DX - Write 3.precis money to TTY . . . . . . . 7-1 LWM3P - Write 3.precis money to string . . . . . . 7-2 LWM3PT - Write 3.precis money to TTY . . . . . . . 7-2 LWM3T - Write 3.precis money to TTY . . . . . . . 7-2 LWMD - Write 2.precis money to string . . . . . . 10-2 LWMDP - Write 2.precis money to string . . . . . . 10-2 LWMDPT - Write 2.precis money to TTY . . . . . . . 10-1 LWMDT - Write 2.precis money to TTY . . . . . . . 10-2 LWMP - Write 2.precis money to string . . . . . . 10-2 LWMPT - Write 2.precis money to TTY . . . . . . . 10-1 LWMT - Write 2.precis money to TTY . . . . . . . . 10-2 CVLLIB Manual - Fortran Section Page I-8 LWSDAT - Write system date to string . . . . . . . 4-2 LWSDTT - Write system date to TTY . . . . . . . . 4-2 LWSTIM - Write system time to string . . . . . . . 5-2 LWSTMT - Write system time to TTY . . . . . . . . 5-1 LWTIM - Write time to string . . . . . . . . . . . 5-2 LWTIMT - Write time to TTY . . . . . . . . . . . . 5-2 LYES - Read answer from TTY . . . . . . . . . . . 15-4 LYESNO - Read Yes/No answer from TTY . . . . . . . 15-4 MINS offset (timeblock) . . . . . . . . . . . . 3-2 Money (2.precis) Routines . . . . . . . . . . . . 10-1 Money (3.precis) read from string - LRM3 . . . . . 7-3 Money (3.precis) read from TTY - LRM3T . . . . . . 7-2 Money (3.precis) write to string - LWM3 . . . . . 7-2 Money (3.precis) write to string - LWM3D . . . . . 7-2 Money (3.precis) write to string - LWM3DP . . . . 7-2 Money (3.precis) write to string - LWM3P . . . . . 7-2 Money (3.precis) write to TTY - LWM3DT . . . . . . 7-2 Money (3.precis) write to TTY - LWM3DX . . . . . . 7-1 Money (3.precis) write to TTY - LWM3PT . . . . . . 7-2 Money (3.precis) write to TTY - LWM3T . . . . . . 7-2 Money - Read 2.precis from string - LRM . . . . . 10-2 Money - Read 2.precis from TTY - LRMT . . . . . . 10-2 Money - Write 2.precis to string - LWM . . . . . . 10-2 Money - Write 2.precis to string - LWMD . . . . . 10-2 Money - Write 2.precis to string - LWMDP . . . . . 10-2 Money - Write 2.precis to string - LWMP . . . . . 10-2 Money - Write 2.precis to TTY - LWMDPT . . . . . . 10-1 Money - Write 2.precis to TTY - LWMDT . . . . . . 10-2 Money - Write 2.precis to TTY - LWMPT . . . . . . 10-1 Money - Write 2.precis to TTY - LWMT . . . . . . . 10-2 Money Format Description . . . . . . . . . . . . . 2-1 Money Routines - 3.precision . . . . . . . . . . . 7-1 MONTH offset (dateblock) . . . . . . . . . . . . . 3-1 Moving 3.precis numbers round - LMOV3 . . . . . . 9-2 Multiply 2.precis integer * 1.precis - LMUL21 . . 12-1 Multiply 2.precis integer * 2.precis - LMUL22 . . 12-1 N12FIL - Fortran input and output . . . . . . . . 2-5 Name of day to TTY - LWDAY . . . . . . . . . . . . 4-2 Name of day to TTY - LWDAYT . . . . . . . . . . . 4-2 Negation of 2.precis integer - LNEG2 . . . . . . . 12-2 Nomenclature . . . . . . . . . . . . . . . . . . . 2-1 Number to 3 rad50 digits - LDIG3 . . . . . . . . . 6-4 Print a prompt - LPRINT . . . . . . . . . . . . . 15-3 Rad50 - 3 digits from number - LDIG3 . . . . . . . 6-4 Radix50 (filename set) read from string - LR50F . 6-3 Radix50 (filename set) read from TTY - LR50FT . . 6-3 Radix50 (full set) read from string - LR50 . . . . 6-3 Radix50 (full set) read from TTY - LR50T . . . . . 6-3 Radix50 (symbol set) read from string - LR50S . . 6-3 Radix50 (symbol set) read from TTY - LR50ST . . . 6-3 CVLLIB Manual - Fortran Section Page I-9 Radix50 - Write (file set) to string - LW50F . . . 6-2 Radix50 - Write (file set) to TTY - LW50FT . . . . 6-2 Radix50 - Write to string - LW50 . . . . . . . . . 6-3 Radix50 - Write to TTY - LW50T . . . . . . . . . . 6-2 Radix50 code interpretation . . . . . . . . . . . 6-1 Radix50 Formats . . . . . . . . . . . . . . . . . 6-1 Radix50 from ascii conversion - LCA50 . . . . . . 6-3 Radix50 to ascii conversion - LCA50 . . . . . . . 6-3 Random number generator - LIRAN . . . . . . . . . 15-4 Random number initialization - LRNSET . . . . . . 15-4 Read 2.precis dec from string - LRD2 . . . . . . . 11-4 Read 2.precis dec from TTY - LRD2T . . . . . . . . 11-3 Read 2.precis dec oct or hex from string - LRN2 . 11-3 Read 2.precis dec oct or hex from TTY - LRN2T . . 11-3 Read 2.precis hex from string - LRH2 . . . . . . . 11-4 Read 2.precis hex from TTY - LRH2T . . . . . . . . 11-4 Read 2.precis money from string - LRM . . . . . . 10-2 Read 2.precis money from TTY - LRMT . . . . . . . 10-2 Read 2.precis oct from string - LR82 . . . . . . . 11-4 Read 2.precis oct from TTY - LR82T . . . . . . . . 11-4 Read 2.precis signed dec from string - LRD2S . . . 11-4 Read 2.precis signed dec from TTY - LRD2ST . . . . 11-3 Read 2.precis signed oct from string - LR82S . . . 11-4 Read 2.precis signed oct from TTY - LR82ST . . . . 11-4 Read 3.precis from string - LRD3 . . . . . . . . . 8-2 Read 3.precis from TTY - LRD3T . . . . . . . . . . 8-2 Read 3.precis money from string - LRM3 . . . . . . 7-3 Read 3.precis money from TTY - LRM3T . . . . . . . 7-2 Read answer from TTY - LYES . . . . . . . . . . . 15-4 Read date from string - LRDAT . . . . . . . . . . 4-3 Read date from system - LRSDAT . . . . . . . . . . 4-2 Read date from TTY - LRDATT . . . . . . . . . . . 4-3 Read dec from string - LRD . . . . . . . . . . . . 13-3 Read dec from TTY - LRDT . . . . . . . . . . . . . 13-3 Read dec signed from string - LRDS . . . . . . . . 13-3 Read dec signed from TTY - LRDST . . . . . . . . . 13-3 Read filename from string - LRF . . . . . . . . . 6-2 Read filename from TTY - LRFT . . . . . . . . . . 6-2 Read filename with defaults from string - LRFD . . 6-2 Read filename with defaults from TTY - LRFDT . . . 6-2 Read hex from string - LRH . . . . . . . . . . . . 13-4 Read hex from TTY - LRHT . . . . . . . . . . . . . 13-4 Read line from TTY - LTLIN . . . . . . . . . . . . 15-3 Read oct dec or hex integer from string - LRN . . 13-3 Read oct dec or hex integer from TTY - LRNT . . . 13-3 Read oct from string - LR8 . . . . . . . . . . . . 13-4 Read oct from TTY - LR8T . . . . . . . . . . . . . 13-4 Read oct signed from string - LR8S . . . . . . . . 13-4 Read oct signed from TTY - LR8ST . . . . . . . . . 13-4 Read radix50 (filename set) from string - LR50F . 6-3 Read radix50 (filename set) from TTY - LR50FT . . 6-3 Read radix50 (full set) from string - LR50 . . . . 6-3 Read radix50 (full set) from TTY - LR50T . . . . . 6-3 Read radix50 (symbol set) from string - LR50S . . 6-3 CVLLIB Manual - Fortran Section Page I-10 Read radix50 (symbol set) from TTY - LR50ST . . . 6-3 Read time from string - LRTIM . . . . . . . . . . 5-2 Read time from system - LRSTIM . . . . . . . . . . 5-2 Read time from TTY - LRTIMT . . . . . . . . . . . 5-2 Read Yes/No answer from TTY - LYESNO . . . . . . . 15-4 Reading (generally) . . . . . . . . . . . . . . . 2-4 Reading DATES . . . . . . . . . . . . . . . . . . 4-1 Return R0/-1 if CS - LRETC . . . . . . . . . . . . 16-4 Routines for DATE conversion . . . . . . . . . . . 4-1 RT11 Time . . . . . . . . . . . . . . . . . . . . 5-1 RTDAT offset (dateblock) . . . . . . . . . . . . . 3-1 RTIM1 offset (timeblock) . . . . . . . . . . . . 3-2 RTIM2 offset (timeblock) . . . . . . . . . . . . 3-2 SECS offset (timeblock) . . . . . . . . . . . . 3-2 Set bits in JSW - JSWSET . . . . . . . . . . . . . 15-4 Single-Precision Integer I/O . . . . . . . . . . . 13-1 SIZE offset (fileblock) . . . . . . . . . . . . 3-3 Size Conversion Routines . . . . . . . . . . . . . 15-1 Spaces and Tabs preceding fields . . . . . . . . . 2-4 Special Block Format - DATE . . . . . . . . . . . 3-1 Special Block Format - TIME . . . . . . . . . . . 3-2 Special Block Formats . . . . . . . . . . . . . . 3-1 Special Block Formats - FILENAME . . . . . . . . . 3-3 Special Mode for TTY - TSPM . . . . . . . . . . . 15-3 String - trim left - LLTRIM . . . . . . . . . . . 15-4 String - trim right - LRTRIM . . . . . . . . . . . 15-4 String Comparison Routines . . . . . . . . . . . . 14-1 Subroutines, Ancillary . . . . . . . . . . . . . . 16-1 Subtraction of 2.precis integers - LSUB2 . . . . . 12-1 SYSLIB INTEGER*4 Comparison . . . . . . . . . . . 11-1 System date reading - LRSDAT . . . . . . . . . . . 4-2 System date to string - LWSDAT . . . . . . . . . . 4-2 System date to TTY - LWSDTT . . . . . . . . . . . 4-2 System time to string - LWSTIM . . . . . . . . . . 5-2 System time to TTY - LWSTMT . . . . . . . . . . . 5-1 TCLOCK offset (timeblock) . . . . . . . . . . . . 3-2 TCRLF - Type . . . . . . . . . . . . . . 15-2 Terminal Buffer . . . . . . . . . . . . . . . . . 3-3 Terminal I/O . . . . . . . . . . . . . . . . . . . 3-3 Terminal I/O and Command Files . . . . . . . . . . 3-3 Terminal line input - LTLIN . . . . . . . . . . . 15-3 Terminal lower case - TLC . . . . . . . . . . . . 15-2 Terminal Special Mode - TSPM . . . . . . . . . . . 15-3 Terminal upper case - TUC . . . . . . . . . . . . 15-2 TICKS offset (timeblock) . . . . . . . . . . . . 3-2 TIMBLK Block . . . . . . . . . . . . . . . . . . . 3-2 Time - Convert RT11 to words . . . . . . . . . . . 5-2 Time - Convert words to RT11 - LCWTR . . . . . . . 5-3 Time - Read from string - LRTIM . . . . . . . . . 5-2 Time - read from system - LRSTIM . . . . . . . . . 5-2 Time - Read from TTY - LRTIMT . . . . . . . . . . 5-2 Time - Write system time to string - LWSTIM . . . 5-2 CVLLIB Manual - Fortran Section Page I-11 Time - Write system time to TTY - LWSTMT . . . . . 5-1 Time - Write to string - LWTIM . . . . . . . . . . 5-2 Time - Write to TTY - LWTIMT . . . . . . . . . . . 5-2 TIME Block Format . . . . . . . . . . . . . . . . 3-2 Time Formats . . . . . . . . . . . . . . . . . . . 5-1 TIOW - TTY I/O wait . . . . . . . . . . . . . . . 15-3 TLC - TTY lower case . . . . . . . . . . . . . . . 15-2 TLINB - User alteration . . . . . . . . . . . . . 3-3 TLOUB - User alteration . . . . . . . . . . . . . 3-3 TNIOW - TTY No I/O Wait . . . . . . . . . . . . . 15-3 TNSPM - Reset TTY Special Mode . . . . . . . . . . 15-3 Trim left of string - LLTRIM . . . . . . . . . . . 15-4 Trim right of string - LRTRIM . . . . . . . . . . 15-4 Triple-precis * 1.precis multiply - LMUL31 . . . . 9-1 Triple-precis * 3.precis multiply - LMUL33 . . . . 9-1 Triple-precis / 1.precis divide - LDIV31 . . . . . 9-1 Triple-precis / 3.precis divide - LDIV33 . . . . . 9-1 Triple-precis addition - LADD3 . . . . . . . . . . 9-2 Triple-precis money read from string - LRM3 . . . 7-3 Triple-precis money read from TTY - LRM3T . . . . 7-2 Triple-precis money write to string - LWM3 . . . . 7-2 Triple-precis money write to string - LWM3D . . . 7-2 Triple-precis money write to string - LWM3DP . . . 7-2 Triple-precis money write to string - LWM3P . . . 7-2 Triple-precis money write to TTY - LWM3DT . . . . 7-2 Triple-precis money write to TTY - LWM3DX . . . . 7-1 Triple-precis money write to TTY - LWM3PT . . . . 7-2 Triple-precis money write to TTY - LWM3T . . . . . 7-2 Triple-precis negation - LNEG3 . . . . . . . . . . 9-2 Triple-precis read from string - LRD3 . . . . . . 8-2 Triple-precis read from TTY - LRD3T . . . . . . . 8-2 Triple-precis replacement - LMOV3 . . . . . . . . 9-2 Triple-precis subtraction - LSUB3 . . . . . . . . 9-2 Triple-precis write to string - LWD3 . . . . . . . 8-2 Triple-precis write to string - LWD3P . . . . . . 8-1 Triple-precis write to TTY - LWD3PT . . . . . . . 8-1 Triple-precis write to TTY - LWD3T . . . . . . . . 8-1 Triple-Precision Arithmetic . . . . . . . . . . . 9-1 Triple-precision comparison - LCMP3 . . . . . . . 9-2 Triple-precision Integers . . . . . . . . . . . . 8-1 Triple-Precision limits . . . . . . . . . . . . . 7-1 Triple-Precision Money Routines . . . . . . . . . 7-1 Triple-Precision Value Limit . . . . . . . . . . . 8-1 TSPM - TTY Special Mode . . . . . . . . . . . . . 15-3 TTY No I/O Wait - TNIOW . . . . . . . . . . . . . 15-3 TTYIN vs GTLIN TTY Input . . . . . . . . . . . . . 3-3 TUC - TTY upper case . . . . . . . . . . . . . . . 15-2 Type - TCRLF . . . . . . . . . . . . . . 15-2 Type a prompt - LPRINT . . . . . . . . . . . . . . 15-3 Type characters - LCHR . . . . . . . . . . . . . . 15-3 Update History . . . . . . . . . . . . . . . . . . 1-1 Upper case from TTY - TUC . . . . . . . . . . . . 15-2 CVLLIB Manual - Fortran Section Page I-12 Various Additional Routines . . . . . . . . . . . 15-1 Write 2.precis dec to string - LWD2 . . . . . . . 11-2 Write 2.precis dec to string - LWD2P . . . . . . . 11-1 Write 2.precis dec to TTY - LWD2PT . . . . . . . . 11-1 Write 2.precis dec to TTY - LWD2T . . . . . . . . 11-1 Write 2.precis hex to string - LWH2 . . . . . . . 11-3 Write 2.precis hex to terminal - LWH2T . . . . . . 11-3 Write 2.precis money to string - LWM . . . . . . . 10-2 Write 2.precis money to string - LWMD . . . . . . 10-2 Write 2.precis money to string - LWMDP . . . . . . 10-2 Write 2.precis money to string - LWMP . . . . . . 10-2 Write 2.precis money to TTY - LWMDPT . . . . . . . 10-1 Write 2.precis money to TTY - LWMDT . . . . . . . 10-2 Write 2.precis money to TTY - LWMPT . . . . . . . 10-1 Write 2.precis money to TTY - LWMT . . . . . . . . 10-2 Write 2.precis oct to string - LW82 . . . . . . . 11-2 Write 2.precis oct to string - LW82P . . . . . . . 11-2 Write 2.precis oct to string - LW82S . . . . . . . 11-2 Write 2.precis oct to string - LW82SP . . . . . . 11-2 Write 2.precis oct to TTY - LW82PT . . . . . . . . 11-2 Write 2.precis oct to TTY - LW82ST . . . . . . . . 11-2 Write 2.precis oct to TTY - LW82SX . . . . . . . . 11-2 Write 2.precis oct to TTY - LW82T . . . . . . . . 11-2 Write 3.precis money to string - LWM3 . . . . . . 7-2 Write 3.precis money to string - LWM3D . . . . . . 7-2 Write 3.precis money to string - LWM3DP . . . . . 7-2 Write 3.precis money to string - LWM3P . . . . . . 7-2 Write 3.precis money to TTY - LWM3DT . . . . . . . 7-2 Write 3.precis money to TTY - LWM3DX . . . . . . . 7-1 Write 3.precis money to TTY - LWM3PT . . . . . . . 7-2 Write 3.precis money to TTY - LWM3T . . . . . . . 7-2 Write 3.precis to string - LWD3 . . . . . . . . . 8-2 Write 3.precis to string - LWD3P . . . . . . . . . 8-1 Write 3.precis to TTY - LWD3PT . . . . . . . . . . 8-1 Write 3.precis to TTY - LWD3T . . . . . . . . . . 8-1 Write a prompt - LPRINT . . . . . . . . . . . . . 15-3 Write ascii char to string - LWA . . . . . . . . . 15-2 Write ascii char to TTY - LWAT . . . . . . . . . . 15-2 Write characters - LCHR . . . . . . . . . . . . . 15-3 Write date to string - LWDAT . . . . . . . . . . . 4-2 Write date to TTY - LWDATT . . . . . . . . . . . . 4-2 Write dec to string - LWD . . . . . . . . . . . . 13-1 Write dec to string - LWDP . . . . . . . . . . . . 13-1 Write dec to TTY - LWDPT . . . . . . . . . . . . . 13-1 Write dec to TTY - LWDT . . . . . . . . . . . . . 13-1 Write filename to string - LWF . . . . . . . . . . 6-2 Write filename to TTY - LWFT . . . . . . . . . . . 6-1 Write hex to string - LWH . . . . . . . . . . . . 13-2 Write hex to terminal - LWHT . . . . . . . . . . . 13-2 Write name of day to string - LWDAY . . . . . . . 4-2 Write name of day to TTY - LWDAYT . . . . . . . . 4-2 Write oct signed to string - LW8S . . . . . . . . 13-2 Write oct signed to string - LW8SP . . . . . . . . 13-2 CVLLIB Manual - Fortran Section Page I-13 Write oct signed to TTY - LW8SPT . . . . . . . . . 13-1 Write oct signed to TTY - LW8ST . . . . . . . . . 13-2 Write oct to string - LW8 . . . . . . . . . . . . 13-2 Write oct to string - LW8P . . . . . . . . . . . . 13-2 Write oct to TTY - LW8PT . . . . . . . . . . . . . 13-1 Write oct to TTY - LW8T . . . . . . . . . . . . . 13-2 Write radix50 (file set) to string - LW50F . . . . 6-2 Write radix50 (file set) to TTY - LW50FT . . . . . 6-2 Write radix50 to string - LW50 . . . . . . . . . . 6-3 Write radix50 to TTY - LW50T . . . . . . . . . . . 6-2 Write system date to string - LWSDAT . . . . . . . 4-2 Write system date to TTY - LWSDTT . . . . . . . . 4-2 Write system time to string - LWSTIM . . . . . . . 5-2 Write system time to TTY - LWSTMT . . . . . . . . 5-1 Write time to string - LWTIM . . . . . . . . . . . 5-2 Write time to TTY - LWTIMT . . . . . . . . . . . . 5-2 Write today and date to string - LTODAY . . . . . 4-2 Write today and date to TTY - LTODAT . . . . . . . 4-2 Writing DATES . . . . . . . . . . . . . . . . . . 4-1 Writing to a string . . . . . . . . . . . . . . . 2-4 YEAR offset (dateblock) . . . . . . . . . . . . . 3-1