SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page   0

TABLE OF CONTENTS   



   (2)      45  DECLARATIONS

   (3)     153  FAO - MAIN PROGRAM

   (4)     355  GETCHAR - Routine to get next char from input s

   (5)     403  GETCOUNT - Routine to get repeat-count or field

   (7)     475  CVTASC	- Insert ASCII string

   (8)     614  CVTNUM - Convert numeric parameter to ASCII

   (9)     826  QUICKSERVE - Small service routines

   (10)    964  PERCENT - Time directives and plural 'S'

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page   1

01                                                                                                                               (1)



                                     0000     1 	.TITLE	SYSFAO - FORMATTED ASCII OUTPUT SYSTEM SERVICE

                                     0000     2 	.IDENT	/01/

                                     0000     3 

                                     0000     4 ;

                                     0000     5 ; COPYRIGHT (C) 1977

                                     0000     6 ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASSACHUSETTS 01754

                                     0000     7 ;

                                     0000     8 ; THIS SOFTWARE IS FURNISHED  UNDER A LICENSE FOR USE ONLY ON A SINGLE

                                     0000     9 ; COMPUTER  SYSTEM AND  MAY BE  COPIED ONLY WITH  THE INCLUSION OF THE

                                     0000    10 ; ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE, OR ANY OTHER COPIES THEREOF,

                                     0000    11 ; MAY NOT BE PROVIDED OR  OTHERWISE MADE AVAILABLE TO ANY OTHER PERSON

                                     0000    12 ; EXCEPT FOR USE ON SUCH SYSTEM AND TO ONE WHO AGREES TO THESE LICENSE

                                     0000    13 ; TERMS.  TITLE TO AND  OWNERSHIP OF THE  SOFTWARE  SHALL AT ALL TIMES

                                     0000    14 ; REMAIN IN DEC.

                                     0000    15 ;

                                     0000    16 ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE

                                     0000    17 ; AND SHOULD  NOT BE CONSTRUED  AS A COMMITMENT  BY DIGITAL  EQUIPMENT

                                     0000    18 ; CORPORATION.

                                     0000    19 ;

                                     0000    20 ; DEC ASSUMES  NO  RESPONSIBILITY  FOR  THE USE OR  RELIABILITY OF ITS

                                     0000    21 ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC.

                                     0000    22 

                                     0000    23 ;++

                                     0000    24 ; FACILITY: SYSTEM SERVICE

                                     0000    25 ;

                                     0000    26 ; ABSTRACT:

                                     0000    27 ;

                                     0000    28 ;	This module provides general formatting services.  It converts

                                     0000    29 ;	binary values to octal, hexadecimal, and decimal ASCII

                                     0000    30 ;	representations, and also inserts ASCII strings and converts

                                     0000    31 ;	date and time to ASCII.

                                     0000    32 ;

                                     0000    33 ; ENVIRONMENT:

                                     0000    34 ;

                                     0000    35 ;	FAO runs in the mode of the caller.

                                     0000    36 ;

                                     0000    37 ; AUTHOR: Henry M. Levy	, CREATION DATE: 29-JAN-1977

                                     0000    38 ;

                                     0000    39 ; MODIFIED BY:

                                     0000    40 ;

                                     0000    41 ;	, : VERSION

                                     0000    42 ; 01	- 

                                     0000    43 ;--

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page   2

01              DECLARATIONS                                                                                                     (2)



                                     0000    45 	.SBTTL	DECLARATIONS

                                     0000    46 ;

                                     0000    47 ; INCLUDE FILES:

                                     0000    48 ;

                                     0000    49 

                                     0000    50 ;

                                     0000    51 ; MACROS:

                                     0000    52 ;

                                     0000    53 

                                     0000    54 	$SSDEF				; define system status codes

                                     0000    55 

                                     0000    56 ;

                                     0000    57 ; EQUATED SYMBOLS:

                                     0000    58 ;

                                     0000    59 

                           00000000  0000    60 	ARGCOUNT = 0			; offset to argument count

                           00000004  0000    61 	INDSC	= 4			; offset to input string descriptor

                           00000008  0000    62 	OUTLEN	= 8			; offset to output length

                           0000000C  0000    63 	OUTDSC	= 12			; offset to output buffer descriptor

                           00000010  0000    64 	FIRSTARG = 16			; offset to first conversion param

                                     0000    65 

                           FFFFFFF0  0000    66 	INLEN	= -16			; local offset to input length remaining

                           FFFFFFF4  0000    67 	INPTR	= -12			; local offset to input string pointer

                           FFFFFFF8  0000    68 	LASTVAL = -8			; local offset to last value converted

                           FFFFFFFC  0000    69 	FIELDEND = -4			; local offset to end of defined field

                                     0000    70 

                           0000000D  0000    71 	CR	= 13			; carriage return

                           0000000A  0000    72 	LF	= 10			; line feed

                           00000021  0000    73 	EXCL	= 33			; exclamation ('!')

                           00000009  0000    74 	TAB	= 9			; horizontal tab

                           0000000C  0000    75 	FF	= 12			; form feed

                                     0000    76 

                                     0000    77 ;

                                     0000    78 ; OWN STORAGE:

                                     0000    79 ;

                                     0000    80 

                                 00000000    81 	.PSECT	Y$EXEPAGED

                                     0000    82 

                                     0000    83 ASC_NAMES:

42 41 39 38 37 36 35 34 33 32 31 30  0000    84 	.ASCII	/0123456789ABCDEF/	; ASCII digits

                        46 45 44 43  000C       

                                     0010    85 

                                     0010    86 ;

                                     0010    87 ;	The following table contains the first character for all 

                                     0010    88 ;	FAO conversion directives.  The first part of the table

                                     0010    89 ;	contains the first character for two-character directives,

                                     0010    90 ;	while the second half of the table contains the one-character

                                     0010    91 ;	directives.

                                     0010    92 ;

                                     0010    93 ;	NOTE -- The ordering of this table must be preserved.  The index

                                     0010    94 ;		of the directives found in this table is used to dispatch

                                     0010    95 ;		via a CASE statement in the main program (FAO).  

                                     0010    96 ;		Routine CVTNUM also uses the index to dispatch and to

                                     0010    97 ;		compute the proper radix for the conversion.

                                     0010    98 ;

                                     0010    99 

                                     0010   100 CNTRL_TABLE:

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page   3

