; 00021

.IF DF R$$T11 ; RT-11 system
  JSW    = ^O<44>
  ERRBYT = ^O<52>
.ENDC

.MACRO $COMMON NAME=<.$$$$.>
  .EMIT <.PSECT 'NAME', RW, D, OVR, GBL>
.ENDM $COMMON

.MACRO $CODE
  .EMIT <.PSECT $CODE$, I, RO>
.ENDM $CODE

.MACRO $IDATA
  .EMIT <.PSECT $IDATA, D, RW>
.ENDM $IDATA

.MACRO $PDATA
  .EMIT <.PSECT $PDATA, D, RO>
.ENDM $PDATA

.MACRO $ASCII
  .EMIT <.PSECT $ASCII, D, RO>
.ENDM $ASCII

.MACRO $VBOT
  .EMIT <.PSECT .99997, D, RW>
.ENDM $VBOT

.MACRO $VIRT
  .EMIT <.PSECT .99998, D, RW>
.ENDM $VIRT

.MACRO $VTOP
  .EMIT <.PSECT .99999, D, RW>
.ENDM $VTOP

.MACRO $USER
.ENDM $USER

.MACRO VINIT
  .EMIT <.SAVE>
     $VIRT
  .IF NDF ..VB.
    ..VB. =: .
    ..VC. = ^O<0>
    .MACRO $VSET
      .EMIT <.BLKW>
      .MACRO $VSET
      .ENDM $VSET
    .ENDM $VSET
  .IFF
    .IF NE ..VC.
      ..VB. =: .
      .EMIT <.WORD ..VC.>
      ..VC. = ^O<0>
    .ENDC
    .MACRO $VSET
    .ENDM $VSET
  .ENDC
  .EMIT <.RESTORE>
.ENDM VINIT

.MACRO V.EVEN
  ..VC.=<..VC.+^O<1>>&^C<1>
.ENDM V.EVEN

.MACRO V.ODD
  ..VC.=<..VC.&^C<1>>+^O<1>
.ENDM V.ODD

.MACRO V.BLKW LAB LEN=<1>
  VALLOC LAB LEN WORDS
.ENDM V.BLKW

.MACRO V.BLKB LAB LEN=<1>
  VALLOC LAB LEN BYTES
.ENDM V.BLKB

.MACRO VALLOC LAB LEN UNIT
  .SAVE
    $VIRT
    .EMIT <LAB =: ..VB.+..VC.>
    .IF NB LEN
      .IF IDN <LEN>, <BYTE>
        $VSET
        ..VC.=..VC.+^O<1>
        .RESTORE
        .MEXIT
      .ENDC
      .IF IDN <LEN>, <WORD>
        .IIF NE ..VC.&^O<1> .ERROR ; ODD count
        V.EVEN
        $VSET
        ..VC.=..VC.+^O<2>
        .RESTORE
        .MEXIT
      .ENDC
      ..VM.=^O<0>
      .IIF IDN <UNIT>, <BYTES> ..VM.=^O<1>
      .IIF IDN <UNIT>, <WORDS> ..VM.=^O<2>
      .IF EQ ..VM.
        .ERROR ; Invalid units - 'UNIT'
        .RESTORE
        .MEXIT
      .ENDC
      .IF EQ ..VM.-^O<2>
        .IIF NE ..VC.&^O<1> .ERROR ; ODD count
        V.EVEN
      .ENDC
      $VSET
      ..VC.=<'LEN'>*..VM.+..VC.
    .ENDC
  .RESTORE
.ENDM VALLOC

