*DECK VALFUNC 
USETEXT CCTTEXT 
USETEXT DNTEXT
          PROC  VALFUNC;
  
#**       VALFUNC -  LOAD FROM A FUNCTION INTO ARG
* 
*         INPUT PARAMETERS ARE PASSED IN INT$ COMMON- 
*                INT$FUN = FUNCTION ORDINAL 
*               INT$ARG = ORDINAL OF ARGUMENT 
*                INT$VARG = CONTENTS OF FIXED CELL *INT$ARG*
*                INT$VFIX = O"77777777777777777777" 
* 
* 
*        SETS INT$VFUN = VALUE OF FUNCTION. 
*         SETS INT$TABL = TABLE REFERENCE  (USUALLY ZERO) 
* 
*         FOR DEBUG,
*           IF FINAL ARGUMENT IS NOT THE FIXED CELL,
*           SETS INT$VFIX = VALUE OF FIXED CELL AND 
*           SETS INT$VARG = FINAL VALUE OF ARGUMENT.
# 
  
          BEGIN 
          CONTROL PACK; 
  
  
*CALL M$
  
*CALL ASMSEQ
*CALL AUXT1 
  
*CALL AUXTVALS
  
          COMMON  CGENSY; 
              BEGIN 
              ARRAY  [0:75];
                  ITEM  CGENSY$WORD  U(0, 0,60);
              END 
  
  
  
*CALL DNATVALS
  
  
*CALL FIELDS
  
  
*CALL FIXCOM
  
*CALL IDBLOCK 
  
*CALL FIXED 
  
*CALL FDLT
*CALL FNAT1 
*CALL FITDEFS 
*CALL FNATVALS
  
*CALL FUNCTIONL 
  
*CALL GTEXT 
  
*CALL INT$
  
*CALL LAT1
  
*CALL PLT1
*CALL PLTVALS 
*CALL NAMET 
  
*CALL PNAT1 
  
*CALL PNT 
  
*CALL RCT 
*CALL REGTABL 
  
*CALL RAPLUSC 
  
          SWITCH SETSYL 
*CALL SETSYS
  
*CALL SUBTYPE 
  
*CALL SUBINFO 
  
*CALL TABLETYP
  
*CALL W$
  
          $BEGIN
*CALL BUG202C 
          $END
  
          XDEF  PROC OCCLEN;
  
          XREF PROC ABORT;
          XREF PROC CBLIST; 
          XREF  PROC  CGABORT;         # INTERNAL COMPILER ERROR       #
          XREF  FUNC  DEC      C(10);  # DECIMAL DISPLAY VALUE         #
          XREF FUNC GETLFN; 
          XREF  PROC  GETPLST;         # GET PLT STRING ENTRY          #
          XREF  FUNC  NEXTLABEL    I;  # NEXT LOCAL LABEL NUMBER       #
          XREF  FUNC  NEXTR        I;  # NEXT VIRTUAL REGISTER NUMBER  #
          XREF  ITEM NRESREG; 
          XREF  PROC  PRINTOCT;        # PRINT OCTAL VALUE             #
          XREF  PROC  PRINTVAL;    # PRINT ERROR MESSAGE               #
          XREF  ITEM RCOUNT;
          XREF ITEM REGSEQ; 
          XREF  ITEM SGIXBLK I;        # SEGMENT INDEX TABLE           #
          XREF  ITEM  SGPTRDNATIX  I;  # POINTER INTO SEG. JUMP TABLE  #
          XREF  PROC  TMREOP;          # RE-OPEN A CLOSED TABLE        #
          XREF  ITEM  LASTPNAT     I;  # POINTER TO SEC 100 PNAT       #
          XREF  FUNC  VIRTUAL      I;  # INDEX TO A MANAGED TABLE      #
          XREF  ITEM  LIBNAME I;       # NAME OF LIBRARY FOR COBOL5#
  
          ITEM  ABSAUXTINDEX I;        # ABSOLUTE INDEX TO AUXT        #
          ITEM  AUXTINDEX    I;        # VIRTUAL INDEX TO AUXT         #
          ITEM  DNATINDEX    I;        # VIRTUAL INDEX TO DNAT         #
          ITEM  FNATINDEX    I;        # VIRTUAL INDEX TO FNAT         #
          ITEM  I            I;        # SCRATCH                       #
          ITEM  ITEMOFFSET   I;        # OFFSET IN CHARS OF ITEM #
          ITEM  ITEMLEN      I;        # LENGTH OF ITEM # 
          ITEM  LATINDEX     I;        # VIRTUAL INDEX TO LAT          #
          ITEM  NUMERICLIT   C(240);   # CURRENT NUMERIC LITERAL       #
          ITEM  PLTINDEX; 
          ITEM  PNATINDEX    I;        # VIRTUAL INDEX TO PNAT         #
          ITEM  T            I;        # USED BY GETFIX, GETDNATINDEX  #
          ITEM  TEMP         I;        # SCRATCH                       #
          ITEM  TEMP1        I;        # SCRATCH                       #
          ITEM  TEMP2        I;        # SCRATCH                       #
          ITEM  TEMPPTR      I;        #SCRATCH                        #
          ARRAY PRINTL [0: 1];
              ITEM PRLINE C(0,0,10);
CONTROL EJECT;
  
          DEF  COMPRESS     #1#;       # 1 MEANS TO COMPRESS *VALFUNC* #
  
          DEF  $C1$ 
          #$BEGIN 
          INT$VFIX = INT$VARG;
          INT$VARG = REGDNATADDR [INT$VARG];
          $END#;
  
          DEF  $C2$ 
          #$BEGIN 
          INT$VFIX = INT$VARG;
          INT$VARG = REGFNATADDR [INT$VARG];
          $END#;
  
          DEF  $C3$ 
          #$BEGIN 
          INT$VFIX = INT$VARG;
          INT$VARG = REGLATADDR [INT$VARG]; 
          $END#;
  
          DEF  $C4$ 
          #$BEGIN 
          INT$VFIX = INT$VARG;
          INT$VARG = REGPNATADDR [INT$VARG];
          $END#;
  
  
CONTROL IFEQ COMPRESS,0;               # IF SHOULD NOT COMPRESS VALFUNC#
  
          DEF  GETDNATINDEX 
 # DNATINDEX=VIRTUAL(TABLETYPE"DNAT$",REGDNATADDR[INT$VARG]); $C1$ T=T#;
  
          DEF  GETFNATINDEX 
 # FNATINDEX=VIRTUAL(TABLETYPE"FNAT$",REGFNATADDR[INT$VARG]); $C2$ T=T#;
  
          DEF  GETLATINDEX
 # LATINDEX=VIRTUAL(TABLETYPE"LAT$", REGLATADDR[INT$VARG]); $C3$ T=T#;
  
          DEF  GETPNATINDEX 
 # PNATINDEX=VIRTUAL(TABLETYPE"PNAT$",REGPNATADDR[INT$VARG]); $C4$ T=T#;
  
CONTROL ENDIF;
  
  
  
CONTROL IFEQ COMPRESS,1;               # IF SHOULD COMPRESS VALFUNC    #
  
          PROC  GETDNATINDEX; 
          BEGIN 
          DNATINDEX = VIRTUAL(TABLETYPE"DNAT$", REGDNATADDR[INT$VARG]); 
          $C1$
          END 
  
          PROC  GETFNATINDEX; 
          BEGIN 
          FNATINDEX = VIRTUAL(TABLETYPE"FNAT$", REGFNATADDR[INT$VARG]); 
          $C2$
          END 
  
          PROC  GETLATINDEX;
          BEGIN 
          LATINDEX = VIRTUAL(TABLETYPE"LAT$", REGLATADDR[INT$VARG]);
          $C3$
          END 
  
          PROC  GETPNATINDEX; 
          BEGIN 
          PNATINDEX = VIRTUAL(TABLETYPE"PNAT$", REGPNATADDR[INT$VARG]); 
          $C4$
          END 
  
  
CONTROL ENDIF;
CONTROL EJECT;
  
          ARRAY [1:2] S(1); 
              ITEM  BLANKCHAR    I(0, 0,60) = [O"55", O"5555"]; 
  
          ARRAY [1:3] S(1); 
              ITEM  ZEROCHAR     I(0, 0,60) = [O"33",O"3333",O"333333"];
  
          BASED ARRAY CCTREFARRAY [0:199] S(1); 
          ITEM  CCTENTRY         U(0, 0,60);
  
  
#      DECLARATIONS FOR *ROUNDOF* FUNCTION                             #
  
         ARRAY[-18:18] S(1);
              ITEM  ROUNDER      R(0, 0,60) = 
              [ 5.0E+17 
              , 5.0E+16 
                  , 5.0E+15 
                  , 5.0E+14 
                  , 5.0E+13 
                  , 5.0E+12 
                  , 5.0E+11 
                  , 5.0E+10 
                  , 5.0E+9
                  , 5.0E+8
                  , 5.0E+7
                  , 5.0E+6
                  , 5.0E+5
                  , 5.0E+4
                  , 5.0E+3
                  , 5.0E+2
                  , 5.0E+1
                  , 5.0 
                  , 5.0E-1
                  , 5.0E-2
                  , 5.0E-3
                  , 5.0E-4
                  , 5.0E-5
                  , 5.0E-6
                  , 5.0E-7
                  , 5.0E-8
                  , 5.0E-9
                  , 5.0E-10 
                  , 5.0E-11 
                  , 5.0E-12 
                  , 5.0E-13 
                  , 5.0E-14 
                  , 5.0E-15 
                  , 5.0E-16 
                  , 5.0E-17 
                  , 5.0E-18 
              , 5.0E-19 
                                   ]; 
  
  
          ARRAY [0:0] S(1); 
              BEGIN 
              ITEM  SETSY$WORD   I(0, 0,60);
              ITEM  SETSY$TYPE   U(0, 0,12);
              ITEM  SETSY$ARG    I(0,12,18);
              ITEM  SETSY$FIXCON B(0,41, 1);
              ITEM  SETSY$CONST  I(0,42,18);
              END 
          DEF  SETSYWORD     #SETSY$WORD[0]#; 
  
          SWITCH  FWA$OFL 
               ,  DFWA$OF    # 1 = DATAREF                             #
               ,             # 2 = FILEREF                             #
               ,  RFWA$OF    # 3 = LABLREF                             #
               ,  LFWA$OF    # 4 = LITREF                              #
               ,  PFWA$OF    # 5 = PROCREF                             #
               ,             # 6 = SUBATOM                             #
               ,             # 7 = SUBVERB                             #
               ,  SFWA$OF    # 8 = SYSREF                              #
               ,  VFWA$OF    # 9 = VERB                                #
               ,             #10 = TEMPREF                             #
               ;