01              DECLARATIONS                                                                                                     (2)



                                     0010   101 TWO_CHAR_CNTRLS:

                                 4F  0010   102 	.ASCII	/O/			; octal conversions

                                 58  0011   103 	.ASCII	/X/			; hex conversions

                                 55  0012   104 	.ASCII	/U/			; unsigned decimal

                                 53  0013   105 	.ASCII	/S/			; signed decimal

                                 5A  0014   106 	.ASCII	/Z/			; unsigned decimal zero filled

                                 41  0015   107 	.ASCII	/A/			; ascii insertion directives

                                 25  0016   108 	.ASCII	/%/			; time conversion, or plural indication

                                 2A  0017   109 	.ASCII	/*/			; character repeater

                                     0018   110 ONE_CHAR_CNTRLS:

                                 2B  0018   111 	.ASCII	/+/			; skip argument

                                 2D  0019   112 	.ASCII	/-/			; backup argument

                                 3C  001A   113 	.ASCII	/</			; begin field definition

                                 3E  001B   114 	.ASCII  />/			; end of field definition

                                     001C   115 REPLACE_CHRS:				; these are one or two char replacements

                                 2F  001C   116 	.ASCII	./.			; newline 

                                 5F  001D   117 	.ASCII	/_/			; tab

                                 5E  001E   118 	.ASCII	/^/			; form feed

                                 21  001F   119 	.ASCII	/!/			; insert exclamation

                           00000010  0020   120 CNTRL_LENGTH = .-CNTRL_TABLE		; length of table

                                     0020   121 

                           00000008  0020   122 ONECHAR_INDEX = CNTRL_LENGTH - <ONE_CHAR_CNTRLS - CNTRL_TABLE>

                                     0020   123 

                           0000000C  0020   124 REPL_OFFSET = REPLACE_CHRS - CNTRL_TABLE ; offset of replacement chars

                                     0020   125 

                                     0020   126 STRING_TYPES:

                        46 44 53 43  0020   127 	.ASCII	/CSDF/			; ascii string types

                                     0024   128 DATA_TYPES:

                           4C 57 42  0024   129 	.ASCII	/BWL/			; byte, word , or long

                                     0027   130 PERCENT_STR:

                           54 44 53  0027   131 	.ASCII	/SDT/			; subtypes for % directive

                                     002A   132 FIELDS:

                           20 10 08  002A   133 	.BYTE	8,16,32			; field size for B,W,and L

                                     002D   134 REPLACEMENT:

                        21 0C 09 0A  002D   135 	.BYTE	LF,TAB,FF,EXCL		; simple replacement table

                                     0031   136 

                                     0031   137 ;

                                     0031   138 ; The following array contains the number of Octal and Hex digits in

                                     0031   139 ; byte , word, and longword fields.  The byte digits are first, the

                                     0031   140 ; hex digits starting at the 4'th entry so that the array may be

                                     0031   141 ; context indexed.

                                     0031   142 ;

                                     0031   143 

                                     0031   144 OCT_HEX_DIGITS:

                        00 0B 06 03  0031   145 	.BYTE	3,6,11,0

                           08 04 02  0035   146 	.BYTE	2,4,8

                                     0038   147 

                                     0038   148 RADIX:

                     0A 0A 0A 10 08  0038   149 	.BYTE	8,16,10,10,10		; radix for numeric conversisons

                                     003D   150 

                                     003D   151 

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page   4

01              FAO - MAIN PROGRAM                                                                                               (3)



                                     003D   153 	.SBTTL	FAO - MAIN PROGRAM

                                     003D   154 ;++

                                     003D   155 ; FUNCTIONAL DESCRIPTION:

                                     003D   156 ;

                                     003D   157 ;	This routine is the entry point for the FAO and FAOL system

                                     003D   158 ;	services.   The caller's control string is scanned for control

                                     003D   159 ;	characters ('!').  All other information is simply passed to

                                     003D   160 ;	the output buffer.  If a control directive is found, it is parsed

                                     003D   161 ;	and an action routine is dispatched.

                                     003D   162 ;

                                     003D   163 ; CALLING SEQUENCE:

                                     003D   164 ;

                                     003D   165 ;	CALLS or CALLG	to SYS$FAO or SYS$FAOL

                                     003D   166 ;

                                     003D   167 ; INPUT PARAMETERS:

                                     003D   168 ;

                                     003D   169 ;	INDSC	- The address of a string descriptor for the input

                                     003D   170 ;		  control string.

                                     003D   171 ;	OUTLEN	- The address of a word to receive the length of

                                     003D   172 ;		  the output string

                                     003D   173 ;	OUTDSC	- The address of a string descriptor for the output

                                     003D   174 ;		  buffer.

                                     003D   175 ;	FIRSTARG - For FAOL , this is the address of a list of longword

                                     003D   176 ;		  parameters.  For FAO , this is the first of a 

                                     003D   177 ;		  variable number of parameters which

                                     003D   178 ;		  may have been passed on the call argument list.

                                     003D   179 ;

                                     003D   180 ; IMPLICIT INPUTS:

                                     003D   181 ;

                                     003D   182 ;	none

                                     003D   183 ;

                                     003D   184 ; OUTPUT PARAMETERS:

                                     003D   185 ;

                                     003D   186 ;	OUTLEN	- Word pointed to will receive length of output buffer.

                                     003D   187 ;

                                     003D   188 ; IMPLICIT OUTPUTS:

                                     003D   189 ;

                                     003D   190 ;	none

                                     003D   191 ;

                                     003D   192 ; COMPLETION CODES:

                                     003D   193 ;

                                     003D   194 ;	SS$_NORMAL	- success code, normal return

                                     003D   195 ;	SS$_BUFFEROVF	- output buffer overflow, attempt to write past end of output buffer

                                     003D   196 ;	SS$_BADPARAM	- invalid directive specified

                                     003D   197 ;

                                     003D   198 ; SIDE EFFECTS:

                                     003D   199 ;

                                     003D   200 ;	none

                                     003D   201 ;

                                     003D   202 ;--

                                     003D   203 

                                     003D   204 ;

                                     003D   205 ; Global register usage:

                                     003D   206 ;

                                     003D   207 ;	R7,R8 - scratch registers

                                     003D   208 ;	R9  - number of characters remaining in output buffer

                                     003D   209 ;	R10 - current position in output buffer

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page   5

01              FAO - MAIN PROGRAM                                                                                               (3)



                                     003D   210 ;	R11 - pointer to next conversion parameter 

                                     003D   211 ;

                                     003D   212 ; Locals

                                     003D   213 ;

                                     003D   214 ;	INLEN(FP) - (word) length of input control string

                                     003D   215 ;	INPTR(FP) - address of position in input control string

                                     003D   216 ;

                                     003D   217 

                                     003D   218 ;

                                     003D   219 ; Entry point for call with multiple arguments on stack

                                     003D   220 ;

                                     003D   221 

                                     003D   222 EXE$FAO::

                                     003D   223 

                               0FFC  003D   224 	.WORD	^M<R2,R3,R4,R5,R6,R7,R8,R9,R10,R11>	; save all registers

            5B         10 AC     DE  003F   225 	MOVAL	FIRSTARG(AP),R11	; get address of first argument

                          06     11  0043   226 	BRB	FAO			; go to main routine

                                     0045   227 

                                     0045   228 ;

                                     0045   229 ; Entry point for FAOL call.

                                     0045   230 ;

                                     0045   231 

                                     0045   232 EXE$FAOL::

                                     0045   233 

                               0FFC  0045   234 	.WORD	^M<R2,R3,R4,R5,R6,R7,R8,R9,R10,R11>

            5B         10 AC     D0  0047   235 	MOVL	FIRSTARG(AP),R11	; address of first argument

                                     004B   236 FAO:

                          7E     7C  004B   237 	CLRQ	-(SP)			; save space for LASTVAL and FIELDEND

            7E         04 BC     7D  004D   238 	MOVQ	@INDSC(AP),-(SP)	; save locals on stack

            59         0C BC     7D  0051   239 	MOVQ	@OUTDSC(AP),R9		; load output descriptor into R9,R10

            59            59     3C  0055   240 	MOVZWL	R9,R9			; ensure word length

                                     0058   241 

                                     0058   242 ;

                                     0058   243 ; Look for a control character in the input string.  Copy text

                                     0058   244 ; up to the control, if any , to the output buffer.

                                     0058   245 ;

                                     0058   246 

                                     0058   247 MAIN_SCAN:

                          7E     D4  0058   248 	CLRL	-(SP)			; indicate control not found

         F0 AD            21     3A  005A   249 	LOCC	#EXCL,INLEN(FP),@INPTR(FP) ; search for control char

                       F4 BD         005E       

                          02     13  0060   250 	BEQL	10$			; branch if not found

                          6E     D6  0062   251 	INCL	(SP)			; set indicator to show char. found

                                     0064   252 10$:

         F0 AD            50     A3  0064   253 	SUBW3	R0,INLEN(FP),R6		; calculate bytes to move

                          56         0068       

         F0 AD            50     D0  0069   254 	MOVL	R0,INLEN(FP)		; update input length remaining

            59            56     A2  006D   255 	SUBW	R6,R9			; update and test output length

                          73     19  0070   256 	BLSS	OVERFLOW		; not enough room, error exit

         F4 BD            56     28  0072   257 	MOVC3	R6,@INPTR(FP),(R10)	; move text part of input string

                          6A         0076       

            74            8E     E9  0077   258 	BLBC	(SP)+,DONE		; leave if no controls left

         F4 AD            51     D0  007A   259 	MOVL	R1,INPTR(FP)		; update input address pointer

            5A            53     D0  007E   260 	MOVL	R3,R10			; update output address pointer

                          7A     10  0081   261 	BSBB	GETCHAR			; skip control char

                                     0083   262 

                                     0083   263 ;

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page   6

01              FAO - MAIN PROGRAM                                                                                               (3)



                                     0083   264 ; Parse the directive which has been found in the input string.  Set

                                     0083   265 ; up: R0 = remaining count in CNTRL_TABLE

                                     0083   266 ;     R4 = second char if two-char directive

                                     0083   267 ;     R5 = repeat count

                                     0083   268 ;     R6 = field width

                                     0083   269 ;

                                     0083   270 

                                     0083   271 PARSE_DIRECTIVE:

                                     0083   272 

            55            01     D0  0083   273 	MOVL	#1,R5			; default repeat count is 1

                          52     D4  0086   274 	CLRL	R2			; paren indicator ( not found yet )

                          007F   30  0088   275 	BSBW	GETCOUNT		; pull off count, if any

                          70     10  008B   276 	BSBB	GETCHAR			; get next char from input string

            53            28     91  008D   277 	CMPB	#^A/(/,R3		; was next char a paren?

                          0D     12  0090   278 	BNEQ	20$			; branch if not

                          52     D6  0092   279 	INCL	R2			; set paren found indicator

                          56     D5  0094   280 	TSTL	R6			; was there a repeat count?

                          03     19  0096   281 	BLSS	10$			; no..use default

            55            56     D0  0098   282 	MOVL	R6,R5			; else get repeat count

                                     009B   283 10$:

                          6D     10  009B   284 	BSBB	GETCOUNT		; look for field width

                          5E     10  009D   285 	BSBB	GETCHAR			; get next char

                                     009F   286 20$:

            10            53     3A  009F   287 	LOCC	R3,#CNTRL_LENGTH,CNTRL_TABLE ; check character in table

                     FF6B CF         00A2       

                          39     13  00A5   288 	BEQL	ILLEGAL			; illegal directive exit

            08            50     D1  00A7   289 	CMPL	R0,#ONECHAR_INDEX	; is this a one char directive?

                          05     15  00AA   290 	BLEQ	30$			; yes, don't need any more

                          4F     10  00AC   291 	BSBB	GETCHAR			; get second control char

            54            53     D0  00AE   292 	MOVL	R3,R4			; move to R4 for return

                                     00B1   293 30$:

            02            52     E9  00B1   294 	BLBC	R2,40$			; skip if no paren found

                          47     10  00B4   295 	BSBB	GETCHAR			; else skip paren char

                                     00B6   296 40$:

                                     00B6   297 

            10            50     C3  00B6   298 	SUBL3	R0,#CNTRL_LENGTH,R3	; compute offset for case table

                          53         00B9       

                                     00BA   299 

                                     00BA   300 ;

                                     00BA   301 ; The following  does a BSBB to the case dispatch

                                     00BA   302 ; table.  The service routines do an RSB and return into CASE_LOOP.

                                     00BA   303 ;

                                     00BA   304 

                          02     11  00BA   305 	BRB	CASE_LOOP		; start processing loop

                                     00BC   306 CASE_BSB:

                          05     10  00BC   307 	BSBB	FAO_CASE		; dispatch next directive

                                     00BE   308 CASE_LOOP:

            FB            55     F4  00BE   309 	SOBGEQ	R5,CASE_BSB		; repeat as specified

                          95     11  00C1   310 	BRB	MAIN_SCAN		; else continue string processing

                                     00C3   311 

                                     00C3   312 ;

                                     00C3   313 ; Here is the main dispatch table for dispatching FAO service 

                                     00C3   314 ; routines.  The case is entered via BSBB from CASE_BSB. The routines

                                     00C3   315 ; RSB to CASE_LOOP.  Since the 5 numeric conversion directives all 

                                     00C3   316 ; dispatch to the same routine, the case has a base of 5 and the

                                     00C3   317 ; numeric directives fall through to the statement following the CASE.

                                     00C3   318 ;

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page   7

01              FAO - MAIN PROGRAM                                                                                               (3)



                                     00C3   319 ; Registers R0, R1, and R2 may be scratched by service routines.

                                     00C3   320 ;

                                     00C3   321 

                                     00C3   322 FAO_CASE:

                                     00C3   323 	CASE	R3,<-			; dispatch to service routine

                                     00C3   324 		CVTASC,-		; ascii string insertion

                                     00C3   325 		PERCENT,-		; insert ascii time or plural 'S'

                                     00C3   326 		REPEATIT,-		; repeat character 'n' times

                                     00C3   327 		INCR_ARGPTR,-		; skip next parameter

                                     00C3   328 		DECR_ARGPTR,-		; backup to previous parameter

                                     00C3   329 		STARTFIELD,-		; define fixed length field

                                     00C3   330 		ENDFIELD,-		; terminate fixed length field

                                     00C3   331 		NEWLINE,-		; insert CR/LF

                                     00C3   332 		INSERT_CHAR,-		; insert TAB

                                     00C3   333 		INSERT_CHAR,-		; insert form feed

                                     00C3   334 		INSERT_CHAR,-		; insert '!'

                                     00C3   335 	>,B,#5				; offset start by 5

                                     00DD   336 

                          00CB   31  00DD   337 	BRW	CVTNUM			; dispatch to numeric conversion

                                     00E0   338 

                                     00E0   339 

                                     00E0   340 ILLEGAL: 

            50            14     3C  00E0   341 	MOVZWL	#SS$_BADPARAM,R0	; error return code

                          0C     11  00E3   342 	BRB	FAO_EXIT

                                     00E5   343 OVERFLOW:

            50       0601 8F     3C  00E5   344 	MOVZWL	#SS$_BUFFEROVF,R0	; error return code

                          59     D4  00EA   345 	CLRL	R9			; ensure correct return length

                          03     11  00EC   346 	BRB	FAO_EXIT

                                     00EE   347 DONE:	

            50            01     3C  00EE   348 	MOVZWL	#SS$_NORMAL,R0		; no errors

                                     00F1   349 FAO_EXIT:

                       08 AC     D5  00F1   350 	TSTL	OUTLEN(AP)		; was a return length required?

                          06     13  00F4   351 	BEQL	10$			; branch if not

         0C BC            59     A3  00F6   352 	SUBW3	R9,@OUTDSC(AP),@OUTLEN(AP) ; compute and return output buffer length

                       08 BC         00FA       

                                 04  00FC   353 10$:	RET

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page   8

01              GETCHAR - Routine to get next char from input s                                                                  (4)



                                     00FD   355 	.SBTTL	GETCHAR - Routine to get next char from input string

                                     00FD   356 

                                     00FD   357 ;++

                                     00FD   358 ;

                                     00FD   359 ; FUNCTIONAL DESCRIPTION:

                                     00FD   360 ;

                                     00FD   361 ;	This routine gets the next character from the input control

                                     00FD   362 ;	string, updating the length and address pointers.  If the length

                                     00FD   363 ;	goes negative, an error exit is called.

                                     00FD   364 ;

                                     00FD   365 ; CALLING SEQUENCE:

                                     00FD   366 ;

                                     00FD   367 ;	JSB (R8)

                                     00FD   368 ;

                                     00FD   369 ; INPUT PARAMETERS:

                                     00FD   370 ;

                                     00FD   371 ;	none

                                     00FD   372 ;

                                     00FD   373 ; IMPLICIT INPUTS:

                                     00FD   374 ;

                                     00FD   375 ;	INLEN(FP) -  lower word has remaining length of input string

                                     00FD   376 ;	INPTR(FP) -  is pointer to current string position

                                     00FD   377 ;

                                     00FD   378 ; OUTPUTS:

                                     00FD   379 ;

                                     00FD   380 ;	R3 - next character in input string

                                     00FD   381 ;

                                     00FD   382 ; IMPLICIT OUTPUTS:

                                     00FD   383 ;

                                     00FD   384 ;	none

                                     00FD   385 ;

                                     00FD   386 ; COMPLETION CODES:

                                     00FD   387 ;

                                     00FD   388 ;	none

                                     00FD   389 ;

                                     00FD   390 ; SIDE EFFECTS:

                                     00FD   391 ;

                                     00FD   392 ;	input pointers on stack are updated

                                     00FD   393 ;	error may cause jump to ILLEGAL

                                     00FD   394 ;--

                                     00FD   395 

                                     00FD   396 GETCHAR:

                       F0 AD     B7  00FD   397 	DECW	INLEN(FP)		; decr input length remaining

                          DE     19  0100   398 	BLSS	ILLEGAL			; error if no more left

            53         F4 BD     9A  0102   399 	MOVZBL	@INPTR(FP),R3		; get next character

                       F4 AD     D6  0106   400 	INCL	INPTR(FP)		; update pointer

                                 05  0109   401 	RSB				; return

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page   9

01              GETCOUNT - Routine to get repeat-count or field                                                                  (5)



                                     010A   403 	.SBTTL	GETCOUNT - Routine to get repeat-count or field-width

                                     010A   404 

                                     010A   405 ;++

                                     010A   406 ;

                                     010A   407 ; FUNCTIONAL DESCRIPTION:

                                     010A   408 ;

                                     010A   409 ;	This subroutine to PARSE_DIRECTIVE scans for a repeat-count or

                                     010A   410 ;	field-width in the directive in the input stream.  If a numeric

                                     010A   411 ;	count is found, it is converted to binary.  If a '#' character

                                     010A   412 ;	is found, the count is taken from the next parameter

                                     010A   413 ;	in the parameter list.

                                     010A   414 ;

                                     010A   415 ; CALLING SEQUENCE:

                                     010A   416 ;

                                     010A   417 ;	JSB or BSB

                                     010A   418 ;

                                     010A   419 ; INPUTS:

                                     010A   420 ;

                                     010A   421 ;	R11	- parameter pointer

                                     010A   422 ;

                                     010A   423 ; IMPLICIT INPUTS:

                                     010A   424 ;

                                     010A   425 ;	none

                                     010A   426 ;

                                     010A   427 ; OUTPUTS:

                                     010A   428 ;

                                     010A   429 ;	R6	- value of count, if # or number found, else -1

                                     010A   430 ;

                                     010A   431 ; IMPLICIT OUTPUTS:

                                     010A   432 ;

                                     010A   433 ;	R11 may be modified if a parameter is taken from the stack

                                     010A   434 ;

                                     010A   435 ; COMPLETION CODES:

                                     010A   436 ;

                                     010A   437 ;	none

                                     010A   438 ;

                                     010A   439 ; SIDE EFFECTS:

                                     010A   440 ;

                                     010A   441 ;	R1, R3, and R4 are destroyed

                                     010A   442 ;--

                                     010A   443 

                                     010A   444 

                                     010A   445 

                                     010A   446 GETCOUNT:

            56            01     CE  010A   447 	MNEGL	#1,R6			; not found indicator

         F4 BD            23     91  010D   448 	CMPB	#^A/#/,@INPTR(FP)	; is this a param. count?

                          26     13  0111   449 	BEQL	40$			; yes .. pull next param

                          53     7C  0113   450 	CLRQ	R3			; zero buffer for digit (R3)

                                     0115   451 					; ... and accumulator for sum (R4)

            51         F4 AD     D0  0115   452 	MOVL	INPTR(FP),R1		; remember where we were

                                     0119   453 10$:

         F4 BD            30     83  0119   454 	SUBB3	#^A/0/,@INPTR(FP),R3	; subtract ascii 0 from char

                          53         011D       

                          0F     19  011E   455 	BLSS	20$			; branch if not numeric

            53            09     91  0120   456 	CMPB	#^A/9/-^A/0/,R3		; still numeric?

                          0A     19  0123   457 	BLSS	20$			; no, branch

            54            0A     C4  0125   458 	MULL2	#10,R4			; shift for next digit

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  10

01              GETCOUNT - Routine to get repeat-count or field                                                                  (5)



            54            53     C0  0128   459 	ADDL	R3,R4			; add in next digit

                          D0     10  012B   460 	BSBB	GETCHAR			; skip digit we took

                          EA     11  012D   461 	BRB	10$			; continue while numeric

                                     012F   462 20$:

         F4 AD            51     D1  012F   463 	CMPL	R1,INPTR(FP)		; did we get any chars?

                          03     13  0133   464 	BEQL	30$			; no, leave

            56            54     D0  0135   465 	MOVL	R4,R6			; yes, return value 

                                     0138   466 30$:

                                 05  0138   467 	RSB				; return

                                     0139   468 

                                     0139   469 40$:

            56            8B     D0  0139   470 	MOVL	(R11)+,R6		; get value from next parameter

                          BF     10  013C   471 	BSBB	GETCHAR			; skip '#'

                                 05  013E   472 	RSB				; return

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  11

01              CVTASC - Insert ASCII string                                                                                     (7)



                                     013F   475 	.SBTTL	CVTASC	- Insert ASCII string

                                     013F   476 	.LIST MEB

                                     013F   477 

                                     013F   478 ;++

                                     013F   479 ;

                                     013F   480 ; FUNCTIONAL DESCRIPTION:

                                     013F   481 ;

                                     013F   482 ;	Service routine to handle ASCII string insertions.

                                     013F   483 ;	Strings are specified by several different methods.  For

                                     013F   484 ;	filled strings (AF) , non-printing characters are output

                                     013F   485 ;	as dots ('.').  

                                     013F   486 ;

                                     013F   487 ; CALLING SEQUENCE:

                                     013F   488 ;

                                     013F   489 ;	JSB or BSB

                                     013F   490 ;

                                     013F   491 ; INPUTS:

                                     013F   492 ;

                                     013F   493 ;	R3	- index of first control char in CNTRL_TABLE

                                     013F   494 ;	R4	- second control character

                                     013F   495 ;	R6	- output field width

                                     013F   496 ;	R9	- output buffer length remaining

                                     013F   497 ;	R10	- output buffer pointer

                                     013F   498 ;	R11	- parameter pointer

                                     013F   499 ;

                                     013F   500 ; IMPLICIT INPUTS:

                                     013F   501 ;

                                     013F   502 ;	none

                                     013F   503 ;

                                     013F   504 ; OUTPUTS:

                                     013F   505 ;

                                     013F   506 ;	none

                                     013F   507 ;

                                     013F   508 ; IMPLICIT OUTPUTS:

                                     013F   509 ;

                                     013F   510 ;	R9 and R10 are update to point to current position in output buffer

                                     013F   511 ;	R11 is updated as parameters are taken from the stack

                                     013F   512 ;

                                     013F   513 ; ROUTINE VALUE:

                                     013F   514 ;

                                     013F   515 ;	none

                                     013F   516 ;

                                     013F   517 ; SIDE EFFECTS:

                                     013F   518 ;

                                     013F   519 ;	R7 and R8 are destroyed

                                     013F   520 ;--

                                     013F   521 

                                     013F   522 

                                     013F   523 CVTASC:

                                     013F   524 

                          38     BB  013F   525 	PUSHR	#^M<R3,R4,R5>		; save registers

                          57     D4  0141   526 	CLRL	R7			; set filled indicator to not filled

            04            54     3A  0143   527 	LOCC	R4,#4,STRING_TYPES	; search for string subtype

                     FED7 CF         0146       

                          5D     13  0149   528 	BEQL	110$			; error if not found

                                     014B   529 

                                     014B   530 ;

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  12

01              CVTASC - Insert ASCII string                                                                                     (7)



                                     014B   531 ;	R0 = 1 - filled , 2 - 2 arg desc. , 3 - str. desc. , 4 - cstring

                                     014B   532 ;

                                     014B   533 	CASE	R0,<10$,20$,30$>,B,#2	; case on descriptor type, base = 2

            02            50     8F  014B       	CASEB	R0,#2,S^#<<30003$-30002$>/2>-1

                          02'        014E       

                                     014F       30002$:

                               0008' 014F       	.WORD	10$-30002$

                               000D' 0151       	.WORD	20$-30002$

                               0015' 0153       	.WORD	30$-30002$

                                     0155       30003$:

                                     0155   534 

                                     0155   535 ;

                                     0155   536 ; Case falls through here for filled ascii strings. Two argument

                                     0155   537 ; descriptor is used.

                                     0155   538 ;

                                     0155   539 

                          57     D6  0155   540 	INCL	R7			; set filled indicator for filled ascii

                                     0157   541 10$:

            51            8B     7D  0157   542 	MOVQ	(R11)+,R1		; get length and address

                          0E     11  015A   543 	BRB	40$			; continue

                                     015C   544 

                                     015C   545 ;

                                     015C   546 ; Standard system string descriptor

                                     015C   547 ;

                                     015C   548 

                                     015C   549 20$:

            51            9B     7D  015C   550 	MOVQ	@(R11)+,R1		; move descriptor to R1,R2

            51            51     3C  015F   551 	MOVZWL	R1,R1			; make sure length is word

                          06     11  0162   552 	BRB	40$			; continue

                                     0164   553 

                                     0164   554 ;

                                     0164   555 ; Ascii counted string, first byte contains length

                                     0164   556 ;

                                     0164   557 

                                     0164   558 30$:

            52            8B     D0  0164   559 	MOVL	(R11)+,R2		; address of counted string

            51            82     9A  0167   560 	MOVZBL	(R2)+,R1		; get length and skip byte count

                                     016A   561 

                                     016A   562 40$:

                                     016A   563 

                                     016A   564 ;

                                     016A   565 ; Here, R1 has string length, R2 has string address. Check length against

                                     016A   566 ; specified field width to decide how much string to move.

                                     016A   567 ;

                                     016A   568 

            58            56     D0  016A   569 	MOVL	R6,R8			; was a width specified?

                          03     18  016D   570 	BGEQ	50$			; branch if so

            58            51     D0  016F   571 	MOVL	R1,R8			; if not, use string length instead

                                     0172   572 50$:

                                     0172   573 	

                                     0172   574 ;

                                     0172   575 ; The string is moved to the output buffer with blank fill at the

                                     0172   576 ; end.  The output pointers are then updated by the field width, so

                                     0172   577 ; that the string will be truncated if it was smaller than the field

                                     0172   578 ; width.  If the string is filled, a second pass is made to change

                                     0172   579 ; non-printing characters to dots.

                                     0172   580 ;

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  13

01              CVTASC - Insert ASCII string                                                                                     (7)



                                     0172   581 ; Check to see if the string will overflow the buffer and if so,

                                     0172   582 ; move the legal part and generate a buffer overflow error.

                                     0172   583 ;

                                     0172   584 

            53            59     D0  0172   585 	MOVL	R9,R3			; copy remaining char count

            59            58     C2  0175   586 	SUBL	R8,R9			; update length remaining

                          03     19  0178   587 	BLSS	55$			; error, use remaining length

            53            58     D0  017A   588 	MOVL	R8,R3			; else move only required length

            62            51     2C  017D   589 55$:	MOVC5	R1,(R2),#^A/ /,R3,(R10) ; move string, fill at end

            53            20         0180       

                          6A         0182       

                          20     14  0183   590 	BGTR	100$			; error if all of string not moved

                                     0185   591 

            52            5A     D0  0185   592 	MOVL	R10,R2			; save output address

            5A            58     C0  0188   593 	ADDL	R8,R10			; update output pointer

            14            57     E9  018B   594 	BLBC	R7,90$			; all done if not filled ASCII

                                     018E   595 60$:

            20            62     91  018E   596 	CMPB	(R2),#^O40		; printing character?

                          06     19  0191   597 	BLSS	70$			; no, fill with dot

         7E 8F            62     91  0193   598 	CMPB	(R2),#^O176		; still printing?

                          03     15  0197   599 	BLEQ	80$			; yes, skip this one

                                     0199   600 70$:

            62            2E     90  0199   601 	MOVB	#^A/./,(R2)		; insert dot in place of char

                                     019C   602 80$:

                          52     D6  019C   603 	INCL	R2			; point to next character

            57            58     F3  019E   604 	AOBLEQ	R8,R7,60$		; continue until done

                          EC         01A1       

                                     01A2   605 90$:

                          38     BA  01A2   606 	POPR	#^M<R3,R4,R5>

                                 05  01A4   607 	RSB				; return

                                     01A5   608 

                                     01A5   609 100$:

                          FF3D   31  01A5   610 	BRW	OVERFLOW

                                     01A8   611 110$:

                          FF35   31  01A8   612 	BRW	ILLEGAL

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  14

01              CVTNUM - Convert numeric parameter to ASCII                                                                      (8)



                                     01AB   614 	.SBTTL	CVTNUM - Convert numeric parameter to ASCII

                                     01AB   615 

                                     01AB   616 ;++

                                     01AB   617 ;

                                     01AB   618 ; FUNCTIONAL DESCRIPTION:

                                     01AB   619 ;

                                     01AB   620 ;	This routine handles the various HEX, OCTAL, and DECIMAL

                                     01AB   621 ;	conversions. The proper field is extracted from the

                                     01AB   622 ;	parameter (byte, word , or long) and the needed output

                                     01AB   623 ;	width is determined.  This is compared with the user

                                     01AB   624 ;	specified field width to determine if padding of filling

                                     01AB   625 ;	is needed.  The entire entire field with fill is build on the

                                     01AB   626 ;	stack and then moved so that the result will be correct

                                     01AB   627 ;	on buffer overflow.

                                     01AB   628 ;

                                     01AB   629 ; CALLING SEQUENCE:

                                     01AB   630 ;

                                     01AB   631 ;	JSB or BSB

                                     01AB   632 ;

                                     01AB   633 ; INPUTS:

                                     01AB   634 ;

                                     01AB   635 ;	R3	- index of directive in CNTRL_TABLE.

                                     01AB   636 ;			0 = 0ctal

                                     01AB   637 ;			1 = heX

                                     01AB   638 ;			2 = Unsigned decimal

                                     01AB   639 ;			3 = Signed decimal

                                     01AB   640 ;			4 = Zero filled unsigned decimal

                                     01AB   641 ;	R4	- second char of directive (B,W, or L)

                                     01AB   642 ;	R6	- field width, or -1 if none

                                     01AB   643 ;	R9	- output length remaining

                                     01AB   644 ;	R10	- output position pointer

                                     01AB   645 ;	R11	- next parameter pointer

                                     01AB   646 ;

                                     01AB   647 ; IMPLICIT INPUTS:

                                     01AB   648 ;

                                     01AB   649 ;	none

                                     01AB   650 ;

                                     01AB   651 ; OUTPUTS:

                                     01AB   652 ;

                                     01AB   653 ;	none

                                     01AB   654 ;

                                     01AB   655 ; IMPLICIT OUTPUTS:

                                     01AB   656 ;

                                     01AB   657 ;	none

                                     01AB   658 ;

                                     01AB   659 ; ROUTINE VALUE:

                                     01AB   660 ;

                                     01AB   661 ;	none

                                     01AB   662 ;

                                     01AB   663 ; SIDE EFFECTS:

                                     01AB   664 ;

                                     01AB   665 ;	none

                                     01AB   666 ;--

                                     01AB   667 

                                     01AB   668 ;

                                     01AB   669 ; The registers will be set up as follows

                                     01AB   670 ;

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  15

01              CVTNUM - Convert numeric parameter to ASCII                                                                      (8)



                                     01AB   671 ;	R0  - max digits to be output

                                     01AB   672 ;	R1  - 0 -> byte, 1 -> word , 2 -> long

                                     01AB   673 ;	R2  - value to be converted

                                     01AB   674 ;	R4  - conversion radix

                                     01AB   675 ;	R5  - sign indicator, 1 -> sign to be output, 0 otherwise

                                     01AB   676 ;	R7  - fill character, (blank, zero for !Z, or * on width too small

                                     01AB   677 ;		for decimal conversions)

                                     01AB   678 ;	R8  - total width of field to be output

                                     01AB   679 ;

                                     01AB   680 

                                     01AB   681 CVTNUM:

                                     01AB   682 

                          38     BB  01AB   683 	PUSHR	#^M<R3,R4,R5>

                                     01AD   684 

            03            54     3A  01AD   685 	LOCC	R4,#3,DATA_TYPES	; determine data type

                     FE71 CF         01B0       

                          03     12  01B3   686 	BNEQ	10$			; continue if legal directive

                          FF28   31  01B5   687 	BRW	ILLEGAL			; else take error condition

                                     01B8   688 10$:

            03            50     C3  01B8   689 	SUBL3	R0,#3,R1		; convert to index

                          51         01BB       

            52            8B     D0  01BC   690 	MOVL	(R11)+,R2		; get next longword parameter

       FE65 CF41          00     EF  01BF   691 	EXTZV	#0,FIELDS[R1],R2,R2	; select proper field

            52            52         01C5       

                          55     D4  01C7   692 	CLRL	R5			; note unsigned

            57            20     90  01C9   693 	MOVB	#^A/ /,R7		; default fill char is blank

            54       FE67 CF43   9A  01CC   694 	MOVZBL	RADIX[R3],R4		; get conversion radix

                                     01D2   695 

                                     01D2   696 ;

                                     01D2   697 ; Case on the type of conversion.  Note that base is set

                                     01D2   698 ; so that octal and hex conversions fall through case table.

                                     01D2   699 ;

                                     01D2   700  

                                     01D2   701 	CASE	R3,<40$,30$,20$>,,#2	; base index of 2

            02            53     AF  01D2       	CASEW	R3,#2,S^#<<30005$-30004$>/2>-1

                          02'        01D5       

                                     01D6       30004$:

                               0038' 01D6       	.WORD	40$-30004$

                               0027' 01D8       	.WORD	30$-30004$

                               0022' 01DA       	.WORD	20$-30004$

                                     01DC       30005$:

                                     01DC   702 

                                     01DC   703 ;

                                     01DC   704 ; Octal and Hex fall through here

                                     01DC   705 ;

                                     01DC   706 

            50            6143   DE  01DC   707 	MOVAL	(R1)[R3],R0		; compute index in OCT_HEX_DIGITS

            50       FE4C CF40   9A  01E0   708 	MOVZBL	OCT_HEX_DIGITS[R0],R0	; get number of digits to output

            58            56     D0  01E6   709 	MOVL	R6,R8			; user specified width?

                          03     18  01E9   710 	BGEQ	15$			; yes, use it as width

            58            50     D0  01EB   711 	MOVL	R0,R8			; else take needed space

                                     01EE   712 15$:

            50            58     D1  01EE   713 	CMPL	R8,R0			; width lss default digits?

                          45     18  01F1   714 	BGEQ	60$			; no, fill to user specified width

            50            58     D0  01F3   715 	MOVL	R8,R0			; else output only specified width

                          40     11  01F6   716 	BRB	60$

                                     01F8   717 

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  16

01              CVTNUM - Convert numeric parameter to ASCII                                                                      (8)



                                     01F8   718 ;

                                     01F8   719 ; Unsigned decimal with zero fill

                                     01F8   720 ;

                                     01F8   721 

                                     01F8   722 20$:

            57            30     90  01F8   723 	MOVB	#^A/0/,R7		; insert new fill char

                          11     11  01FB   724 	BRB	40$			; continue with normal dec. code

                                     01FD   725 

                                     01FD   726 ;

                                     01FD   727 ; Signed decimal conversion

                                     01FD   728 ;

                                     01FD   729 

                                     01FD   730 30$:

       FE27 CF41          00     EE  01FD   731 	EXTV	#0,FIELDS[R1],R2,R2	; sign extend the field

            52            52         0203       

            52            1F     E1  0205   732 	BBC	#31,R2,40$		; not negative, continue

                          05         0208       

                          55     D6  0209   733 	INCL	R5			; else note that value negative

            52            52     CE  020B   734 	MNEGL	R2,R2			; and make it positive

                                     020E   735 

                                     020E   736 40$:					; common decimal processing

                                     020E   737 

                                     020E   738 ;

                                     020E   739 ; Determine the number of digits needed to print number in ASCII

                                     020E   740 ; decimal representation.

                                     020E   741 ;

                                     020E   742 

            50            01     D0  020E   743 	MOVL	#1,R0			; init digit counter

            53            54     D0  0211   744 	MOVL	R4,R3			; copy first power of 10

                                     0214   745 44$:

            53            52     D1  0214   746 	CMPL	R2,R3			; does it fit?

                          07     1F  0217   747 	BLSSU	48$			; yes, R0 has count if so

            53            54     C4  0219   748 	MULL	R4,R3			; else compute next power of ten

            50            54     F2  021C   749 	AOBLSS	R4,R0,44$		; continue (10 digits is largest possible)

                          F4         021F       

                                     0220   750 48$:

            55            50     C1  0220   751 	ADDL3	R0,R5,R3		; add in sign, if one exists

                          53         0223       

            58            56     D0  0224   752 	MOVL	R6,R8			; did user specify width?

                          05     18  0227   753 	BGEQ	50$			; yes, use it for field width

            58            53     D0  0229   754 	MOVL	R3,R8			; else use amount needed

                          0A     11  022C   755 	BRB	60$			; continue

                                     022E   756 50$:

            58            53     D1  022E   757 	CMPL	R3,R8			; is there space within specified width?

                          05     15  0231   758 	BLEQ	60$			; yes, go on

            57            2A     90  0233   759 	MOVB	#^A/*/,R7		; no room, fill with stars

                          50     D4  0236   760 	CLRL	R0			; output no digits

                                     0238   761 

                                     0238   762 60$:

         F8 AD            52     D0  0238   763 	MOVL	R2,LASTVAL(FP)		; remember value to be converted

                                     023C   764 

                                     023C   765 ;

                                     023C   766 ; Insert the ASCII representation for the value in R2 into the

                                     023C   767 ; output buffer. 

                                     023C   768 ;

                                     023C   769 

                                     023C   770 CVT_BIN_TO_ASC:

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  17

