		USRMAC - User Macro Library
		===========================

 USRMAC  is  a macro library provided with a few useful macros for the
 user.  It resides in LB:[1,1] and currently contains:-

	BASTS	- Set-up macro for BINASC
	CALLG	- FORTRAN-compatible call generator
	PUSH	- Stack manipulation macro
	POP	- Stack manipulation macro

 Type HELP USRMAC <macro> for details of a particular macro
2	BASTS
 The  Binary-to-ASCII  conversion  routine  BINASC  (type  HELP OBJLIB
 BINASC  for details) requires as input a flags word defining the form
 of the conversion.  $BASTS can be used from a MACRO-11 program to set
 the word up painlessly.

 The format of the macro is:-

	$BASTS keyword<,keyword><,keyword>

 where the keyword(s) may be any of the following:-

	SIGNED   - Perform a signed conversion
	UNSIGNED - Perform an unsigned conversion
	LEFT     - Left-adjust the result
	RIGHT    - Right-adjust the result
	ZEROES   - Fill in any leading zeroes
	BLANKS   - Replace leading zeroes with blanks
2	CALLG
 This Macro facilitates the calling of a FORTRAN-compatible subroutine
 (i.e.  one  which  expects  R5  to  point to a parameter list) from a
 MACRO-11 Subroutine.

 The Macro is invoked by

    $CALLG  SUBR,A1,A2...

 where  SUBR  is  the  routine  to  be  called,  and  A1,A2... are the
 arguments  to  be  passed. Note that the arguments are moved onto the
 stack exactly as coded, i.e.

    $CALLG  SUB,A1

 results in MOV A1,-(SP)

 For  compatibility  with  FORTRAN,  though, all arguments must be the
 addresses  of storage locations so that, for instance, if you want to
 pass 6 as a parameter, you cannot code

    $CALLG SUB,6
 or $CALLG SUB,#6
 but  must  use  $CALLG  SUB,  #NUM6  where NUM6 is a storage location
 holding the value 6.

 There must not be more than 10 arguments.
2	POP
	#PUSH
2	PUSH

 This  is  a  set  of macros designed to facilitate using the stack as
 temporary storage.

 There are four macros involved:-

 PUSH   -   Store word(s) on the stack
 PUSHB  -      "  byte(s)  "  "    "
 POP    -   Remove word(s) from the stack
 POPB   -      "   byte(s)   "   "    "

 Each one is invoked in an identical fashion. Using PUSH as an example:-

 PUSH X will store the contents of X on the stack

 PUSH <X,Y,Z> will store the contents of X,Y, and Z on the stack.

 If a null variable is used, the corresponding word is cleared, i.e:-

 PUSH  <X,>  will  store  the contents of X on the stack and clear the
 next word.

 PUSH will just clear a word on the stack.