*CALL,ASSEMOP 
          CONTROL EJECT;
          PROC FINDAUX (FINDAUXPAR);
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*         PROC FINDAUX
* 
*         DOES - FINDS AN AUX TABLE ENTRY 
* 
*         INPUTS
*             ABSAUXTINDEX HAS AUX TABLE INDEX OF START OF AUX CHAIN
*             PARAMETER IN CALL IS AUXTTYPE TO LOOK FOR 
* 
*         OUTPUTS 
*             ABSAUXTINDEX IS ZERO IF NONE FOUND
*             AUXTINDEX IS VIRTUAL INDEX TO FOUND AUX ENTRY IF ONE
* 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
          BEGIN 
          ITEM FINDAUXPAR I;
  
          IF ABSAUXTINDEX NQ 0
          THEN
              BEGIN 
              FOR AUXTINDEX = VIRTUAL(TABLETYPE"AUX$", ABSAUXTINDEX)
              WHILE ABSAUXTINDEX NQ 0 
              AND AX$TTYPE [AUXTINDEX] NQ FINDAUXPAR
              DO
                  BEGIN 
                  ABSAUXTINDEX = AX$TNEXTPTR [AUXTINDEX]; 
                  IF ABSAUXTINDEX NQ 0
                  THEN
                      AUXTINDEX = VIRTUAL (TABLETYPE"AUX$", 
                          ABSAUXTINDEX);
                  END 
              END 
          RETURN; 
          END 
          CONTROL EJECT;
          PROC FINDDNAUX (FINDDNPAR); 
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
* 
*         PROC FINDDNAUX - FIND AUX ENTRY FOR A DNAT
* 
*         DOES - SEARCHES AUX LINKS FOR AUX ENTRY MATCHING PARAM
* 
*         INPUTS
*                 REGULAR VALFUNC DNAT PTR
*                 INPUT PARAMETER IS AUXTTYPE TO COMPARE AGAINST
* 
*         OUTPUT - ABSAUXTINDEX HAS INDEX TO MATCHING ITEM OR 0 IF NONE 
*                 AUXTINDEX HAS VIRTUAL INDEX TO MATCHING ITEM
* 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
          BEGIN 
          ITEM FINDDNPAR I; 
  
          GETDNATINDEX; 
          ABSAUXTINDEX = DN$AUXREF [DNATINDEX]; 
          FINDAUX (FINDDNPAR);
          RETURN; 
          END 
          CONTROL EJECT;
          PROC GETOFFSET (DNATPTR); 
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
* 
*         PROC - GETOFFSET
* 
*         DOES - GETS CHARACTER OFFSET AND LENGTH OF AN ITEM
* 
*         INPUTS
*                 DNATPTR - PARAMETER IS DNAT POINTER OF ITEM 
* 
*         OUTPUTS 
*                 ITEMOFFSET - OFFSET 
*                 ITEMLEN - LENGTH
*                 DNATINDEX - VIRTUAL DNAT POINTER TO ITEM
* 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * # 
  
          BEGIN 
          ITEM DNATPTR; 
  
          DNATINDEX = VIRTUAL(TABLETYPE"DNAT$", DNATPTR); 
          ITEMOFFSET = (10 * DN$WORDOFF[DNATINDEX]) + 
            DN$CHARPOS[DNATINDEX];
          ITEMLEN = DN$ITMLEN[DNATINDEX]; 
          RETURN; 
          END 
          CONTROL EJECT;
          PROC  OCCLEN; 
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
* 
*         PROC   OCCLEN 
* 
*         DOES -  FINDS MAXOCC AUX TABLE ENTRY WHICH HAS SUBSLEVEL
*                 MATCHING THE FIRST PARAMETER
*                 SET  THE RETURN VALUE TO AUXOCCLEN OF THE MATCH 
* 
*         INPUTS
*                P1 - REGTABLE POINTER FOR DNAT 
*                P2 - LEVEL 
* 
*         OUTPUTS 
*                P1 - VALUE OF AUXOCCLEN FOR GIVEN DNAT AND LEVEL 
* 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
          BEGIN 
          ITEM FMOCP1 I;
          ITEM FMOCP2 I;
  
          DNATINDEX = VIRTUAL(TABLETYPE"DNAT$", 
                             REGDNATADDR[FIXEDCELL[FIXED"P1"]]);
          FMOCP1 = FIXEDCELL[FIXED"P2"];
          ABSAUXTINDEX = DN$AUXREF [DNATINDEX]; 
          FOR TEMP = 0 WHILE TEMP EQ 0
          DO
              BEGIN 
              FINDAUX (MAXOCCUR);   #FIND AN ENTRY# 
              IF ABSAUXTINDEX EQ 0
              THEN
                  BEGIN   # AN ERROR - NO ENTRY FOUND # 
                  INT$VFUN = 0; 
                  $BEGIN
                  CGABORT ("FINDMAXOCC"); 
                  $END
                  RETURN; 
                  END 
              IF AX$SUBSLVL [AUXTINDEX] NQ FMOCP1 
              THEN
                  ABSAUXTINDEX = AX$TNEXTPTR [AUXTINDEX];  #CHECK NEXT# 
              ELSE
                  TEMP = 1;    #FOUND IT# 
              END 
          FIXEDCELL[FIXED"P1"] = AX$OCCLEN[AUXTINDEX];
          RETURN; 
          END 
          CONTROL EJECT;
          PROC FINDSEGENT;
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
* 
*         PROC - FINDSEGENT 
* 
*         DOES - FINDS SEGENTRYIX IN THE AUX TABLE IF ANY 
* 
*         INPUT - PNAT VIRTUALIZED INDEX IN PNATINDEX 
* 
*         OUTPUTS - AUXTINDEX HAS VIRTUAL INDEX OF AUX ENTRY
*                 ABSAUXTINDEX HAS ABSOLUTE INDEX OF AUX OR 0 IF NONE 
* 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
          BEGIN 
          ABSAUXTINDEX = PN$AUXREF [PNATINDEX]; 
          FINDAUX (SEGENTRYIX); 
          RETURN; 
          END 
  
  
  
          XDEF PROC SETSAVEA1;
          PROC SETSAVEA1; 
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #        PROC - SETSAVEA1                                             #
 #                                                                     #
 #        DOES - SETS SAVEA1 FOR CID LOADER TABLES FOR ASM2            #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
          BEGIN 
          SAVEA1 = FIXEDCELL[FIXED"P1"];
          RETURN; 
          END 
          CONTROL EJECT;
          PROC VARGRPROC; 
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
* 
*         PROC - VARGRPROC
* 
*         DOES -  LOOKS UP MAXOCCUR ENTRY IN AUX TABLE FOR A VAR
*                 OCCUR GROUP - COMMON TO TWO ROUTINES
* 
*         INPUT - VIRTUALIZED DNAT POINTER IN DNATINDEX 
* 
*         OUTPUT - AUX POINTER TO MAX OCCUR ENTRY 
*                IN AUXTINDEX (VIRTUALIZED) 
*                ABSAUXTINDEX = 0 IF NONE - NON-ZERO IF ONE 
* 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
          BEGIN 
          ABSAUXTINDEX = DN$AUXREF[DNATINDEX] ; 
          FINDAUX(SUBOCCDP);
          IF ABSAUXTINDEX NQ 0
          THEN
              BEGIN 
              DNATINDEX = VIRTUAL (TABLETYPE"DNAT$",AX$OCCNAM 
                  [AUXTINDEX]); 
              ABSAUXTINDEX = DN$AUXREF [DNATINDEX]; 
              FINDAUX (MAXOCCUR);   #GET MAXOCCUR AUX#
              END 
          RETURN; 
          END 
CONTROL EJECT;
  
          INT$TABL = 0; 
          $BEGIN
          INT$VFIX = O"77777777777777777777";    # ASSUME VARG IS VFIX #
          $END
          GOTO FUNCTIONL[INT$FUN];     # JUMP ACCORDING TO FUNCTION ORD#
  
  
ABSVALOF: 
 #     COMPASS CODE IN EVALCFN  # 
          RETURN; 
  
  
ALLBITOF: 
          RETURN; 
  
  
 ANTYPEOF:  
          GETDNATINDEX; 
          INT$VFUN = DN$ANTYPE[DNATINDEX];
          RETURN; 
  
  
ARITH1: 
 #     COMPASS CODE IN EVALCFN  # 
          RETURN; 
  
  
ARITH2: 
ARITH3: 
 #     COMPASS CODE IN EVALCFN  # 
          RETURN; 
  
  
ARITH4: 
          $BEGIN
          IF INT$VARG LS 1 OR INT$VARG GR 2  THEN 
              BEGIN 
              CGABORT("ARITH4");
              INT$VFUN = 0; 
              RETURN; 
              END 
          $END
          INT$VFUN = BLANKCHAR[INT$VARG]; 
          RETURN; 
  
  