01              CVTNUM - Convert numeric parameter to ASCII                                                                      (8)



                                     023C   771 

                     0840 8F     BB  023C   772 	PUSHR	#^M<R6,R11>		; save work registers

                       04 A8     9F  0240   773 	PUSHAB	4(R8)			; compute stack space needed for buffer

            6E            03     CA  0243   774 	BICL	#3,(SP)			; round stack to longword

            5B            5E     D0  0246   775 	MOVL	SP,R11			; save stack pointer

            5E            6B     C2  0249   776 	SUBL	(R11),SP		; leave buffer space on stack

                                     024C   777 

                          53     D4  024C   778 	CLRL	R3			; clear upper half of quad quotient

            51            01     CE  024E   779 	MNEGL	#1,R1			; init digit counter for loop

                          0B     11  0251   780 	BRB	15$			; start loop

                                     0253   781 10$:

            52            54     7B  0253   782 	EDIV	R4,R2,R2,R6		; R2 <- quotient, R6 <- remainder

            56            52         0256       

            7B       FDA3 CF46   90  0258   783 	MOVB	ASC_NAMES[R6],-(R11)	; output ascii digit

                                     025E   784 15$:

            51            50     F2  025E   785 	AOBLSS	R0,R1,10$		; one more digit, done yet?

                          F1         0261       

            05            55     E9  0262   786 	BLBC	R5,20$			; branch if no sign to output

            7B            2D     90  0265   787 	MOVB	#^A/-/,-(R11)		; output sign

                          51     D6  0268   788 	INCL	R1			;

                                     026A   789 20$:

                                     026A   790 	

                                     026A   791 ;	

                                     026A   792 ; If field (R8) is not full, then fill remainder with the fill character

                                     026A   793 ;

                                     026A   794 

                          03     11  026A   795 	BRB	40$			; start the loop

                                     026C   796 30$:

            7B            57     90  026C   797 	MOVB	R7,-(R11)		; insert fill character

                                     026F   798 40$:

            51            58     F3  026F   799 	AOBLEQ	R8,R1,30$		; fill until full

                          F9         0272       

                                     0273   800 

                                     0273   801 ;

                                     0273   802 ; Now copy stack back to buffer, checking for overflow

                                     0273   803 ;

                                     0273   804 

                          08     11  0273   805 	BRB	70$			; start loop

                                     0275   806 50$:

            02            59     F4  0275   807 	SOBGEQ	R9,60$			; update length, check for overflow

                          21     11  0278   808 	BRB	INSERT_OVF		; handle overflow

            8A            8B     90  027A   809 60$:	MOVB	(R11)+,(R10)+		; move char to output buffer

            F5            58     F4  027D   810 70$:	SOBGEQ	R8,50$			; move entire string

                                     0280   811 

                                     0280   812 ;

                                     0280   813 ; Now clean up mess on stack

                                     0280   814 ;

                                     0280   815 

            5E            5B     D0  0280   816 	MOVL	R11,SP			; restore stack 

                     0841 8F     BA  0283   817 	POPR	#^M<R0,R6,R11>		; remove top of stack and restore regs

                                     0287   818 

                                     0287   819 ;

                                     0287   820 ; Restore registers and return from service routine.

                                     0287   821 ;

                                     0287   822 

                          38     BA  0287   823 	POPR	#^M<R3,R4,R5>

                                 05  0289   824 	RSB

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  18

