.COMMENT**************************************************************** .COMMENT * .COMMENT VAX/VMS CHARACTER STRING LIBRARY USER'S MANUAL * .COMMENT * .COMMENT**************************************************************** .COMMENT * .COMMENT TITLE AND REVISION PAGES * .COMMENT * .COMMENT**************************************************************** .NO NUMBER .CENTER ;MOSTEK VAX/VMS CHARACTER STRING LIBRARY USER'S GUIDE .PAGE .CENTER ;MOSTEK VAX/VMS CHARACTER STRING LIBRARY USER'S GUIDE .PAGE .LITERAL .END LITERAL .CENTER ;MOSTEK VAX/VMS CHARACTER STRING LIBRARY USER'S GUIDE .SKIP 3 .CENTER ;FOR .SKIP 3 .CENTER ;SOFTWARE RELEASE 2.0 .PAGE .CENTER 70;CONTENTS .SKIP 2 .REQUIRE "STRING.RNT" .AUTOPARAGRAPH .AUTOSUBTITLE .LEFT MARGIN 0 .NUMBER PAGE 1 .PAGE SIZE 58,60 .PAGE .NUMBER PAGE 1 .COMMENT**************************************************************** .COMMENT * .COMMENT GENERAL INFORMATION * .COMMENT * .COMMENT**************************************************************** .SUBTITLE MOSTEK VAX/VMS CHARACTER STRING LIBRARY .CHAPTER GENERAL INFORMATION .DISPLAY CHAPTER .DATE .PAGE .HEADER LEVEL 1 SUMMARY .SKIP 5 This is release 2.0 of the MOSTEK Character String Library. This library was originally developed during the summer of 1979 as an aid in the development of the MOSTEK Interactive MOSFET Model Optimizer, but has rapidly grown into an integral portion of the interactive software development base on the VAX-11/780. These subroutines will significantly reduce program development time, while at the same time increasing program readability. Examples of these subroutines in use may be found throughout the MOSTEK Interactive MOSFET Model Optimizer, available from Steve Hamm. .PAGE .HEADER LEVEL 1 IMPLEMENTATION .SKIP 5 The character string library is implemented as a series of FORTRAN and MACRO modules which reside in SYS$SYSDISK:[SYSLIB.MOSTEK]. These modules are then compiled/assembled and then placed in the system library SYS$SYSDISK:[SYSLIB]STARLET.OLB. At this point the modules become globally defined, and are automatically included in a user's program at LINK time if they are referenced. This allows the general user population the benefits of a shared object library with none of the overhead associated with its initial generation and debugging. Users are encouraged to examine and study the [SYSLIB.MOSTEK] subdirectory and the character string library functions contained in the STRING.FOR module. This source module conforms to strict Mostek coding practices and should serve as a guide to writing effective and well documented user application programs. Any questions or comments regarding the character string library should be directed to the author, Kevin Klughart (CAD x8813). In addition, it should be mentioned that any user-written subroutine which conforms to Mostek coding practices and which demonstrates a diverse user base will be seriously considered for inclusion into the existing character string library. .PAGE .CENTER ;SUMMARY OF STRING LIBRARY FUNCTIONS .SKIP 5 .CENTER ;CENTER .SKIP Centers character strings for titles, etc. .SKIP 2 .CENTER ;DECFMT .SKIP Right-justified INTEGER*4 to character string conversion. .SKIP 2 .CENTER ;DECODE__INTEGER .SKIP Converts a character string to an INTEGER*4 number. Similar to FORTRAN DECODE, but modified for use in an interactive environment. .SKIP 2 .CENTER ;DECODE__NUMBER .SKIP Converts a character string to a REAL*8 number. Similar to FORTRAN DECODE, but modified for use under VMS Fortran. .SKIP 2 .CENTER ;DELETE__BLANKS .SKIP Deletes all blanks from a character string. .SKIP 2 .CENTER ;DELETE__CONTROL .SKIP Deletes all control characters from a given character string. .SKIP 2 .CENTER ;ENGFMT .SKIP REAL*8 to Engineering notation character string conversion. .SKIP 2 .CENTER ;EXPFMT .SKIP REAL*8 to Exponential notation character string conversion. .SKIP 2 .CENTER ;FIRST .SKIP Finds the first non-blank character position in a character string. .SKIP 2 .CENTER ;GET__WORD .SKIP Parses the first non-blank word from a character string. .SKIP 2 .CENTER ;HEXFMT .SKIP INTEGER*4 to hexadecimal character string conversion. .SKIP 2 .CENTER ;INTFMT .SKIP Left-justified INTEGER*4 to character string conversion. .SKIP 2 .CENTER ;LENGTH .SKIP Finds the last non-blank character position in a character string (logical string length). .SKIP 2 .CENTER ;METFMT .SKIP REAL*8 to Metric notation conversion. .SKIP 2 .CENTER ;MOVC3 .SKIP General character move subroutine (emulates VAX MOVC3 instruction). .SKIP 2 .CENTER ;MOVC5 .SKIP General character move-with-pad subroutine (emulates VAX MOVC5 instruction). .SKIP 2 .CENTER ;PARSE .SKIP Performs an indexed string list search (similar in nature to the FORTRAN INDEX function, but applies to string lists). .SKIP 2 .CENTER ;UPPER__CASE .SKIP Transforms lower-case characters to upper-case characters and strips parity bits. .COMMENT**************************************************************** .COMMENT * .COMMENT DESCRIPTIONS OF EACH STRING LIBRARY ELEMENT * .COMMENT * .COMMENT**************************************************************** .CHAPTER CHARACTER STRING LIBRARY DESCRIPTION .DISPLAY CHAPTER .PAGE Following is a detailed description of each member of the Mostek VAX/VMS character string library. Reference the source code or contact the author for additional information. .PAGE .HEADER LEVEL 1 CHARACTER*(*) FUNCTION CENTER .SKIP 5 ARGUMENTS: (STRING) .SKIP 2 .LEFT MARGIN +12 STRING: Character string to be returned as a centered character string of length determined by the physical length definition of the CENTER function in the user's program. .LEFT MARGIN -12 .SKIP 2 This function is used to center text for use in headings, titles, etc. It must be declared in the calling program to be of type CHARACTER and must have a physical length corresponding to the width of the page to be used to print the passed character string. Note that alternate entrypoints (CEN040, CEN066, CEN080, CEN132) exist such that several page widths may be accomodated within a single program. For example: .SKIP 2 .NOFILL .NOJUSTIFY CHARACTER*80 CEN080 CHARACTER*40 CEN040 CHARACTER*21 CENTER .SKIP STRING1=CENTER('***TEST***') STRING2=CENTER('***TEST***') STRING3=CENTER('***TEST***') .FILL .JUSTIFY .SKIP Upon completion, the above code segment would put 21 characters in STRING1, 40 characters in STRING2, and 80 characters in STRING3. In all cases, the text '***TEST***' would appear in the center of the character string. .SKIP 5 NOTE: .LEFT MARGIN +12 If the passed character string is too long to fit in the declared width of the CENTER function within the calling program, the passed character string is truncated to the right. .LEFT MARGIN -12 .PAGE .HEADER LEVEL 1 SUBROUTINE DECFMT .SKIP 5 ARGUMENTS: (NUMBER,STRING,SIGFIG) .LEFT MARGIN +12 .SKIP 2 NUMBER: INTEGER*4 number to be converted to decimal blank-filled character format. .SKIP STRING: Character string to receive the character representation of INTEGER*4 argument NUMBER. The destination character string will be blank filled and right-justified, just as a normal FORTRAN FORMAT statement would produce. .SKIP SIGFIG: INTEGER*4 number of significant figures to be displayed. This argument represents the total field width of the character string produced. .LEFT MARGIN -12 .SKIP 2 This subroutine is useful in performing INTEGER*4 to character conversion in which the number to be converted must be right justified and blank filled to fit a specific output field. If the passed character string is negative, the first non-blank character in argument STRING will be '-'; otherwise no leading sign is produced and the sign position will be blank. .PAGE .HEADER LEVEL 1 SUBROUTINE DECODE__HEXDEC .SKIP 5 ARGUMENTS: (STRING,NUMBER,NODATA,ERROR) .LEFT MARGIN +12 .SKIP 2 STRING: Input character string containing an alphanumeric character string in hexadecimal longword format. .SKIP NUMBER: INTEGER*4 variable into which the decoded result is to be placed. .SKIP NODATA: A LOGICAL*4 flag which is set TRUE if the passed character string is devoid of character data. If set, the NUMBER argument is returned as 0. If the passed character string contains any non-blank characters, NODATA is set FALSE on exit. .SKIP ERROR: A LOGICAL*4 flag which is set TRUE if a numeric conversion error was encountered while decoding the passed character string. If no error occurred, ERROR is set FALSE on exit. .LEFT MARGIN -12 .SKIP 2 This subroutine is used to convert an alphanumeric hexadecimal character string to INTEGER*4 LONGWORD format. This enables the user to manipulate character data in all command parsers with little difficulty in converting any embedded numeric data to the correct internal format. Note that the calling sequence for this routine is identical to that of the DECODE__INTEGER and DECODE__NUMBER subroutines described later in this manual. .PAGE .HEADER LEVEL 1 SUBROUTINE DECODE__INTEGER .SKIP 5 ARGUMENTS: (STRING,NUMBER,NODATA,ERROR) .LEFT MARGIN +12 .SKIP 2 STRING: Input character string containing a numeric character string in decimal format. .SKIP NUMBER: INTEGER*4 variable into which the decoded result is to be placed. .SKIP NODATA: A LOGICAL*4 flag which is set TRUE if the passed character string is devoid of character data. If set, the number argument is returned as 0. If the passed character string contains any non-blank characters, NODATA is set FALSE on exit. .SKIP ERROR: A LOGICAL*4 flag which is set TRUE if a numeric conversion error was encountered while decoding the passed character string. If no error occurred, ERROR is set FALSE on exit. .LEFT MARGIN -12 .SKIP 2 This subroutine is used to convert a numeric character string to INTEGER*4 LONGWORD format. Functionally equivalent to the DECODE__HEXDEC subroutine, except that this routine deals with integer numeric character strings rather than hexadecimal character strings. .PAGE .HEADER LEVEL 1 SUBROUTINE DECODE__NUMBER .SKIP 5 ARGUMENTS: (STRING,NUMBER,NODATA,ERROR) .SKIP 2 .LEFT MARGIN +12 STRING: Input character string containing a numeric character string in integer, real, or double precision format. .SKIP NUMBER: A REAL*8 variable into which the decoded result is to be placed. .SKIP NODATA: A LOGICAL*4 flag which is set TRUE if the passed character string is devoid of character data. If set, the NUMBER argument is returned as +0.0D+00. If the passed character string contains any nonblank characters, NODATA is set FALSE on exit. .SKIP ERROR: A LOGICAL*4 flag which is set TRUE if a numeric conversion error was encountered while decoding the passed character string. If no error occurred, ERROR is set FALSE on exit. .LEFT MARGIN -12 .SKIP 2 This subroutine closely models that of the DECODE__INTEGER utility described previously. It is functionally equivalent except for the fact that this version of the conversion utility assumes that the passed character string contains an REAL*8 number which is to be converted to internal VAX floating point and returned to the user in the NUMBER argument. This utility is the preferred alternative to the use of the VAX FORTRAN DECODE statement, as VAX FORTRAN incorrectly converts a character string if it does not contain a decimal point in the mantissa. For example, '1E10' and '100' are both incorrectly converted by VAX FORTRAN when used with a formatted floating point DECODE statement. .SKIP 2 NOTE: .LEFT MARGIN +12 .SKIP The total width of the character string passed (last position - first position + 1) must be less than or equal to 25 characters for the DECODE__NUMBER subroutine to function properly. .LEFT MARGIN -12 .PAGE .HEADER LEVEL 1 SUBROUTINE DELETE__BLANKS .SKIP 5 ARGUMENTS: (INPUT__STRING) .SKIP 2 .LEFT MARGIN +12 INPUT__STRING: Passed character string in which leading and embedded blanks are to be removed. .LEFT MARGIN -12 .SKIP 2 This subroutine is useful in removing leading and embedded blanks from a passed character variable. Upon exit, the passed character variable will have no leading or embedded blanks, and will have blanks following all non-blank characters (i.e., trailing blanks). .PAGE .HEADER LEVEL 1 SUBROUTINE DELETE__CONTROL .SKIP 5 ARGUMENTS: (STRING) .LEFT MARGIN +12 .SKIP 2 STRING: Passed character string in which all control characters are to be removed. Control characters are herein defined as characters less than ASCII '20'X and the DELETE ('7F'X) key. The parity bit is also forced to 0 on all characters in the passed character string. .LEFT MARGIN -12 .SKIP 2 This subroutine is useful in removing control characters from a character variable. Upon exit, the passed character string will have all parity bits set to 0 and all control characters removed. .PAGE .HEADER LEVEL 1 SUBROUTINE ENGFMT .SKIP 5 ARGUMENTS: (NUMBER,STRING,SIGFIG) .SKIP 2 .LEFT MARGIN +12 NUMBER: REAL*8 number to be converted to engineering format. .SKIP STRING: Character string to receive the character representation of argument NUMBER. .SKIP SIGFIG: INTEGER*4 number of significant figures to be displayed. The total field width produced will be SIGFIG+6. .LEFT MARGIN -12 .SKIP 2 This subroutine performs specialized REAL*8 to character conversion in that it assures that the exponent displayed will be an even integral multiple of 3. If the exponent is 0, then the number is printed with no exponent. If the number of significant figures is greater than 15, it is assumed to be 15. If the number of significant figures is such that a true engineering notation format cannot be obtained, then the user value is overridden and the field witdh will be acordingly larger. .PAGE .HEADER LEVEL 1 SUBROUTINE EXPFMT .SKIP 5 ARGUMENTS: (NUMBER,STRING,SIGFIG) .SKIP 2 .LEFT MARGIN +12 NUMBER: REAL*8 number to be converted to exponential format .SKIP STRING: Character string to receive the character representation of argument NUMBER. .SKIP SIGFIG: INTEGER*4 number of significant figures to be displayed. The total field width produced will be SIGFIG+6. .LEFT MARGIN -12 .SKIP 2 This subroutine is identical to that of ENGFMT except that the output is true exponential notation and no attempt is made to convert to engineering notation. As before, if the exponent is zero, it is not printed. The same restrictions apply to EXPFMT as to ENGFMT with regards to the SIGFIG argument. .PAGE .HEADER LEVEL 1 INTEGER*4 FUNCTION FIRST .SKIP 5 ARGUMENTS: (STRING) .SKIP 2 .LEFT MARGIN +12 STRING: Character string to be searched for first valid non-blank character. .SKIP FIRST(STRING): Position of first non-blank character. If the entire character string is blank, the value returned is 0. FIRST MUST BE DECLARED INTEGER*4 IN THE CALLING PROGRAM. .LEFT MARGIN -12 .SKIP 2 The function FIRST is useful in parsing user commands which are delimited by blanks. When used in conjunction with the LENGTH function, the FIRST function will enable the programmer to quickly and efficiently determine the total effective length of the character string in question. .PAGE .HEADER LEVEL 1 SUBROUTINE GET__WORD .SKIP 5 ARGUMENTS: (STRING,WORD) .SKIP 2 .LEFT MARGIN +12 STRING: Master character string from which argument WORD is to be parsed. Upon return, argument STRING contains all characters except the WORD which has been removed from it by GET__WORD. The only acceptable word delimiter is the blank (space) character. .SKIP WORD: First word delimited by blanks which was found within STRING. If STRING was entirely blank, WORD will be entirely blank. Otherwise, WORD will contain a delimited representation of the first blank-delimited word within STRING. .LEFT MARGIN -12 .SKIP 2 This subroutine is very useful in parsing user commands on a word by word basis. The end-of-commandlist condition may easily be tested for by checking if LENGTH(WORD) is 0, signifying that the parsed word is entirely blank. Reference the main command processor of the Mostek Interactive Mosfet Optimizer for examples of this subroutine in use. .PAGE .HEADER LEVEL 1 SUBROUTINE HEXFMT .SKIP 5 ARGUMENTS: (NUMBER,STRING,LIMIT) .LEFT MARGIN +12 .SKIP 2 NUMBER: INTEGER*4 number to be converted to hexadecimal character format. .SKIP STRINT: Destination output character string. .SKIP LIMIT: INTEGER*4 variable which contains the number of characters to be placed in the argument STRING. .LEFT MARGIN -12 .SKIP 2 This subroutine is useful in performing INTEGER*4 to hexadecimal character conversion in which leading zeros are desired. Functionally equivalent to DECFMT, INTFMT, and OCTFMT. .PAGE .HEADER LEVEL 1 SUBROUTINE INTFMT .SKIP 5 ARGUMENTS: (NUMBER,STRING,LIMIT) .LEFT MARGIN +12 .SKIP 2 NUMBER: INTEGER*4 number to be converted to integer character format. .SKIP STRING: Destination output character string. .SKIP LIMIT: INTEGER*4 variable which returns the actual number of characters output to STRING. .LEFT MARGIN -12 .SKIP 2 This subroutine is useful in performing INTEGER*4 to character conversion in which no leading blanks are desired. If the passed integer is negative, the first character is '-'; otherwise no leading sign is printed and the first character will be numeric in type. If the physical length of the destination string is less than the number of digits printed, digits to the right are truncated. .PAGE .HEADER LEVEL 1 INTEGER*4 FUNCTION LENGTH .SKIP 5 ARGUMENTS: (STRING) .SKIP 2 .LEFT MARGIN +12 STRING: Character string to be searched for last valid non-blank character. .SKIP LENGTH(STRING): Position of last non-blank character. If the entire character string is blank, the function value returned is 0. LENGTH MUST BE DECLARED INTEGER*4 IN THE CALLING PROGRAM. .LEFT MARGIN -12 .SKIP 2 The function LENGTH is useful in determining the logical length of a character string. The logical string length is defined as the position of the last non-blank character within a given character string. This definition differs from the VAX FORTRAN LEN function, which returns the physical length of a given character string. This physical length is the physical amount of memory (in bytes) which the character string consumes. The logical string length is vital in performing character I/O because without knowledge of the logical length of the string to be read or printed, much needless computation must be performed in either decoding the character string or transmitting it to an output device (CRT). .PAGE .HEADER LEVEL 1 SUBROUTINE METFMT .SKIP 5 ARGUMENTS: (NUMBER,STRING,SIGFIG) .LEFT MARGIN +12 .SKIP 2 NUMBER: REAL*8 number to be converted to Metric notation format. .SKIP STRING: Destination character string. .SKIP SIGFIG: Number of significant figures to be displayed. The output field width will be SIGFIG+5. .LEFT MARGIN -12 .SKIP 2 This subroutine is exactly as that of ENGFMT, except that instead of providing numeric exponents, this subroutine replaces the exponent with a metric postfix as such: .SKIP 2 .NOFILL .LEFT MARGIN +12 MULTIPLIER POSTFIX ---------- ------- +1.0D+12 'T ' - TERA +1.0D+09 'G ' - GIGA +1.0D+06 'MEG' - MEGA +1.0D+03 'K ' - KILO +1.0D+00 ' ' - UNITS +1.0D-03 'M ' - MILLI +1.0D-06 'U ' - MICRO +1.0D-09 'N ' - NANO +1.0D-12 'P ' - PICO +1.0D-15 'F ' - FEMTO .FILL .LEFT MARGIN -12 .SKIP Values larger than +1.0D+15 will cause '*****' to be returned. Values less than +0.001D-15 will cause '0.000F' to be returned. The same restrictions to argument SIGFIG apply here as in EXPFMT and ENGFMT, and the calling conventions for these three subroutines are equivalent. Thus changing from exponential output to engineering format output or metric format output is extremely simple if these three routines are adopted as the standard in numeric conversion for the user's program. .PAGE .HEADER LEVEL 1 SUBROUTINE MOVC3 .SKIP 5 ARGUMENTS: (SRCLEN,SRCADR,DSTADR) .LEFT MARGIN +12 .SKIP 2 SRCLEN: INTEGER*4 variable which contains the number of bytes to be transferred from the source address (SRCADR) to the destination address (DSTADR). The maximum transfer count is 65535 bytes. .SKIP SRCADR: INTEGER*4 variable which contains the starting virtual address of the source operand. Characters will be transferred from the source operand to the destination operand. .SKIP DSTADR: INTEGER*4 variable which contains the starting virtual address of the destination operand. The user program must have write access to this address. .LEFT MARGIN -12 .SKIP 2 This subroutine is a general move character (byte) routine which enables a user to transfer one block of memory to another portion of memory. This routine may be used to transfer character strings, integer or real data, as well as other data structures. A typical example of transferring COUNT bytes from the tenth byte of integer array SOURCE to the sixth byte of character string DESTIN is as follows: .SKIP .NOFILL CALL MOVC3(COUNT,(%LOC(SOURCE)+9),(%LOC(DESTIN)+5)) .FILL .SKIP As can be seen, the offsets placed within the call to the MOVC3 routine were byte in nature and in addition the %LOC function was used to obtain the starting virtual address of each argument of the transfer (SOURCE and DESTIN). .PAGE .HEADER LEVEL 1 INTEGER*4 FUNCTION MOVC5 .SKIP 5 ARGUMENTS: (SRCLEN,SRCADR,FILL,DSTLEN,DSTADR) .LEFT MARGIN +12 .SKIP 2 SRCLEN: INTEGER*4 variable which contains the number of bytes to be transferred from the source address (SRCADR) to the destination address (DSTADR). The maximum transfer count is 65535 bytes. .SKIP SRCADR: INTEGER*4 variable which contains the starting virtual address of the source operand. Characters will be transferred from the source operand to the destination operand. .SKIP FILL: INTEGER*4 variable which contains the fill character to be used to pad the destination buffer if (SRCLEN) < (DSTLEN). .SKIP DSTLEN: INTEGER*4 variable which contains the number of bytes to be received by the destination address (DSTADR) from the source address (SRCADR). The maximum transfer count is 65535 bytes. If the destination buffer length is less than the source buffer length, then the number of characters not transferred will be returned as the INTEGER*4 function value MOVC5(). If the destination buffer length is greater than the source buffer length, the remainder of the destination buffer is filled with the FILL character. .SKIP DSTADR: INTEGER*4 variable which contains the starting virtual address of the destination operand. The user program must have write access to this address. .SKIP MOVC5(): INTEGER*4 function return value. Returns the number of characters not transferred from the source operand to the destination operand. MOVC5 MUST BE DECLARED INTEGER*4 IN THE CALLING PROGRAM. .LEFT MARGIN -12 .SKIP 2 This subroutine is a general move character (BYTE) buffer routine which enables a user to transfer one block of memory to another portion of memory with a specified fill character if the blocks are not of equal length. This routine may be used to initialize blocks of memory, transfer character strings, integer, or real data, as well as other data structures. A typical example of zeroing out a block of memory called DATABUF can be seen as follows: .SKIP .NOFILL CALL MOVC5(0,%LOC(DATABUF),0,DATABUFLEN,%LOC(DATABUF)) .FILL .SKIP A can be seen, the offsets placed within the call to the MOVC5 routine were byte in nature and made use of the %LOC function to determine the starting virtual address of the buffer to be initialized. .PAGE .HEADER LEVEL 1 SUBROUTINE OCTFMT .SKIP 5 ARGUMENTS: (NUMBER,STRING,SIGFIG) .LEFT MARGIN +12 .SKIP 2 NUMBER: INTEGER*4 number to be converted to octal character format. .SKIP STRING: Destination output character string. .SKIP SIGFIG: INTEGER*4 variable which contains the field width to be produced in argument STRING. .LEFT MARGIN -12 .SKIP 2 This subroutine is useful in performing INTEGER*4 to octal character conversion in which leading zeros are desired. This subroutine is functionally equivalent to DECFMT, HEXFMT, and INTFMT. .PAGE .HEADER LEVEL 1 INTEGER*4 FUNCTION PARSE .SKIP 5 ARGUMENTS: (SEARCH__LIST,LIST__START,LIST__LENGTH,STRING) .LEFT MARGIN +12 .SKIP 2 SEARCH__LIST: Character array to be searched for match to argument STRING. .SKIP LIST__START: INTEGER*4 starting index of search in SEARCH__LIST. .SKIP LIST__LENGTH: INTEGER*4 number of entries to be searched in SEARCH__LIST. .SKIP STRING: Character string to search for within SEARCH__LIST. .SKIP PARSE(): Returns the index of the first match between SEARCH__LIST and STRING. If no match is found, the value returned is 0. PARSE MUST BE DECLARED INTEGER*4 IN THE CALLING PROGRAM. .LEFT MARGIN -12 .SKIP 2 This subroutine is a general command string parser which searches for a match between a character string and a master list of character strings. The returned result can be used in a computed GOTO statement to vector to FORTRAN code which processes the command which is present in STRING. .PAGE .HEADER LEVEL 1 SUBROUTINE UPPER__CASE .SKIP 5 ARGUMENTS: (STRING) .LEFT MARGIN +12 .SKIP 2 STRING: Character string in which lower-case characters are to be converted to upper-case characters. Upon return, STRING contains only upper-case characters. .LEFT MARGIN -12 .SKIP 2 This subroutine is very useful in implementing a general command processor because it is vital to be able to support both lower and upper-case terminals in any general command parser. To this end this subroutine enables rapid conversion from lower-case to upper-case characters. This facility is mandatory if a correct match is to occur with either the FORTRAN INDEX function or the PARSE subroutine described previously. .PAGE .CENTER ; End of Manual .PAGE .CENTER ; End of Manual