ARITH4N:  
          $BEGIN
          IF INT$VARG LS 1 OR INT$VARG GR 2  THEN 
              BEGIN 
              CGABORT("ARITH4N"); 
              INT$VFUN = 0; 
              RETURN; 
              END 
          $END
          INT$VFUN = ZEROCHAR[INT$VARG];
          RETURN; 
  
  
ARITH5: 
ARITH6: 
ARITH7: 
ARITH8: 
ARITH9: 
ARITH10:  
ARITH11:  
ARITH12:  
ARITH13:  
ARITH14:  
ARITH15:  
ARITH16:  
ARITH17:  
ARITH18:  
ARITH19:  
 #     COMPASS CODE IN EVALCFN  # 
          RETURN; 
  
  
ARITH20:  
          $BEGIN
          IF INT$VARG LS 1 OR INT$VARG GR 3  THEN 
              BEGIN 
              CGABORT("ARITH20"); 
              INT$VFUN = 0; 
              RETURN; 
              END 
          $END
          INT$VFUN = ZEROCHAR[INT$VARG];
          RETURN; 
  
  
ARITH21:  
ARITH22:  
 #     COMPASS CODE IN EVALCFN  # 
          RETURN; 
  
  
 AUXDNPOF:                   # AUXTABLE ENTRY DNAT POINTER             #
          INT$VFUN = AX$SKEYDNAT[VIRTUAL(TABLETYPE"AUX$",INT$VARG)];
          RETURN; 
  
  
 AUXFNPOF:                   # AUXTABLE ENTRY FNAT POINTER             #
          INT$VFUN = AX$FNFNAT[VIRTUAL(TABLETYPE"AUX$", INT$VARG)]; 
          RETURN; 
  
  
 AUXMAXOC:  
          INT$VFUN = AX$MAXOCCNO[VIRTUAL(TABLETYPE"AUX$",INT$VARG)];
          RETURN; 
AUXNXTOF: 
          INT$VFUN = AX$TNEXTPTR[VIRTUAL(TABLETYPE"AUX$",INT$VARG)];
          RETURN; 
  
 AUXOCCLN:  
          INT$VFUN = AX$OCCLEN[VIRTUAL(TABLETYPE"AUX$",INT$VARG)];
          RETURN; 
  
  
AUXRCVOF: 
          INT$VFUN = AX$TFIRST[VIRTUAL(TABLETYPE"AUX$",INT$VARG)];
          RETURN; 
  
  
AUXREFOF: 
          GETDNATINDEX; 
          INT$VFUN = DN$AUXREF[DNATINDEX];
          RETURN; 
  
  
BCPOF:  
BINVALOF: 
BYTLENOF: 
 #     COMPASS CODE IN EVALCFN  # 
          RETURN; 
 BITLENOF:  
          GETDNATINDEX; 
          INT$VFUN = DN$BITLEN[DNATINDEX];
          RETURN; 
  
  
CCTBIT: 
          INT$VFUN = B<INT$ARG,1>CCTFLAGINFO[0];
          RETURN; 
  
  
CCTWORD:  
          P<CCTREFARRAY> = LOC(CCTENTRIES[0]);
          INT$VFUN = CCTENTRY[INT$ARG]; 
          RETURN; 
  
  
CLASSOF:  
          GETDNATINDEX; 
          TEMP = DN$TYPE[DNATINDEX];
          IF TEMP EQ COMP4
           OR TEMP EQ NUMEDIT  THEN 
              TEMP = COMP;
          IF TEMP EQ EXTFLOAT  THEN 
              TEMP = COMP2; 
          INT$VFUN = TEMP;
          RETURN; 
  
  
 CONSTOF: 
          INT$VFUN = RAPLUS [INT$MODADR + INT$ARG]; 
          RETURN; 
  
  
DEPNAMOF: 
          FINDDNAUX (SUBOCCDP);  #FIND AUX ENTRY# 
          $BEGIN
          IF ABSAUXTINDEX EQ 0
          THEN    #ERROR - NO AUX ENTRY#
              BEGIN 
              CGABORT("DEPNAMOF");
              RETURN; 
              END 
          $END
          INT$VFUN = AX$DEPNAM[AUXTINDEX];
          RETURN; 
  
  
 DMFUTOF:                    #CDCS -FILE USAGE- TABLE ENTRY            #
          CONTROL IFNQ CB5$CDCS,"NO"; 
          FNATINDEX = VIRTUAL(TABLETYPE"FNAT$", INT$VARG);
          IF FN$SSCHEMA[FNATINDEX] EQ 0  #IF NOT A SS-DESCRIBED FILE# 
           OR FN$SSRELATN[FNATINDEX] NQ 0  #IF A SS -RELATION-# 
           OR FN$ABORT[FNATINDEX] NQ 0
          THEN
          INT$VFUN = 0; 
          ELSE
          BEGIN 
              INT$VFUN = FN$AREAORD[FNATINDEX]; 
              B<0,8>INT$VFUN = FN$VBITS[FNATINDEX]; 
          END 
          RETURN; 
          CONTROL FI; 
  
  
 DMLOSZOF:                   #SUB-SCHEMA LOADER OMIT TABLE SIZE        #
          CONTROL IFNQ CB5$CDCS,"NO"; 
          TEMP = VIRTUAL(TABLETYPE"PLTSTR$", INT$VARG); 
          INT$VFUN = C<2,2>PLT$CHAR[TEMP];
          RETURN; 
          CONTROL FI; 
  
  
 DMLOWDOF:                   #SUB-SCHEMA LOADER OMIT TABLE ENTRY       #
          CONTROL IFNQ CB5$CDCS,"NO"; 
          TEMP = VIRTUAL(TABLETYPE"PLTSTR$", INT$VARG); 
          INT$VFUN = PLT$CHAR[TEMP];
          RETURN; 
          CONTROL FI; 
  
  
 DMPLTSTR:                   #SS LOADER OMIT TABLE -PLTSTR- POINTER    #
          CONTROL IFNQ CB5$CDCS,"NO"; 
          TEMP = VIRTUAL(TABLETYPE"PLT$", INT$VARG);  #PLT ENTRY# 
          INT$VFUN = PL$STRINGPTR[TEMP];
          RETURN; 
          CONTROL FI; 
  
  
 DMPRGID:                    #PROGRAM-ID WITH ZERO FILL                #
          CONTROL IFNQ CB5$CDCS,"NO"; 
          INT$VFUN = CCTPROGRAMID;
          FOR I = 54 STEP -6 WHILE B<I,6>INT$VFUN EQ O"55" DO 
              B<I,6>INT$VFUN = 0; 
          RETURN; 
          CONTROL FI; 
  
  
 DMRORDOF:                   #GET SUB-SCHEMA RECORD ORDINAL            #
          CONTROL IFNQ CB5$CDCS,"NO"; 
          FINDDNAUX (FILENAME);  #FIND AUX ENTRY FOR FILE NAME# 
          FNATINDEX = VIRTUAL(TABLETYPE"FNAT$", AX$FNATPTR[AUXTINDEX]); 
          IF FN$SSCHEMA[FNATINDEX] EQ 0 THEN  #IF NOT CDCS I/O FILE#
          BEGIN 
              INT$VFUN = 0; 
              RETURN; 
          END 
          ABSAUXTINDEX = FN$DRECPTR [FNATINDEX];
          I = 0;
          FOR FNATINDEX = FNATINDEX WHILE I NQ DNATINDEX DO 
          BEGIN 
              $BEGIN
              IF ABSAUXTINDEX EQ 0
              THEN
                  BEGIN 
                  CGABORT("DMRORDOF");
                  RETURN; 
                  END 
              $END
              FINDAUX (DATARECNAME);  #GET AN AUX ENTRY#
              $BEGIN
              IF ABSAUXTINDEX EQ 0
              THEN
                  BEGIN  # AN ERROR - NONE EXISTS#
                  CGABORT ("DMRORDOF"); 
                  INT$VFUN = 0; 
                  RETURN; 
                  END 
              $END
              ABSAUXTINDEX = AX$TNEXTPTR [AUXTINDEX];  #GET NEXT ONE# 
              I = VIRTUAL(TABLETYPE"DNAT$", AX$DATARCNAM[AUXTINDEX]); 
          END 
          INT$VFUN = AX$DATARCORD[AUXTINDEX]; 
          RETURN; 
          CONTROL FI; 
  
  
DNATOF: 
          INT$VFUN = REGDNATADDR[INT$VARG]; 
          RETURN; 
  
  
 EQUALS:  
 #     COMPASS CODE IN EVALCFN  # 
          RETURN; 
  
  