01              QUICKSERVE - Small service routines                                                                              (9)



                                     028A   826 	.SBTTL	QUICKSERVE - Small service routines

                                     028A   827 

                                     028A   828 ;++

                                     028A   829 ;

                                     028A   830 ; FUNCTIONAL DESCRIPTION:

                                     028A   831 ;

                                     028A   832 ;	Following are a collection of short service routines for

                                     028A   833 ;	FAO directives.  

                                     028A   834 ;

                                     028A   835 ; CALLING SEQUENCE:

                                     028A   836 ;

                                     028A   837 ;	JSB or BSB

                                     028A   838 ;

                                     028A   839 ; INPUTS:

                                     028A   840 ;

                                     028A   841 ;	R3  - index in CNTRL_TABLE of the directive

                                     028A   842 ;	R4  - second character of two-char directive, if any

                                     028A   843 ;	R6  - user specified field width, if any (ignored for singal char

                                     028A   844 ;	      and argument directives)

                                     028A   845 ;	R9  - output length remaining

                                     028A   846 ;	R10 - output position pointer

                                     028A   847 ;

                                     028A   848 ; IMPLICIT INPUTS:

                                     028A   849 ;

                                     028A   850 ;	none

                                     028A   851 ;

                                     028A   852 ; OUTPUTS:

                                     028A   853 ;

                                     028A   854 ;	none

                                     028A   855 ;

                                     028A   856 ; IMPLICIT OUTPUTS:

                                     028A   857 ;

                                     028A   858 ;	R9 and R10 are modified 

                                     028A   859 ;

                                     028A   860 ; COMPLETION CODES:

                                     028A   861 ;

                                     028A   862 ;	none

                                     028A   863 ;

                                     028A   864 ; SIDE EFFECTS:

                                     028A   865 ;

                                     028A   866 ;	none

                                     028A   867 ;--

                                     028A   868 

                                     028A   869 

                                     028A   870 INCR_ARGPTR:

                                     028A   871 

                                     028A   872 ;

                                     028A   873 ; Directive to skip next parameter in parameter list

                                     028A   874 ;

                                     028A   875 

                          8B     D5  028A   876 	TSTL	(R11)+			; skip next parameter

                                 05  028C   877 	RSB				; exit

                                     028D   878 

                                     028D   879 DECR_ARGPTR:

                                     028D   880 

                                     028D   881 ;

                                     028D   882 ; Directive to back up and reuse last parameter in parameter list

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  19