.MACRO $ORDER TYPE
  .IF IDN <TYPE>, <NOSECT>
    .MACRO $COMMON N
    .ENDM $COMMON
    .MACRO $CODE
    .ENDM $CODE
    .MACRO $IDATA
    .ENDM $IDATA
    .MACRO $PDATA
    .ENDM $PDATA
    .MACRO $ASCII
    .ENDM $ASCII
    .MACRO $VBOT
    .ENDM $VBOT
    .MACRO $VIRT
    .ENDM $VIRT
    .MACRO $VTOP
    .ENDM $VTOP
    .MACRO $USER
    .ENDM $USER
    .MACRO VINIT
      .ERROR ; Not implemented
    .ENDM VINIT
    .MACRO V.EVEN
      .ERROR ; Not implemented
    .ENDM V.EVEN
    .MACRO V.ODD
      .ERROR ; Not implemented
    .ENDM V.ODD
    .MACRO V.BLKW LAB LEN=<1>
      .ERROR ; Not implemented
    .ENDM V.BLKW
    .MACRO V.BLKB LAB LEN=<1>
      .ERROR ; Not implemented
    .ENDM V.BLKB
    .MACRO VALLOC LAB LEN UNIT
      .ERROR ; Not implemented
    .ENDM VALLOC
    .MACRO $ORDER TYPE
    .ENDM $ORDER
    .MACRO ADJUST
    .ENDM ADJUST
  .IFF
    .SAVE
      $CODE
      $ASCII
      $PDATA
      $IDATA
      $USER
      $VBOT
      $VIRT
      $VTOP
 
      VINIT
    .RESTORE
  .ENDC
.ENDM $ORDER

.MACRO ADJUST
  .SAVE
    $PDATA
    .EVEN
    $IDATA
    .EVEN
    $ASCII
    .EVEN
    $VIRT
    V.EVEN
  .RESTORE
.ENDM ADJUST

.MACRO $SAVAL
  .GLOBL $SAVAL
  .EMIT <JSR %7, $SAVAL>
.ENDM $SAVAL

.MACRO .SAVR1
  .GLOBL .SAVR1
  .EMIT <JSR %5, .SAVR1>
.ENDM .SAVR1

.MACRO $SAVVR
  .GLOBL $SAVVR
  .EMIT <JSR %2, $SAVVR>
.ENDM $SAVVR

.MACROS $SAVRG
  .GLOBL $SAVRG
  .EMIT <JSR %5, $SAVRG>
.ENDM $SAVRG

.MACRO PUSHB LIST
  .PUSH <LIST>, B
.ENDM PUSHB

.MACRO PUSH LIST
  .PUSH <LIST>
.ENDM PUSH

.MACRO POPB LIST
  .POP  <LIST>, B
.ENDM POPB

.MACRO POP LIST
  .POP  <LIST>
.ENDM POP

.MACRO .PUSH LIST, BB
  .IF B <LIST>
    .EMIT <CLR'BB' -(%6)>
  .IFF
    .IRP X, <LIST>
      .IF NB X
        .IF IDN <X>, <#0>
          .EMIT <CLR'BB' -(%6)>
        .IFF
          .EMIT <MOV'BB' X, -(%6)>
        .ENDC
      .IFF
        .EMIT <CLR'BB' -(%6)>
      .ENDC
    .ENDR
  .ENDC
.ENDM .PUSH

.MACRO .POP LIST, BB
  .IF B <LIST>
    .EMIT <TST'BB' (%6)+>
  .IFF
    .IRP X, <LIST>
      .IF NB X
        .EMIT <MOV'BB' (%6)+, X>
      .IFF
        .EMIT <TST'BB' (%6)+>
      .ENDC
    .ENDR
  .ENDC
.ENDM .POP

.MACRO $GOTO LABEL, MESSAGE
  .IF B <MESSAGE>
    .IIF NE .-<'LABEL'> .ERROR ; LABEL must be next
  .IFF
    .IIF NE .-<'LABEL'> .ERROR ; MESSAGE
  .ENDC
.ENDM $GOTO

.MACRO $RGOTO LABEL, BASE, MESSAGE
  .IF B <MESSAGE>
    .IIF NE .-<'LABEL'>-<'BASE'> .ERROR ; LABEL must be next
  .IFF
    .IIF NE .-<'LABEL'>-<'BASE'> .ERROR ; MESSAGE
  .ENDC
.ENDM $RGOTO