FIGVALOF: 
          LATINDEX = VIRTUAL(TABLETYPE"LAT$", REGLATADDR[INT$VARG]);
          $BEGIN
          INT$VFIX = INT$VARG;
          INT$VARG = LATINDEX;
          $END
          INT$VFUN = L$HILO[LATINDEX];
          IF INT$VFUN NQ 0  THEN
              BEGIN 
              TEMP = L$PLT[LATINDEX]; 
              INT$VFUN = 1 + PL$FIGHIGHV[VIRTUAL(TABLETYPE"PLT$",TEMP)];
             END
          RETURN; 
  
  
 #
          FINDDP SEARCHES THROUGH THE PNAT TO FIND NEXT I-O DECLARATIVE 
          PROCEDURE.  IT RETURNS THE PNAT INDEX FOR THIS ONE
          IT CAN BE CALLED ONLY FROM GBRANCH  SINCE IT KEEPS A LOCAL
          POSITION POINTER
 #
 FINDDP:  
          ITEM FINDDPPTR I=1;    #PNAT POINTER# 
          I = 0;
          FOR TEMP = FINDDPPTR STEP 1 WHILE I EQ 0 DO 
              BEGIN 
              IF TEMP GR CCTPNATLEN 
              THEN
                  BEGIN   #ERROR - RAN OUT OF TABLE#
                  $BEGIN
                  PRINTVAL (1, "VALFUNC", FINDDPPTR); 
                  $END
                  I = 1;
                  TEST TEMP;
                  END 
              PNATINDEX = VIRTUAL (TABLETYPE "PNAT$", TEMP);
              IF PN$PROCKIND [PNATINDEX] EQ 0 THEN TEST TEMP; 
              IF PN$DECLARATV [PNATINDEX] EQ 0 THEN TEST TEMP;
              TEMP1 = PN$AUXREF [PNATINDEX];
              FOR TEMP1 = TEMP1 WHILE TEMP1 NQ 0 DO 
                  BEGIN 
                  AUXTINDEX = VIRTUAL (TABLETYPE "AUX$", TEMP1);
                  I = AX$TTYPE [AUXTINDEX]; 
                  IF I EQ AUXINPUTDCL 
                  OR I EQ AUXOUTPUTDCL
                  OR I EQ AUXIODCL
                  OR I EQ AUXEXTENDDCL
                  OR I EQ AUXFILEDCL
                  OR I EQ AUXHASH 
                  THEN
                      TEMP1 = 0;   #FOUND ONE#
                 CONTROL IFEQ CB5$CDCS,"CDCS2"; 
                  IF I EQ AUXREALMS 
                  OR I EQ AUXREALMNAME
                  THEN
                      TEMP1 = 0;
                 CONTROL FI;
  
                  IF TEMP1 NQ 0 THEN
                      BEGIN 
                      I = 0;
                      TEMP1 = AX$TNEXTPTR [AUXTINDEX];
                      END 
                  END 
              END 
          FINDDPPTR = TEMP; 
          INT$VFUN = TEMP - 1;         # POINT TO CORRECT PNAT ENTRY   #
          RETURN; 
  
  
 #
          FNALTK RETURNS THE ALTERNATE KEY AUX TABLE POINTER FROM FNAT
 #
 FNALTK:  
          GETFNATINDEX; 
          INT$VFUN = FN$ALTKPTR[FNATINDEX]; 
          RETURN; 
  
 #
          FNBLKNB GETS THE DATA ON THE BLOCK COUNT FROM THE FNAT
          IF IT IS A DNAT, THE DNAT POINTER IS RETURNED AND FIXED 
            REG P1 IS SET TO 3
          IF IT IS A LITERAL, P1 IS SET TO 1 AND THE VALUE IS RETURNED
 #
 FNBLKNB: 
          GETFNATINDEX; 
          IF FN$DBLCTVAL [FNATINDEX] EQ 0 
          THEN
              BEGIN 
              FIXEDCELL[FIXED"P1"] = 0;          # SET P1              #
              INT$VFUN = FN$DBLCTPTR[FNATINDEX];
              END 
          ELSE
              BEGIN 
              FIXEDCELL[FIXED"P1"] = 1;          # SET P1              #
              INT$VFUN = FN$DBLCTVAL[FNATINDEX];
              END 
          RETURN; 
  
FNDNATOF: 
          GETFNATINDEX; 
          INT$VFUN = FN$DNATPTR[FNATINDEX]; 
          RETURN; 
 #
          FNLABTS RETURNS 0 IF NO LABEL RECS - 1 IF SO
 #
 FNLABTS: 
          GETFNATINDEX; 
          IF FN$LABELREC [FNATINDEX] EQ STANDARD
          THEN
              INT$VFUN = 1; 
          ELSE
              INT$VFUN = 0; 
          RETURN; 
  
  
 #
          FNELEMR RETURNS THE DNAT POINTER TO AN ELEMENTART RECORD
          DESCRIPTION IF THE FILE HAS ONLY ONE AND THE RECS ARE NOT 
          VARIABLE LENGTH.
          OTHERWISE, ZERO IS RETURNED.
 #
 FNELEMR: 
          GETFNATINDEX; 
          IF FN$RECCOUNT [FNATINDEX] GR 1 
          THEN
              BEGIN    #MORE THAN ONE REC DESCR FOR FILE - RETURN ZERO# 
              INT$VFUN = 0; 
              RETURN; 
              END 
          INT$VFUN = FN$FRECPTR[FNATINDEX];     #POINTER TO FIRSTREC  # 
          TEMP = DN$TYPE[VIRTUAL(TABLETYPE"DNAT$", INT$VFUN)];
          IF TEMP EQ GROUP
           OR TEMP EQ VARGROUP  THEN
              INT$VFUN = 0;            # GROUP ITEM -  RETURN ZERO     #
          RETURN; 
  
  
 FNKNBOF: 
          ITEM PKDNAT I;  #PRIME KEY DNAT PTR#
          ITEM PKLEN I;   #PRIME KEY LENGTH#
          ITEM PKOFFSET I;
  
          GETFNATINDEX; 
          INT$VFUN = 0;  #DEFAULT RETURN# 
          PKDNAT = FN$RECPTR[FNATINDEX];
          IF PKDNAT EQ FIXEDCELL[FIXED"P1"] 
          THEN
              RETURN;  # IS PRIMARY KEY # 
          GETOFFSET (PKDNAT); 
          PKLEN = ITEMLEN;
          PKOFFSET = ITEMOFFSET;
#      GET INFO ON BEGINNING CHARACTER FROM DNAT IN P1                 #
          GETOFFSET (FIXEDCELL[FIXED"P1"]); 
          TEMP1 = ITEMOFFSET; 
          TEMP2 = ITEMLEN;
          I = 0;
#      GO THROUGH ALTERNATE KEY LIST LOOKING FOR A BCP MATCH           #
          FOR ABSAUXTINDEX = FN$ALTKPTR [FNATINDEX] WHILE 
          ABSAUXTINDEX NQ 0 DO
              BEGIN 
              FINDAUX (ALTKEYNAME); 
              IF ABSAUXTINDEX EQ 0
              THEN
                  TEST ABSAUXTINDEX;   #FINISHED - EXIT LOOP# 
              INT$VFUN = INT$VFUN + 1;           # SET FOR NEXT KEY    #
              TEMP = AX$ALTKEY[AUXTINDEX];  #DNAT PTR OF KEY# 
              IF TEMP EQ FIXEDCELL[FIXED"P1"] 
              THEN
                  RETURN;  # IS THIS ALTERNATE KEY #
              GETOFFSET (TEMP); 
              TEMPPTR = AX$TNEXTPTR [AUXTINDEX];  # PTR TO NEXT ALT AX$#
              IF TEMP1 EQ ITEMOFFSET  # SEE IF OFFSETS SAME # 
              THEN
                  BEGIN 
                  IF TEMP2 EQ ITEMLEN  # TEST LENGTH #
                  THEN
                      RETURN;  #AN ALTERNATE KEY# 
                  IF TEMP2 LS ITEMLEN   # IF ITEM SUBORDINATE TO KEY #
                  THEN
                      I = INT$VFUN;  # MAY BE PARTIAL ALT KEY - SAVE #
                  END 
              ABSAUXTINDEX = TEMPPTR;  # PTR TO NEXT ALT KEY AUX ENTRY #
              END 
          IF FIXEDCELL[FIXED"P2"] EQ 1
          THEN  # IS A START - SEE IF SUBORDINATE # 
              BEGIN 
              IF TEMP1  EQ PKOFFSET 
              AND TEMP2 LS PKLEN
              THEN
                  INT$VFUN = 0;   # IS SUBORDINATE TO PRIME KEY # 
              ELSE
                  INT$VFUN = I;  # SUBORDINATE TO ALT KEY # 
              END 
          ELSE
              INT$VFUN = 0;   # ON READ ALWAYS RETURN 0 # 
          RETURN; 
  
  
 #
       FNLINAG RETURNS 0 IF NO LINAGE PRESENT, 1 IF SO
 #
 FNLINAG: 
          GETFNATINDEX; 
          IF FN$LINAGPTR[FNATINDEX] EQ 0
          THEN
              INT$VFUN = 0; 
          ELSE
              INT$VFUN = 1; 
          RETURN; 
  
 FNMRLOF:                    # MRL FIELD FROM FILE FIT                 #
          GETFNATINDEX; 
          INT$VFUN = FN$ACCUMMAX[FNATINDEX];
          RETURN; 
  
  
FNRLKOF:  
          GETFNATINDEX; 
          IF FN$ORG [FNATINDEX] EQ RELATIVE 
          THEN
              INT$VFUN = FN$RELKPTR[FNATINDEX]; 
          ELSE
              INT$VFUN = FN$WAKPTR[FNATINDEX];
          RETURN; 
  
  
 FNRRCOF:                    #GET RERUN COUNT FROM FNAT#
 #
          FNRRCOF RETURNS RERUN ON N REC COUNT AND IN P1 RETURNS 1 IF 
          RERUN ON END OF UNIT/REEL GIVEN AND 0 IF NOT
 #
          GETFNATINDEX; 
          INT$VFUN = FN$RRUNREC [FNATINDEX];
          IF FN$RRUNEOR [FNATINDEX] EQ 1
          THEN
              FIXEDCELL [FIXED"P1"] = 1;   # P1 = 1 IF RRUN ON EOR #
         ELSE 
              FIXEDCELL [FIXED"P1"] = 0;
          RETURN; 