01              QUICKSERVE - Small service routines                                                                              (9)



                                     028D   883 ;

                                     028D   884 

                          7B     D5  028D   885 	TSTL	-(R11)			; back up argument pointer

                                 05  028F   886 	RSB				; exit

                                     0290   887 

                                     0290   888 NEWLINE:

                                     0290   889 

                                     0290   890 ;

                                     0290   891 ; Insert carriage return, line feed into output buffer

                                     0290   892 ;

                                     0290   893 

            02            59     F4  0290   894 	SOBGEQ	R9,10$			; room for CR?, branch if so

                          06     11  0293   895 	BRB	INSERT_OVF		; no room in output buffer

                                     0295   896 10$:

            8A            0D     90  0295   897 	MOVB	#CR,(R10)+		; insert CR in output buffer

                                     0298   898 					; continue for LF insertion

                                     0298   899 

                                     0298   900 INSERT_CHAR:

                                     0298   901 

                                     0298   902 ;

                                     0298   903 ; Make simple one character insertion in the output buffer.

                                     0298   904 ;

                                     0298   905 

            03            59     F4  0298   906 	SOBGEQ	R9,INSERT_IT		; check length, branch if ok

                                     029B   907 INSERT_OVF:

                          FE47   31  029B   908 	BRW	OVERFLOW		; error , no room in output buffer

                                     029E   909 INSERT_IT:

                                     029E   910 

                                     029E   911 ;

                                     029E   912 ; Insert the character by computing the index into the replacement table

                                     029E   913 ;

                                     029E   914 

            8A       FD7E CF43   90  029E   915 	MOVB	REPLACEMENT-REPL_OFFSET[R3],(R10)+ ; insert the char

                                 05  02A4   916 	RSB

                                     02A5   917 

                                     02A5   918 ;

                                     02A5   919 ; Directive to repeat a particular character 'n' times, where 'n' is

                                     02A5   920 ; specified by the field width in the directive.

                                     02A5   921 ;

                                     02A5   922 

                                     02A5   923 REPEATIT:

                          38     BB  02A5   924 	PUSHR	#^M<R3,R4,R5>	 	; save regs for MOVC5 clobber

                          56     D5  02A7   925 	TSTL	R6			; check if width was specified

                          15     19  02A9   926 	BLSS	ILLFIELD		; illegal if none specified

            59            56     C2  02AB   927 	SUBL	R6,R9			; compute remaining output length

                          EB     19  02AE   928 	BLSS	INSERT_OVF		; not enough room, error

            6E            00     2C  02B0   929 	MOVC5	#0,(SP),R4,R6,(R10) 	; fill with specified character

            56            54         02B3       

                          6A         02B5       

            5A            56     C0  02B6   930 	ADDL	R6,R10			; update output pointer

                          38     BA  02B9   931 	POPR	#^M<R3,R4,R5>	 	; restore regs

                                 05  02BB   932 	RSB

                                     02BC   933 

                                     02BC   934 ;

                                     02BC   935 ; The following are the directives which define a fixed length field.


                                     02BC   936 ; The field width is specified with the define field directive.  At the

                                     02BC   937 ; end field directive, any of the field remaining is blank filled, else

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  20

01              QUICKSERVE - Small service routines                                                                              (9)



                                     02BC   938 ; the field is truncated to the specified length.

                                     02BC   939 ;

                                     02BC   940 

                                     02BC   941 STARTFIELD:

                          56     D5  02BC   942 	TSTL	R6			; did user specify field (must be specified)

                          03     18  02BE   943 	BGEQ	STARTOK			; yes, continue

                                     02C0   944 ILLFIELD:

                          FE1D   31  02C0   945 	BRW	ILLEGAL			; illegal directive

            5A            56     C1  02C3   946 STARTOK:ADDL3	R6,R10,FIELDEND(FP) 	; compute and save ending address

                       FC AD         02C6       

            59            56     D1  02C8   947 	CMPL	R6,R9			; was that much space remaining?

                          CE     14  02CB   948 	BGTR	INSERT_OVF		; no, take error here

                                 05  02CD   949 	RSB				; return

                                     02CE   950 

                                     02CE   951 ;

                                     02CE   952 ; Set up registers so that if fill is needed, a phony call is made

                                     02CE   953 ; to REPEATIT with the length in R6 and the 'blank' character in R4

                                     02CE   954 ;

                                     02CE   955 

                                     02CE   956 ENDFIELD:

            54            20     9A  02CE   957 	MOVZBL	#^A/ /,R4		; generate blank fill character

         FC AD            5A     C3  02D1   958 	SUBL3	R10,FIELDEND(FP),R6 	; compute remaining field length

                          56         02D5       

                          CD     14  02D6   959 	BGTR	REPEATIT		; if any left, go fill with blanks

            5A         FC AD     D0  02D8   960 	MOVL	FIELDEND(FP),R10 	; else truncate by setting back pointer

            59            56     C2  02DC   961 	SUBL	R6,R9			; subtract negative difference from counter

                                 05  02DF   962 	RSB				; return

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  21