FNFOOF: 
          GETFNATINDEX; 
          INT$VFUN = FN$ORG[FNATINDEX]; 
          RETURN; 
  
 FNRTOF:                     #GET RECORD TYPE FROM FNAT # 
          GETFNATINDEX; 
          INT$VFUN = FN$RECTYPE[FNATINDEX]; 
          RETURN; 
  
 #
          FNVLREC TESTS FOR VARIABLE LENGTH RECORDS WITH SIZE FIELDS
            IF D OR T TYPE RECORDS, 0 RETURNED
            IF REC CONT DEP ON IS SPECIFIED, P1 AND P2 WILL BE 0 ON 
            RETURN. 
            IF OCC DEP ON SPECIFIED, P1 HAS OCC LENGTH, P2 FIXED LENGTH 
            ON RETURN.
            DNAT OF SIZE FIELD RETURNED AS FUNCTION VALUE.
            P3 HAS FNATPRINTF ON RETURN 
 #
 FNVLREC: 
          ITEM SD B;   #TRUE IF A SORT DESCRIPTION# 
          ITEM OFFSET1 I; 
          GETFNATINDEX; 
          INT$VFUN = 0; 
          DNATINDEX = VIRTUAL(TABLETYPE"DNAT$",FN$DNATPTR[FNATINDEX]);
          IF DN$LEVEL[DNATINDEX] EQ SDDESCR 
          THEN
              SD = TRUE;   #PROCESSING AN SD# 
          ELSE
              SD = FALSE;   #PROCESSING AN FD#
          IF FN$RECTYPE [FNATINDEX] EQ FITV$DT
          OR FN$RECTYPE [FNATINDEX] EQ FITV$TT
          THEN
              BEGIN 
              FIXEDCELL [FIXED"P3"] = 0;  #RETURN A 0 IN P3 FOR TEST# 
              IF NOT SD 
              OR (SD AND FIXEDCELL [FIXED"P1"] EQ 1)
              THEN
                  RETURN;  # NO PROC FOR FD OR RETURN WITH SD # 
              END 
          TEMP = 0; 
          TEMP1 = 0;
          IF FN$RCDEPPTR [FNATINDEX] EQ 0 
          THEN
              BEGIN 
              IF SD 
              AND FIXEDCELL[FIXED"P1"] EQ 1 
              THEN
                  RETURN;  #NO SIZE FIELD SET FOR SORT RETURN STATEMENT#
              IF FN$VARTYPE [FNATINDEX] EQ FNVGMS 
              OR FN$VARTYPE [FNATINDEX] EQ FNVGSS 
              THEN           # NOT RC DEP ON AND ODO IS IN 1 REC DESC # 
                  BEGIN 
                  DNATINDEX = VIRTUAL (TABLETYPE "DNAT$", 
                      REGDNATADDR [FIXEDCELL [FIXED"REGD"]]); 
                  OFFSET1 = DN$ITMLEN [DNATINDEX];
                  ABSAUXTINDEX = DN$AUXREF [DNATINDEX]; 
                  FINDAUX (SUBOCCDEP);  #FIND OCC DEP AUX ENTRY#
                  IF ABSAUXTINDEX NQ 0
                  THEN
                      BEGIN   #ODO TYPE#
                      I = VIRTUAL (TABLETYPE"DNAT$", AX$OCCNAM
                          [AUXTINDEX]); 
                      INT$VFUN = AX$DEPNAM [AUXTINDEX]; 
                      TEMP = DN$ITMLEN [I];  #LEN OF OCURRING ITEM# 
                      ABSAUXTINDEX = DN$AUXREF[I];
                      FINDAUX(MAXOCCUR);
                      TEMP1 = OFFSET1 - (AX$MAXOCCNO[AUXTINDEX] * 
                        AX$OCCLEN [AUXTINDEX]); # FIXED PART LENGTH # 
                      END 
                  END 
              END 
          ELSE
              INT$VFUN = FN$RCDEPPTR [FNATINDEX]; 
          FIXEDCELL [FIXED "P1"] = TEMP;
          FIXEDCELL [FIXED "P2"] = TEMP1; 
          IF FN$RPTPTR[FNATINDEX] EQ 0
          THEN  FIXEDCELL[FIXED"P3"] = FN$PRINTF[FNATINDEX];
          ELSE  FIXEDCELL[FIXED"P3"] = 0;        #REPORT FILE#
          RETURN; 
  
  
GCODEOF:  
          INT$VFUN = REGGCODE[INT$VARG];
          RETURN; 
  
  
 #
          GETDCCT RETURNS THE I-O DECLARATIVE COUNT WHICH WAS STORED
          IN IODECCT BY PROCTAB.
 #
 GETDCCT: 
          XREF ITEM DECLCT;   #HAS COUNT OF I-O DECLARATIVES# 
          INT$VFUN = DECLCT;
          RETURN; 
  
  
GPTROF: 
          INT$VFUN = REGGPTR[INT$VARG]; 
          RETURN; 
  
  
GSCODEOF: 
          INT$VFUN = REGGSCODE[INT$VARG]; 
          RETURN; 
  
  
 IMPNMOF: 
          IF INT$VARG EQ 0
          THEN
              BEGIN          # IF ARG IS ZERO WE WANT LIBRARY NAME# 
              INT$VFUN = LIBNAME; 
              RETURN; 
              END 
          TEMP = L$PLT[VIRTUAL(TABLETYPE"LAT$", REGLATADDR[INT$VARG])]; 
          TEMP = GETLFN (TEMP);   #GET FILE NAME# 
 #     CONVERT OUTPUT-C AND TERMINAL-C PROPERLY - PUT IN BLANK INSERT 
       FLAG FOR OUTPUT AND TERMINAL WITHOUT THE -C OPTION 
 #
          IF TEMP EQ O"17252420252446030000"  #OUTPUT-C#
          THEN
              TEMP = O"17252420252400000000";  #CHANGE TO OUTPUT NO INS#
          ELSE
              IF TEMP EQ O"24052215111601144603"  #TERMINAL-C#
              THEN
                  TEMP =  O"24052215111614000000";  #TERMINL - NO INS#
              ELSE
                  IF TEMP EQ O"17252420252400000000"     #OUTPUT# 
                  THEN
                      TEMP = TEMP + 1;   #SET INSERT FLAG#
                  ELSE
                      IF TEMP EQ O"24052215111601140000"  #TERMINAL#
                      THEN
                          TEMP = O"24052215111614000001";  #TERMINL -IN#
          INT$VFUN = TEMP;
          RETURN; 
  
  
INTLENOF: 
          INT$VFUN = REGNUMLEN[INT$VARG] - REGPOINT[INT$VARG];
          RETURN; 
  
  
JUSTOF: 
          INT$VFUN = REGJUST[INT$VARG]; 
          RETURN; 
  
  
LATALLOF: 
          IF REGGCODE[INT$VARG] EQ GLITREF  THEN
              INT$VFUN =
                L$ALL[VIRTUAL(TABLETYPE"LAT$", REGLATADDR[INT$VARG])];
          ELSE
              INT$VFUN = 0; 
          RETURN; 
  
  
LDROMIT:  
LDRUSE: 
          $BEGIN
          CGABORT("LDRFUNC"); 
          RETURN; 
          $END
  
  
LDSIGNOF: 
          GETDNATINDEX; 
          INT$VFUN = DN$LSIGN[DNATINDEX]; 
          RETURN; 
  
  
LEVELOF:  
          INT$VFUN = REGLEVEL[INT$VARG];
          RETURN; 
  
  
 LITREFOF:  
          IF  REGLITIMM[INT$VARG] EQ 0
          THEN  GETPLST(REGLITPLT[INT$VARG],LOC(NUMERICLIT)); 
          ELSE  C<0,10>NUMERICLIT = DEC(REGLITPLT[INT$VARG]); 
          TEMP = 0; 
          B<42,18>TEMP = LOC(NUMERICLIT); 
          B<41,1>TEMP = REGLITSGN[INT$VARG];
          B<0,2>TEMP = 1; 
          B<2,10>TEMP = REGLITLEN[INT$VARG];
          B<12,18>TEMP = REGLITPLT[INT$VARG]; 
          INT$VFUN = TEMP;
          RETURN; 
  
  
LNGOFFOF: 
          GETDNATINDEX; 
          INT$VFUN = DN$LONGOFF[DNATINDEX]; 
          RETURN; 
  
  
LOCLAB: 
          IF INT$ARG NQ 0  THEN 
              BEGIN 
              FIXEDCELL[INT$ARG] = NEXTLABEL;    # CALL FUNCTION       #
              INT$VFUN = FIXEDCELL[INT$ARG];
              END 
          ELSE
              INT$VFUN = NEXTLABEL;              # CALL FUNCTION       #
          RETURN; 
  
  
MAJMSCOF: 
          GETDNATINDEX; 
          INT$VFUN = DN$MAJMSEC[DNATINDEX]; 
          RETURN; 
  
  
 MNVALOF: 
 #     GET THE MNEMONIC CHARACTER OUT OF THE PLT  # 
          GETLATINDEX;
          GETPLST(L$PLT[LATINDEX], LOC(NUMERICLIT));
          INT$VFUN = 0; 
          B<54,6>INT$VFUN = B<0,6>NUMERICLIT; 
          RETURN; 
NUMLENOF: 
 #     COMPASS CODE IN EVALCFN  # 
          RETURN; 
  
  
MXOCC1OF: 
  
  
MXOCC2OF: 
  
  
MXOCC3OF: 
          RETURN; 
  
  