01              PERCENT - Time directives and plural 'S'                                                                        (10)



                                     02E0   964 	.SBTTL	PERCENT - Time directives and plural 'S'

                                     02E0   965 

                                     02E0   966 ;++

                                     02E0   967 ;

                                     02E0   968 ; FUNCTIONAL DESCRIPTION:

                                     02E0   969 ;

                                     02E0   970 ;	These directives are for date and time conversion, and for

                                     02E0   971 ;	conditionally inserting a plural 'S' into messages.

                                     02E0   972 ;	The time directives insert an ASCII time string into the output buffer.

                                     02E0   973 ;	The user may supply a quadword binary time to be converted, 

                                     02E0   974 ;	or have the current date or time inserted.

                                     02E0   975 ;

                                     02E0   976 ; CALLING SEQUENCE:

                                     02E0   977 ;

                                     02E0   978 ;	JSB/BSB

                                     02E0   979 ;

                                     02E0   980 ; INPUTS:

                                     02E0   981 ;

                                     02E0   982 ;	R4  - second character of directive.  D -> convert

                                     02E0   983 ;		date and time, T -> convert time only

                                     02E0   984 ;		S -> plural indicator

                                     02E0   985 ;	R9  - remaining length of output buffer

                                     02E0   986 ;	R10 - current output buffer position

                                     02E0   987 ;	R11 - next parameter address

                                     02E0   988 ;

                                     02E0   989 ; IMPLICIT INPUTS:

                                     02E0   990 ;

                                     02E0   991 ;	none

                                     02E0   992 ;

                                     02E0   993 ; OUTPUTS:

                                     02E0   994 ;

                                     02E0   995 ;	none

                                     02E0   996 ;

                                     02E0   997 ; IMPLICIT OUTPUTS:

                                     02E0   998 ;

                                     02E0   999 ;	none

                                     02E0  1000 ;

                                     02E0  1001 ; ROUTINE VALUE:

                                     02E0  1002 ;

                                     02E0  1003 ;	none

                                     02E0  1004 ;

                                     02E0  1005 ; SIDE EFFECTS:

                                     02E0  1006 ;

                                     02E0  1007 ;	none

                                     02E0  1008 ;--

                                     02E0  1009 

                                     02E0  1010 PERCENT:

            03            54     3A  02E0  1011 	LOCC	R4,#3,PERCENT_STR	; find directive type

                     FD41 CF         02E3       

                          D8     13  02E6  1012 	BEQL	ILLFIELD		; illegal directive if not found

                          57     D4  02E8  1013 	CLRL	R7			; assume date and time

                                     02EA  1014 	CASE	R0,<10$,30$>,B,#2	; branch on directive type

            02            50     8F  02EA       	CASEB	R0,#2,S^#<<30007$-30006$>/2>-1

                          01'        02ED       

                                     02EE       30006$:

                               0006' 02EE       	.WORD	10$-30006$

                               003F' 02F0       	.WORD	30$-30006$

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  22

01              PERCENT - Time directives and plural 'S'                                                                        (10)



                                     02F2       30007$:

                                     02F2  1015 

                                     02F2  1016 ;

                                     02F2  1017 ; Time only directive falls through here

                                     02F2  1018 ;

                                     02F2  1019 

                          57     D6  02F2  1020 	INCL	R7			; indicate time only

                                     02F4  1021 10$:					; time and date enters here

                          38     BB  02F4  1022 	PUSHR	#^M<R3,R4,R5>		; save registers

            6A            00     2C  02F6  1023 	MOVC5	#0,(R10),#^A/ /,R9,(R10) ; blank fill rest of output buffer

            59            20         02F9       

                          6A         02FB       

            58            7E     DE  02FC  1024 	MOVAL	-(SP),R8		; space for return length

            7E            59     7D  02FF  1025 	MOVQ	R9,-(SP)		; form descriptor for output buffer

            52            6E     DE  0302  1026 	MOVAL	(SP),R2			; get address of buffer descriptor

            51            8B     D0  0305  1027 	MOVL	(R11)+,R1		; get binary time address

                                     0308  1028 	$ASCTIM_S (R8),(R2),(R1),R7	; convert time to ascii

                          57     DD  0308       		PUSHL	R7

                          61     7F  030A       		PUSHAQ	(R1)

                          62     7F  030C       		PUSHAQ	(R2)

                          68     3F  030E       		PUSHAW	(R8)

   00000000'9F            04     FB  0310       		CALLS	#4,@#SYS$ASCTIM

            52            56     D0  0317  1029 	MOVL	R6,R2			; did user specify width?

                          03     18  031A  1030 	BGEQ	20$			; yes, use it

            52            68     3C  031C  1031 	MOVZWL	(R8),R2			; else use returned length

                                     031F  1032 20$:

            59            52     C2  031F  1033 	SUBL	R2,R9			; update output length

                          12     19  0322  1034 	BLSS	40$			; error, not enough room

            5A            52     C0  0324  1035 	ADDL	R2,R10			; update output buffer

            5E            0C     C0  0327  1036 	ADDL	#12,SP			; pop locals from stack

                          38     BA  032A  1037 	POPR	#^M<R3,R4,R5>		; restore registers

                                 05  032C  1038 	RSB				;

                                     032D  1039 30$:

                                     032D  1040 

                                     032D  1041 ;

                                     032D  1042 ; Check if the last value converted was equal to one.  If so, then do

                                     032D  1043 ; nothing, else output an 'S' into the output buffer.

                                     032D  1044 ;

                                     032D  1045 

         F8 AD            01     D1  032D  1046 	CMPL	#1,LASTVAL(FP)		; was last value a one

                          13     13  0331  1047 	BEQL	60$			; yes, simply return

            03            59     F4  0333  1048 	SOBGEQ	R9,50$			; check if room in buffer

                          FDAC   31  0336  1049 40$:	BRW	OVERFLOW		; no room , error

            8A         53 8F     90  0339  1050 50$:	MOVB	#^A/S/,(R10)+		; plural, insert 'S'

         FE AA            05     E1  033D  1051 	BBC	#5,-2(R10),60$		; continue if previous character was

                          04         0341       

                                     0342  1052 					; ...upper case

         FF AA            05     88  0342  1053 	BISB	#5,-1(R10)		; else convert upper 'S' to lower 's'

                                 05  0346  1054 60$:	RSB				; return

                                     0347  1055 

                                     0347  1056 

                                     0347  1057 	.END

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  23

SYMBOL TABLE                                                                                                                    (10)



ARGCOUNT       = 00000000            SS$_ACCVIO     = 0000000C            SS$_FCPWRITERR = 000008A0            

ASC_NAMES        00000000 R     03   SS$_ARITH      = 00000404            SS$_FILACCERR  = 0000009C            

BIT...         = 00000000            SS$_ASTFLT     = 0000040C            SS$_FILALRACC  = 000000A4            

CASE_BSB         000000BC R     03   SS$_BADATTRIB  = 00000034            SS$_FILELOCKED = 000008A8            

CASE_LOOP        000000BE R     03   SS$_BADCHKSUM  = 00000808            SS$_FILENUMCHK = 000008B0            

CNTRL_LENGTH   = 00000010            SS$_BADESCAPE  = 0000003C            SS$_FILESEQCHK = 000008B8            

CNTRL_TABLE      00000010 R     03   SS$_BADFILEHDR = 00000810            SS$_FILESTRUCT = 000008C0            

CR             = 0000000D            SS$_BADFILENAME= 00000818            SS$_FILNOTACC  = 000000AC            

CVTASC           0000013F R     03   SS$_BADFILEVER = 00000820            SS$_FILNOTCNTG = 000002AC            

CVTNUM           000001AB R     03   SS$_BADIMGHDR  = 00000044            SS$_FILNOTEXP  = 000000B4            

CVT_BIN_TO_ASC   0000023C R     03   SS$_BADIRECTORY= 00000828            SS$_FORMAT     = 000000BC            

DATA_TYPES       00000024 R     03   SS$_BADPARAM   = 00000014            SS$_GPTFULL    = 000000C4            

DECR_ARGPTR      0000028D R     03   SS$_BADSTACK   = 000002B4            SS$_GSDFULL    = 000000CC            

DONE             000000EE R     03   SS$_BEGOFFILE  = 00000938            SS$_GSDNOTXXX  = 000000D4            

ENDFIELD         000002CE R     03   SS$_BLOCKCNTERR= 00000940            SS$_HANGUP     = 000002CC            

EXCL           = 00000021            SS$_BREAK      = 00000414            SS$_HEADERFULL = 000008C8            

EXE$FAO          0000003D RG    03   SS$_BUFFEROVF  = 00000601            SS$_IDXFILEFULL= 000008D0            

EXE$FAOL         00000045 RG    03   SS$_BUGCHECK   = 000002A4            SS$_ILLBLKNUM  = 000000DC            

FAO              0000004B R     03   SS$_CANCEL     = 00000830            SS$_ILLCNTRFUNC= 000000E4            