OCCLN1OF: 
  
  
OCCLN2OF: 
  
  
OCCLN3OF: 
          RETURN; 
  
  
 PALTEROF:  
          GETPNATINDEX; 
          INT$VFUN = PN$ALTERED [PNATINDEX];
          RETURN; 
  
  
 #
       PARANAM IS CALLED TO RETURN THE PARAGRAPH NAME FOR THE PARAGRAPH 
       TRACE OPTION.
       IT RETURNS THE FIRST 10 CHARS OF THE NAME IN P1, THE SECOND 10 
       IN P2 AND THE THIRD IN P3. 
       THE INPUT IS THE PNT NUMBER (SAME AS PNAT NUMBER). 
 #
 PARANAM: 
          ITEM PARANAMFT B = TRUE;
  
          IF PARANAMFT
          THEN
              BEGIN   #FIRST TIME THROUGH#
              PARANAMFT = FALSE;
              TMREOP  (TABLETYPE "PNT$");   #OPEN THE TABLE#
              TMREOP(TABLETYPE"NAMET$");
              END 
          PNATINDEX = VIRTUAL (TABLETYPE"PNT$", REGPNATADDR [INT$VARG]);
          $C4$
          I = PNTNAMETPTR[PNATINDEX]; 
          TEMP  = PNTNBRWORDS[PNATINDEX]; 
          FIXEDCELL[FIXED"P1"] = NAMET$CHARS[VIRTUAL(TABLETYPE"NAMET$", 
              I)];
          IF TEMP GR 1
          THEN
              BEGIN  # MORE THAN ONE WORD IN NAME - GET NEXT #
              FIXEDCELL[FIXED"P2"] = NAMET$CHARS[VIRTUAL(TABLETYPE
                  "NAMET$", I + 1)];
              IF TEMP GR 2
              THEN
                  FIXEDCELL[FIXED"P3"] = NAMET$CHARS[VIRTUAL(TABLETYPE
                      "NAMET$", I + 2)];
              ELSE
                  FIXEDCELL[FIXED"P3"] = "          ";
              END 
          ELSE
              BEGIN 
              FIXEDCELL[FIXED"P2"] = "          ";
              FIXEDCELL[FIXED"P3"] = "          ";
              END 
          RETURN; 
  
  
 # PARNAM0 IS THE SAME AS PARNAM, EXCEPT PARAGRAPH NAME IS ZERO FILLED# 
 # ON THE RIGHT.  THIS IS FOR CID STYLIZED CODE                        #
          ITEM  C10         C(10);
 PARNAM0: 
          IF PARANAMFT  THEN
              BEGIN 
              PARANAMFT = FALSE;
              TMREOP(TABLETYPE"PNT$");
              TMREOP(TABLETYPE"NAMET$");
              END 
          PNATINDEX = VIRTUAL(TABLETYPE"PNT$",REGPNATADDR[INT$VARG]); 
          $C4$
          FIXEDCELL[FIXED"P1"] = 0; 
          FIXEDCELL[FIXED"P2"] = 0; 
          FIXEDCELL[FIXED"P3"] = 0; 
         FIXEDCELL[FIXED"P4"] = PNTLINE[PNATINDEX]; 
          I = PNTNAMETPTR[PNATINDEX]; 
          IF I EQ 0  THEN  RETURN;   # COMPILER GENERATED PNT          #
          TEMP = PNTNBRWORDS[PNATINDEX] - 1;
          C10 = NAMET$CHARS[VIRTUAL(TABLETYPE"NAMET$",I+TEMP)]; 
          TEMP1 = 0;
          FOR TEMP1 = TEMP1 WHILE C<TEMP1>C10 NQ " " AND TEMP1 LS 10 DO 
              TEMP1 = TEMP1 + 1;
          IF TEMP EQ 0 THEN 
              C<0,TEMP1>FIXEDCELL[FIXED"P1"] = C<0,TEMP1>C10; 
          ELSE
              BEGIN 
              FIXEDCELL[FIXED"P1"] =
                             NAMET$CHARS[VIRTUAL(TABLETYPE"NAMET$",I)]; 
              IF TEMP EQ 1 THEN 
                  C<0,TEMP1>FIXEDCELL[FIXED"P2"] = C<0,TEMP1>C10; 
              ELSE
                  BEGIN 
                  FIXEDCELL[FIXED"P2"] =
                           NAMET$CHARS[VIRTUAL(TABLETYPE"NAMET$",I+1)]; 
                  C<0,TEMP1>FIXEDCELL[FIXED"P3"] = C<0,TEMP1>C10; 
                  END 
              END 
          RETURN; 
  
  
PEQUOF: 
          GETPNATINDEX; 
          INT$VFUN = PN$EQUATE [PNATINDEX]; 
          RETURN; 
  
  
PFSSECOF: 
          I = 0;
          FOR TEMP = 1 STEP 1 WHILE I EQ 0 DO 
              BEGIN 
              PNATINDEX = VIRTUAL (TABLETYPE"PNAT$", TEMP); 
              IF PN$DECLARATV [PNATINDEX] NQ 0 THEN TEST TEMP;
              IF PN$PROCKIND [PNATINDEX] EQ 0 THEN TEST TEMP; 
              I = 1;                   #CORRECT ENTRY FOUND#
              END 
          INT$VFUN = TEMP - 1;         # POINT TO CORRECT PNAT ENTRY   #
          RETURN; 
  
  
PKINDOF:  
          GETPNATINDEX; 
          INT$VFUN = PN$PROCKIND [PNATINDEX]; 
          RETURN; 
  
  
PLOCALOF: 
          GETPNATINDEX; 
          ABSAUXTINDEX = PN$AUXREF [PNATINDEX]; 
         FINDAUX(AUXLOCAL); 
         INT$VFUN = AX$LOCALNO[AUXTINDEX];
          RETURN; 
  
 PLTQUOTE:  
          INT$VFUN = 0; 
          IF  REGLITIMM[INT$VARG] EQ 1  THEN RETURN;
          IF  L$ALL[VIRTUAL(TABLETYPE"LAT$",REGLATADDR[INT$VARG])] NQ 0 
          THEN  RETURN; 
          PLTINDEX = VIRTUAL(TABLETYPE"PLT$",REGLITPLT[INT$VARG]);
          IF  PL$CODE[PLTINDEX] EQ PLTQUOTEDLIT  THEN  INT$VFUN = 1;
          RETURN; 
  
PNXSECOF: 
          GETPNATINDEX; 
          INT$VFUN = PN$NEXTSECTN [PNATINDEX];
          RETURN; 
  
  
POINTOF:  
          INT$VFUN = REGPOINT[INT$VARG];
          RETURN; 
  
  
PPERFBOF: 
  
  
PPERFEOF: 
          GETPNATINDEX; 
          INT$VFUN = PN$PERFLAST [PNATINDEX]; 
          RETURN; 
  
  
PSEGNOOF: 
          GETPNATINDEX; 
          INT$VFUN = PN$SEGMENTNO [PNATINDEX];
          RETURN; 
  
 PSGALTOF:  
          GETPNATINDEX; 
          ABSAUXTINDEX = PN$AUXREF[PNATINDEX];
          FINDAUX(SEGALTERIX);
          IF  ABSAUXTINDEX EQ 0 
          THEN  INT$VFUN = 0; 
          ELSE  INT$VFUN = AX$ALTERIX[AUXTINDEX]; 
          RETURN; 
  
PSGENTOF: 
          GETPNATINDEX; 
          FINDSEGENT;    #FIND SEGENTRYIX IN THE AUX TABLE IF ANY#
          IF ABSAUXTINDEX EQ 0
          THEN
              INT$VFUN = 0;  #NONE - RETURN 0#
          ELSE
              BEGIN 
              INT$VFUN = AX$ENTRYIX [AUXTINDEX];
              END 
          RETURN; 
  
  
 PSGEXTOF:  
          GETPNATINDEX; 
          FINDSEGENT;    #FIND SEGENTRYIX IN THE AUX TABLE IF ANY#
          IF ABSAUXTINDEX EQ 0
          THEN
              INT$VFUN = 0;  #NONE - RETURN 0#
          ELSE
              BEGIN 
              INT$VFUN = AX$EXITIX [AUXTINDEX]; 
              END 
          RETURN; 
  
  
 RCTENTOF:  
          INT$VFUN = RCT$ENTRY[VIRTUAL(TABLETYPE"RCT$",INT$VARG)] 
                   + RCT$ENTRY[VIRTUAL(TABLETYPE"RCT$",INT$VARG+1)];
          RETURN; 
REFOF:  
          TEMP = REGGCODE[INT$VARG];
          IF TEMP GQ GDATAREF  AND  TEMP LQ GTEMPREF  THEN
              INT$VFUN = 1; 
          ELSE
              INT$VFUN = 0; 
          RETURN; 
REGPTROF: 
          INT$VFUN = REGDNATADDR[INT$VARG]; 
          RETURN; 
  
  
REGWIXOF: 
          INT$VFUN = REGWORDINDX[INT$VARG]; 
          RETURN; 
  
 RFLENTYP:  
          INT$VFUN = RFLENTYPE[INT$VARG]; 
          RETURN; 
 RFLENVAL:  
          INT$VFUN = RFLENVALUE[INT$VARG];
          RETURN; 
 RFLCPTYP:  
          INT$VFUN = RFLCPTYPE[INT$VARG]; 
          RETURN; 
 RFLCPVAL:  
          INT$VFUN = RFLCPVALUE[INT$VARG];
          RETURN; 
  
ROOTLNOF: 
          GETDNATINDEX; 
          TEMP = DN$ITMLEN[DNATINDEX];
          VARGRPROC;     #DO COMMON VARIABLE GROUP PROCESS# 
          $BEGIN
          IF ABSAUXTINDEX EQ 0
          THEN
              BEGIN 
              CGABORT("ROOTLNOF1"); 
              RETURN; 
              END 
          $END
          INT$VFUN = TEMP - AX$MAXOCCNO[AUXTINDEX]*AX$OCCLEN[AUXTINDEX];
          RETURN; 
  
  
ROUNDOF:  
          B<0,60>INT$VFUN = B<0,60>ROUNDER[INT$VARG]; 
          RETURN; 
  
  
SBDPTHOF: 
          GETDNATINDEX; 
          INT$VFUN = DN$SDEPTH[DNATINDEX];
          RETURN; 
  
  
SCHAROF:  
          GETDNATINDEX; 
          INT$VFUN = DN$SCHAR[DNATINDEX]; 
          RETURN; 
  
 SEQUENCE:  
          REGCNT[VIRTUAL(TABLETYPE"ASMSEQ$",REGSEQ)] = RCOUNT;
          RCOUNT = NRESREG; 
          REGSEQ = REGSEQ + 1;
          INT$VFUN = REGSEQ;
          RETURN; 
  
 SETSYOF: 
          IF INT$ARG LS 128  THEN 
              SETSYWORD = COMMANDWORD[INT$MODADR + INT$ARG];
          ELSE
              SETSYWORD = CGENSY$WORD[INT$ARG - 128]; 
          IF SETSY$FIXCON[0]  THEN     # IF MODIFIER IS A FIXED CELL   #
              TEMP = FIXEDCELL[SETSY$CONST[0]]; 
          ELSE                         # IF MODIFIER IS A CONSTANT     #
              TEMP = SETSY$CONST[0];
          INT$TABL = 0;                # PRE-CLEAR TABL REFERENCE      #
          GOTO SETSYL[SETSY$TYPE[0]];  # BRANCH ACCORDING TO SETSY TYPE#
#   NOTE- SINCE THE PROCESSORS TO HANDLE *SETSY* TYPES ARE NOT         #
#         FUNCTIONS IN THE USUAL SENSE,                                #
#         THEY ARE NOT GROUPED WITH THESE FUNCTIONS.                   #
#         THEY APPEAR AT THE END OF THE PROGRAM.                       #
  
  
 SHL30OF: 
 #     COMPASS CODE IN EVALCFN  # 
          RETURN; 
  
  
SHOLITOF: 
          GETDNATINDEX; 
          INT$VFUN = DN$SHORTLIT[DNATINDEX];
          RETURN; 
  
  
SIGNOF: 
          INT$VFUN = REGSIGNBIT[INT$VARG];
          RETURN; 
  
  
 SMBYTLOF:                   # SORT/MERGE - KEY BYTE LENGTH            #
          INT$VFUN = DN$ITMLEN[VIRTUAL(TABLETYPE"DNAT$", INT$VARG)];
          RETURN; 
  
  
 SMFBYTOF:                   # SORT/MERGE -  KEY BYTE NUMBER           #
                             # FIXED CELL T1 CONTAINS POINTER TO DNAT  #
                             # OF 01 ENTRY OF 1ST RECORD DESC OF FD    #
          GETOFFSET (FIXEDCELL[FIXED"T1"]); 
          TEMP = ITEMOFFSET;
          GETOFFSET (INT$VARG); 
          INT$VFUN = ITEMOFFSET - TEMP + 1; 
          RETURN; 
  
  
 SMLGTHOF:                   # SORT/MERGE - MINIMUM AREA REQUIRED (WDS)#
                   # 100*(2 + (KEY LENGTH + 9)/10 + (MRL+9)/10 + 2000B #
          INT$VFUN = 100 * (20 + INT$VARG + 18)/10 + O"2000"; 
          RETURN; 
  
  
 SMSEQOF:                    # SORT/MERGE - ASCENDING/DESCENDING FLAG  #
          TEMP = AX$SKEYSEQ[VIRTUAL(TABLETYPE"AUX$", INT$VARG)];
          IF TEMP EQ ASCENDING  THEN
              IF CCTSORT4 THEN
                  INT$VFUN = 0; 
              ELSE
                  INT$VFUN = 1; 
          ELSE
              IF CCTSORT4 THEN
                  INT$VFUN = 1; 
              ELSE
                  INT$VFUN = 4; 
          RETURN; 
  
  
 SMSIGNOF:                   # SORT/MERGE - KEY SIGN                   #
          DNATINDEX = VIRTUAL(TABLETYPE"DNAT$", INT$VARG);
          TEMP = DN$SIGNGRP[DNATINDEX]; 
          TEMP1 = DN$TYPE[DNATINDEX]; 
          IF TEMP1 NQ NUMERIC THEN TEMP = 0;
                             # REVERSE SEPARATE/SIGNED BIT POSITIONS   #
          IF TEMP LS 4  THEN
              INT$VFUN = 0; 
          ELSE
              BEGIN 
              IF TEMP EQ 4  OR  TEMP EQ 6  THEN 
                  INT$VFUN = TEMP - 3;
              ELSE
                  INT$VFUN = TEMP;
              END 
          RETURN; 
  
  
 SMTYPOF:                    # SORT/MERGE - KEY TYPE                   #
#    RETURNS TYPE OF KEY (DIFFERS FOR SORT4 AND 5)  # 
          DNATINDEX = VIRTUAL(TABLETYPE"DNAT$", INT$VARG);
          TEMP1 = DN$TYPE[DNATINDEX]; 
          IF CCTSORT4 
          THEN
              BEGIN 
              TEMP = DN$SIGNBIT[DNATINDEX]; 
              INT$VFUN = 5; 
              IF TEMP1 EQ NUMERIC AND TEMP EQ 0 THEN
                  INT$VFUN = 0; 
              IF TEMP1 EQ BINARY THEN 
                  INT$VFUN = 1; 
              IF TEMP1 EQ SHORTFLOAT THEN 
                  INT$VFUN = 2; 
              RETURN; 
              END 
          TEMP = DN$SIGNGRP[DNATINDEX]; 
          IF TEMP1 LS LOWNUMOPERND OR TEMP1 GR HINUMOPERND
          THEN   # ITEM IS NOT NUMERIC #
              INT$VFUN = 0; 
          ELSE
              BEGIN   # NUMERIC - CHECK TYPE, SIGN, ETC. #
              IF TEMP1 EQ COMP1 OR TEMP1 EQ COMP4 
              THEN
                  BEGIN 
                  IF TEMP EQ 0
                  THEN  # NOT SIGNED #
                      C<0,10>INT$VFUN = "BINARY"; 
                  ELSE  # IS SIGNED # 
                      C<0,10>INT$VFUN = "INTEGER";
                  END 
              ELSE  # NOT COMP-1 OR COMP-4 #
                  BEGIN 
                  IF TEMP1 EQ NUMERIC 
                  THEN
                      BEGIN   # IS DISPLAY CODE NUMERIC # 
                      C<0,10>INT$VFUN = "NUMERIC_"; 
                      IF TEMP EQ 0
                      THEN   # NOT SIGNED # 
                          C<8,2>INT$VFUN = "NS";
                      ELSE
                          BEGIN  # IS SIGNED DISPLAY - SEE IF LEAD ETC# 
                          IF TEMP EQ 4 OR TEMP EQ 6 
                          THEN  #  NOT SEPARATE CHARACTER # 
                              C<9,1>INT$VFUN = "O"; 
                          ELSE  # IS SEPARATE CHAR #
                              C<9,1>INT$VFUN = "S"; 
                          IF TEMP EQ 6 OR TEMP EQ 7 
                          THEN  # IS LEADING #
                              C<8,1>INT$VFUN = "L"; 
                          ELSE  # IS TRAILING # 
                              C<8,1>INT$VFUN = "T"; 
                          END 
                      END 
                  ELSE  # NOT DISPLAY NUMERIC - MUST BE COMP2 # 
                      C<0,10>INT$VFUN = "REAL"; 
                  END 
              END 
          RETURN; 
  
  
 SMKCNTOF:                   # SORT/MERGE - NUMBER OF EKYS             #
          GETDNATINDEX; 
          INT$VFUN = DN$KEYCOUNT[DNATINDEX];
          RETURN; 
SPACESOF: 
          GETLATINDEX;
          INT$VFUN = L$SPACES[LATINDEX];
          RETURN; 
  
 STATICOF:  
          GETLATINDEX;
          TEMP = L$PLT[LATINDEX]; 
          TEMP1 = VIRTUAL(TABLETYPE"PLT$",TEMP);
          TEMP1 = PL$LENGTH[TEMP1]; 
          GETPLST(TEMP,LOC(NUMERICLIT));
          FOR TEMP2 =1  STEP 1 UNTIL CCTFDLTLEN DO
              BEGIN 
              TEMP = VIRTUAL(TABLETYPE"FDLT$",TEMP2); 
              IF  C<0,30>FDLTPROGNAME[TEMP] NQ C<0,TEMP1>NUMERICLIT 
              THEN  TEST; 
              IF  FDLTSTATICF[TEMP] 
              THEN
                  BEGIN 
                  INT$VFUN = TEMP2; 
                  RETURN; 
                  END 
              ELSE
                  BEGIN 
                  INT$VFUN = 0; 
                  RETURN; 
                  END 
              END 
          INT$VFUN = -1;
          RETURN; 
  
SUBLOCOF: 
          INT$VFUN = SUBLOC[INT$VARG];
          RETURN; 
  
  
 SUBLVLOF:  
          GETDNATINDEX; 
          INT$VFUN = DN$IDXDEP[DNATINDEX];
          RETURN; 
  
  
 SUBMSCOF:  
          GETDNATINDEX; 
          INT$VFUN = DN$SUBMSEC[DNATINDEX]; 
          RETURN; 
 SUBNUMOF:  
          INT$VFUN = SUBNUMBER[INT$VARG]; 
          RETURN; 
  
  
SUBOCCLN: 
          GETDNATINDEX ;
          VARGRPROC;     #DO COMMON VARIABLE GROUP PROCESS# 
          $BEGIN
          IF ABSAUXTINDEX EQ 0
          THEN
              BEGIN 
              CGABORT("SUBOCCOF1"); 
              RETURN; 
              END 
          $END
          INT$VFUN = AX$OCCLEN[AUXTINDEX];
          RETURN; 
 SUBOFFOF:  
          INT$VFUN = SUBOFFS[INT$VARG]; 
          RETURN; 
  
SUBSCOF:  
          INT$VFUN = REGSUBSC[INT$VARG];
          RETURN; 
  
  
SUBTYPOF: 
          INT$VFUN = SUBTYP[INT$VARG];
          RETURN; 
 SYNCHOF: 
          INT$VFUN = REGSYNC[INT$VARG]; 
          RETURN; 
  
  
TREGOF: 
TREGP1OF: 
TYPEOF: 
 #     COMPASS CODE IN EVALCFN  # 
          RETURN; 
  
  
  
VREFOF: 
          INT$VFUN = INT$VARG;
          RETURN; 
  
  