FAO_CASE         000000C3 R     03   SS$_CHANINTLK  = 0000004C            SS$_ILLEFC     = 000000EC            

FAO_EXIT         000000F1 R     03   SS$_CLIFRCEXT  = 00000980            SS$_ILLIOFUNC  = 000000F4            

FF             = 0000000C            SS$_CMODSUPR   = 0000041C            SS$_ILLLBLAST  = 00000968            

FIELDEND       = FFFFFFFC            SS$_CMODUSER   = 00000424            SS$_ILLPAGCNT  = 000000FC            

FIELDS           0000002A R     03   SS$_COMPAT     = 0000042C            SS$_ILLSEQOP   = 000002DC            

FIRSTARG       = 00000010            SS$_CONTINUE   = 00000001            SS$_ILLSER     = 00000104            

GBL...         = 00000000            SS$_CONTROLC   = 00000651            SS$_ILLUSRLBLRD= 00000958            

GETCHAR          000000FD R     03   SS$_CONTROLO   = 00000609            SS$_ILLUSRLBLWT= 00000960            

GETCOUNT         0000010A R     03   SS$_CONTROLY   = 00000611            SS$_INCVOLLABEL= 0000010C            

ILLEGAL          000000E0 R     03   SS$_CREATED    = 00000619            SS$_INSFARG    = 00000114            

ILLFIELD         000002C0 R     03   SS$_CTRLERR    = 00000054            SS$_INSFMEM    = 00000124            

INCR_ARGPTR      0000028A R     03   SS$_DATACHECK  = 0000005C            SS$_INSFRAME   = 0000012C            

INDSC          = 00000004            SS$_DATAOVERUN = 00000838            SS$_INSFWSL    = 0000011C            

INLEN          = FFFFFFF0            SS$_DEBUG      = 0000046C            SS$_IVADDR     = 00000134            

INPTR          = FFFFFFF4            SS$_DEVACTIVE  = 000002C4            SS$_IVCHAN     = 0000013C            

INSERT_CHAR      00000298 R     03   SS$_DEVALLOC   = 00000840            SS$_IVCHNLSEC  = 0000026C            

INSERT_IT        0000029E R     03   SS$_DEVALRALLOC= 00000641            SS$_IVDEVNAM   = 00000144            

INSERT_OVF       0000029B R     03   SS$_DEVASSIGN  = 00000848            SS$_IVGSDNAM   = 0000014C            

LASTVAL        = FFFFFFF8            SS$_DEVFOREIGN = 00000064            SS$_IVLOGNAM   = 00000154            

LF             = 0000000A            SS$_DEVICEFULL = 00000850            SS$_IVLOGTAB   = 0000015C            

MAIN_SCAN        00000058 R     03   SS$_DEVMOUNT   = 0000006C            SS$_IVPROTECT  = 000002F4            

NEWLINE          00000290 R     03   SS$_DEVNOTALLOC= 00000858            SS$_IVQUOTAL   = 00000164            

OCT_HEX_DIGITS   00000031 R     03   SS$_DEVNOTMBX  = 00000074            SS$_IVSECFLG   = 0000016C            

ONECHAR_INDEX  = 00000008            SS$_DEVNOTMOUNT= 0000007C            SS$_IVSECIDCTL = 000002E4            

ONE_CHAR_CNTRLS  00000018 R     03   SS$_DEVOFFLINE = 00000084            SS$_IVSSRQ     = 00000174            

OUTDSC         = 0000000C            SS$_DIRFULL    = 00000860            SS$_IVSTSFLG   = 0000017C            

OUTLEN         = 00000008            SS$_DRVERR     = 0000008C            SS$_IVTIME     = 00000184            

OVERFLOW         000000E5 R     03   SS$_DUPFILENAME= 00000868            SS$_LENVIO     = 0000018C            

PARSE_DIRECTIVE  00000083 R     03   SS$_DUPLNAM    = 00000094            SS$_LKWSETFUL  = 00000194            

PERCENT          000002E0 R     03   SS$_ENDOFFILE  = 00000870            SS$_MBFULL     = 000008D8            

PERCENT_STR      00000027 R     03   SS$_ENDOFTAPE  = 00000878            SS$_MBTOOSML   = 0000019C            

RADIX            00000038 R     03   SS$_ENDOFUSRLBL= 00000970            SS$_MCHECK     = 000002BC            

REPEATIT         000002A5 R     03   SS$_EXQUOTA    = 0000001C            SS$_MEDOFL     = 000001A4            

REPLACEMENT      0000002D R     03   SS$_EXTIDXFILE = 00000880            SS$_MSGNOTFND  = 00000621            

REPLACE_CHRS     0000001C R     03   SS$_FCPREADERR = 00000888            SS$_MUSTCLOSEFL= 00000948            

REPL_OFFSET    = 0000000C            SS$_FCPREPSTN  = 00000988            SS$_NODATA     = 000001AC            

SS$_ABORT      = 0000002C            SS$_FCPREWNDERR= 00000890            SS$_NOHANDLER  = 000008F8            

SS$_ACCONFLICT = 00000800            SS$_FCPSPACERR = 00000898            SS$_NOHOMEBLK  = 000008E0            

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  24

SYMBOL TABLE                                                                                                                    (10)



SS$_NOIOCHAN   = 000001B4            SS$_WRITLCK    = 0000025C            

SS$_NOLINKS    = 0000027C            STARTFIELD       000002BC R     03   

SS$_NOLOGNAM   = 000001BC            STARTOK          000002C3 R     03   

SS$_NOMBX      = 00000274            STRING_TYPES     00000020 R     03   

SS$_NOMOREFILES= 00000930            SYS$ASCTIM       ********   X   03   

SS$_NONEXDRV   = 000001C4            TAB            = 00000009            

SS$_NONEXPR    = 000008E8            TWO_CHAR_CNTRLS  00000010 R     03   

SS$_NONLOCAL   = 000008F0            

SS$_NOPRIV     = 00000024            

SS$_NORMAL     = 00000001            

SS$_NOSIGNAL   = 00000900            

SS$_NOSOLICIT  = 00000284            

SS$_NOSUCHDEV  = 00000908            

SS$_NOSUCHFILE = 00000910            

SS$_NOSUCHNODE = 0000028C            

SS$_NOSUCHSEC  = 00000978            

SS$_NOTAPEOP   = 00000264            

SS$_NOTFILEDEV = 000001CC            

SS$_NOTINTBLSZ = 000001D4            

SS$_NOTLABELMT = 000001DC            

SS$_NOTNETDEV  = 000002EC            

SS$_NOTRAN     = 00000629            

SS$_NOTSQDEV   = 000001E4            

SS$_OPCCUS     = 00000434            

SS$_OPCDEC     = 0000043C            

SS$_OPINCOMPL  = 000002D4            

SS$_PAGOWNVIO  = 000001EC            

SS$_PAGRDERR   = 00000444            

SS$_PARITY     = 000001F4            

SS$_PARTESCAPE = 000001FC            

SS$_PFMBSY     = 00000204            

SS$_PSTFULL    = 0000020C            

SS$_RADRMOD    = 0000044C            

SS$_REJECT     = 00000294            

SS$_REMOTE     = 00000649            

SS$_RESIGNAL   = 00000918            

SS$_RESULTOVF  = 00000214            

SS$_ROPRAND    = 00000454            

SS$_SECTBLFUL  = 0000021C            

SS$_SSFAIL     = 0000045C            

SS$_SUPERSEDE  = 00000631            

SS$_TAPEPOSLOST= 00000224            

SS$_TBIT       = 00000464            

SS$_TIMEOUT    = 0000022C            

SS$_TOOMANYVER = 00000990            

SS$_TOOMUCHDATA= 0000029C            

SS$_UNASEFC    = 00000234            

SS$_UNSAFE     = 0000023C            

SS$_UNWIND     = 00000920            

SS$_UNWINDING  = 00000928            

SS$_VASFULL    = 00000244            

SS$_VECINUSE   = 0000024C            

SS$_VOLINV     = 00000254            

SS$_WAITUSRLBL = 00000950            

SS$_WASCLR     = 00000001            

SS$_WASECC     = 00000639            

SS$_WASSET     = 00000009            

SYSFAO          - FORMATTED ASCII OUTPUT SYSTEM SERVICE          21-AUG-1978 23:40:16   VAX-11 MACRO X0.3-11               Page  25

PROGRAM SECTION SYNOPSIS                                                                                                        (10)







PROGRAM SECTION SYNOPSIS



.  ABS  .        00000000      00     NOPIC   USR   CON   ABS   LCL NOSHR NOEXE NORD  NOWRT BYTE  

. BLANK .        00000000      01     NOPIC   USR   CON   REL   LCL NOSHR   EXE   RD    WRT BYTE  

$ABS$            00000000      02     NOPIC   USR   CON   ABS   LCL NOSHR   EXE   RD    WRT BYTE  

Y$EXEPAGED       00000347      03     NOPIC   USR   CON   REL   LCL NOSHR   EXE   RD    WRT BYTE  





THERE WERE NO ERRORS OR WARNINGS.

19522. BYTES LEFT IN FREE MEMORY POOL.

1690. BYTES OF RECLAIMED MEMORY.

OBJ$:SYSFAO,LIS$:SYSFAO/-SP=LIB$:LIB/ML,SRC$:SYSFAO

3 MLB DIR RDS - 285 GETS TO DEFINE 10 MACROS. 31 INTER. FILE WRITES. 