VREGOF: 
          INT$VFUN = NEXTR;            # CALL FUNCTION TO GET NEXT VRN #
          IF  INT$VFUN GQ 2000 THEN 
              BEGIN 
              CBLIST(1,"STATEMENT TOO LONG, PLEASE SIMPLIFY",35); 
              PRLINE [0] = "LINE =     "; 
              PRLINE [1] = DEC(FIXEDCELL[FIXED"CURRLINE"]); 
              CBLIST (1,PRINTL,20); 
              ABORT;
              END 
          FIXEDCELL[INT$ARG] = INT$VFUN;
          RETURN; 
  
  
VREGP1OF: 
 #     COMPASS CODE IN EVALCFN  # 
          RETURN; 
  
  
WRDOFFOF: 
          GETDNATINDEX; 
          INT$VFUN = DN$WORDOFF[DNATINDEX]; 
          RETURN; 
  
  
ZEROSOF:  
          GETLATINDEX;
          INT$VFUN = L$ZEROS[LATINDEX]; 
          RETURN; 
  
  
 DMRELOF:                    #CREATES -WORD1- OF RELATIONS/AREAS TABLE
                              IF FIXED REG T9 = 0 
                              CREATES -WORD1- OF RELATIONS/QUALIFIERS 
                              TABLE IF FIXED REG T9 = 1 
                              RETURNS FIXED REG T8 = PTR TO AUX CHAIN 
                              (OF DNAT PTRS TO AREAS OR QUALIFIERS)#
          CONTROL IFNQ CB5$CDCS,"NO"; 
          FNATINDEX = VIRTUAL(TABLETYPE"FNAT$", INT$VARG);
          IF FN$SSCHEMA[FNATINDEX] EQ 0 
           OR FN$SSRELATN[FNATINDEX] EQ 0 
           OR FN$ABORT[FNATINDEX] NQ 0 THEN 
          BEGIN 
              INT$VFUN=0; 
              RETURN; 
          END 
          TEMP = FIXEDCELL[FIXED"T9"];  #0 OR 1#
          IF TEMP EQ 0
          THEN               #RELATIONS/AREAS#
              AUXTINDEX = FN$SSRSTLST[FNATINDEX]; 
          ELSE               #RELATIONS/QUALIFIERS# 
              AUXTINDEX = FN$SSRQTLST[FNATINDEX]; 
          FIXEDCELL[FIXED"T8"] = AUXTINDEX; 
          FOR TEMP1 = TEMP1 WHILE AUXTINDEX NQ 0 DO 
          BEGIN              #COUNT NUMBER OF AUXT LINKS# 
              TEMP = TEMP + 1;
              AUXTINDEX = VIRTUAL(TABLETYPE"AUX$",
                                                AX$TNEXTPTR[AUXTINDEX]);
          END 
          INT$VFUN = FN$AREAORD[FNATINDEX];  #RELATION ORDINAL# 
          B<0,15>INT$VFUN = TEMP;  #NO. OF AREAS, OR NO. OF QUALS +1# 
          RETURN; 
          CONTROL FI; 
  
  
 DMRELOOF:                   #SS RELATION ORDINAL                      #
          CONTROL IFNQ CB5$CDCS,"NO"; 
          GETFNATINDEX; 
          IF FN$SSRELATN[FNATINDEX] EQ 0
          THEN
              INT$VFUN = 0; 
          ELSE
              INT$VFUN = FN$AREAORD[FNATINDEX]; 
          RETURN; 
          CONTROL FI; 
  
  
 DMIORDOF:                   #SS ITEM ORDINAL                          #
          CONTROL IFNQ CB5$CDCS,"NO"; 
          INT$VFUN = DN$SSORD [VIRTUAL(TABLETYPE"DNAT$",
              REGDNATADDR[INT$VARG])];
          RETURN; 
          CONTROL FI; 
CONTROL EJECT;
  
#         THE BELOW SECTIONS OF CODE ARE NOT NORMAL FUNCTIONS          #
#         THEY ARE PROCESSORS FOR THE *SETSYOF* FUNCTION.              #
  
  
 EXT$OF:  
          INT$VFUN = TEMP;
          B<34,8>INT$TABL = TABLETYPE"EXT$";
          B<42,18>INT$TABL = SETSY$ARG[0];
          RETURN; 
  
  
 FDLT$OF: 
          INT$VFUN = TEMP;
          B<34,8>INT$TABL = TABLETYPE"FDLT$"; 
          B<42,18>INT$TABL = FIXEDCELL[SETSY$ARG[0]]; 
          RETURN; 
  
 FWA$OF:  
          INT$VARG = FIXEDCELL[SETSY$ARG[0]]; 
          INT$VFUN = TEMP + REGWORDINDX[INT$VARG]; #FOR CONSTANT SUBSCR#
          GOTO FWA$OFL[REGGCODE[INT$VARG]]; 
  
 DFWA$OF: 
 LFWA$OF: 
 SFWA$OF: 
          B<30,4>INT$TABL = MODVALUES"FWA$";
          B<34,8>INT$TABL = TABLETYPE"DNAT$"; 
          B<42,18>INT$TABL = REGDNATADDR[INT$VARG]; 
          RETURN; 
  
 PFWA$OF: 
 VFWA$OF: 
 RFWA$OF: 
          IF  FIXEDCELL[FIXED"SEGPROG"] NQ 0
              AND  REGPNATADDR[INT$VARG] LQ CCTLSTGLPN
          THEN
              BEGIN 
              PNATINDEX=VIRTUAL(TABLETYPE"PNAT$",REGPNATADDR[INT$VARG]);
              TEMP1 = PN$SEGMENTNO [PNATINDEX] - CCTSEGLIMIT + 1; 
              IF TEMP1 LS 0 
              THEN
                  TEMP1 = 0;
              IF  TEMP1 NQ FIXEDCELL[FIXED"CUROVL"] 
              THEN
                  BEGIN 
                  FINDSEGENT;   #FIND SEGENTRYIX IN AUX TABLE#
                  IF ABSAUXTINDEX EQ 0
                  THEN    #THERE WAS NOT ONE# 
                      CGABORT("FWA$OF");
                  INT$VFUN = AX$ENTRYIX[AUXTINDEX]; 
                  B<30,4>INT$TABL = MODVALUES"FWA$";
                  B<34,8>INT$TABL = TABLETYPE"DNAT$"; 
                  B<42,18>INT$TABL = SGPTRDNATIX; 
                  RETURN; 
                  END 
              END 
          B<30,4>INT$TABL = MODVALUES"FWA$";
          B<34,8>INT$TABL = TABLETYPE"PNAT$"; 
          B<42,18>INT$TABL = REGPNATADDR[INT$VARG]; 
          RETURN; 
  
  
 FWASG$OF:  
          INT$VARG = FIXEDCELL[SETSY$ARG[0]]; 
          INT$VFUN = TEMP;
          $BEGIN
          IF REGGCODE[INT$VARG] NQ GLABLREF 
           AND REGGCODE[INT$VARG] NQ GPROCREF 
           AND REGGCODE[INT$VARG] NQ GVERB  THEN
              BEGIN 
              CGABORT("FWASG$OF");
              RETURN; 
              END 
          $END
          B<30,4>INT$TABL = MODVALUES"FWA$";
          B<34,8>INT$TABL = TABLETYPE"PNAT$"; 
          B<42,18>INT$TABL = REGPNATADDR[INT$VARG]; 
          RETURN; 
  
  
 LOCAL$OF:  
          INT$VFUN = TEMP;
          B<34,8>INT$TABL = TABLETYPE"LOCAL$";
          B<42,18>INT$TABL = FIXEDCELL[SETSY$ARG[0]]; 
          RETURN; 
  
  
 LWA$OF:  
          INT$VARG = FIXEDCELL[SETSY$ARG[0]]; 
          INT$VFUN = TEMP + REGWORDINDX[INT$VARG]; #FOR CONSTANT SUBSCR#
  
          $BEGIN
          TEMP = REGGCODE[INT$VARG];
          IF TEMP NQ GDATAREF  AND
             TEMP NQ GLITREF   AND
             TEMP NQ GPROCREF AND 
             TEMP NQ GSYSREF   THEN 
              BEGIN 
              CGABORT("CGENINT-5"); 
              RETURN; 
              END 
          $END
  
          B<30,4>INT$TABL = MODVALUES"LWA$";
          IF REGGCODE[INT$VARG] EQ GPROCREF  THEN 
              B<34,8>INT$TABL = TABLETYPE"PNAT$"; 
          ELSE
              B<34,8>INT$TABL = TABLETYPE"DNAT$"; 
          B<42,18>INT$TABL = REGDNATADDR[INT$VARG]; 
          RETURN; 
  
  
 SUBTMPOF:  
          INT$VFUN = TEMP;
          INT$VARG = FIXEDCELL[SETSY$ARG[0]]; 
          B<34,8>INT$TABL = TABLETYPE"SUBTEMP$";
          B<42,18>INT$TABL = SUBLOC[INT$VARG];
          RETURN; 
  
  
 UEXT$OF: 
          INT$VFUN = TEMP;
          INT$VARG = FIXEDCELL[SETSY$ARG[0]]; 
          B<34,8>INT$TABL = TABLETYPE"UEXT$"; 
          B<42,18>INT$TABL = L$PLT [VIRTUAL(TABLETYPE "LAT$", 
              REGLATADDR [INT$VARG])];
          RETURN; 
  
 USEORG$F:  
          INT$VFUN = TEMP;
          B<34,8>INT$TABL = TABLETYPE"USEORG$"; 
          B<42,18>INT$TABL= FIXEDCELL[SETSY$ARG[0]];
          RETURN; 
  
 USETB$OF:  
          INT$VFUN = TEMP;
          B<34,8>INT$TABL = TABLETYPE"USETAB$"; 
          B<42,18>INT$TABL = FIXEDCELL[SETSY$ARG[0]]; 
          RETURN; 
  
  
          END 
          TERM
