*DECK,DCCONV
      PROC DC$CONV(ERRCODE,SRCLASS,TGCLASS,SRLOC,TGLOC,SRBIT,TGBIT, 
                   SRBLENG,TGBLENG,SRJRIGHT,TGJRIGHT,SRDECPT,TGDECPT, 
                   SRXDEC,TGXDEC,SRSIGNED,TGSIGNED);
      BEGIN 
  
 #
  *   DC$CONV - CONVERSION ROUTINES FOR CDCS 1.0 PAGE 1 
* *   C C CHOW      6/13/74 
* 
* DC  PURPOSE 
*       PERFORM DATA CONVERSION FOR CDCS 1.0. 
* 
* DC  LANGUAGE
*       SYMPL 
* 
* DC  ENTRY CONDITIONS
*       PARAMETERS PASSED 
*         SRCLASS  = SOURCE DATA CLASS CODE.
*         TGCLASS  = TARGET DATA CLASS CODE.
*         SRLOC    = SOURCE LOCATION. 
*         TGLOC    = TARGET LOCATION. 
*         SRBIT    = SOURCE BEGINNING BIT POSITION. 
*         TGBIT    = TARGET BEGINNING BIT POSITION. 
*         SRBLENG  = SOURCE LENGTH IN BITS. 
*         TGBLENG  = TARGET LENGTH IN BITS. 
*         SRJRIGHT = SOURCE JUSTIFIED RIGHT IF SET. 
*         TGJRIGHT = TARGET JUSTIFIED RIGHT IF SET. 
*         SRDECPT  = SOURCE DECIMAL PT POSITION (LEFT OR RIGHT).
*                    POS - PT IS TO LEFT OF RIGHTMOST DIGIT.
*                    NEG - PT IS TO RIGHT OF RIGHTMOST DIGIT. 
*         TGDECPT  = TARGET DECIMAL PT POSITION.
*         SRXDEC   = SOURGE EXPLICITLY DECIMALED IF SET.
*         TGXDEC   = TARGET EXPLICITLY DECIMALED IF SET.
*         SRSIGNED = SOURCE IS SIGNED (OVERPUNCH FOR CURRENT RELEASE).
*         TGSIGNED = TARGET IS SIGNED.
*       SOURCE DATA IS CONTAINED IN LOCATION/POSITION SPECIFIED.
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         TARGET DATA STORED INTO LOCATION/POSITION SPECIFIED.
*         ERRCODE = 0.
*       ERROR:  
*         ERRCODE = CDCS ERROR CODE.
* 
* DC  CALLING ROUTINE 
*       CDCS RECORD MAPPER ROUTINES.
* 
* DC  CALLED ROUTINES 
*       CHECKALLZERO - CHECK ALL ZEROS. 
*       CHECKCLS3 - CHECK SOURCE CLASS 3. 
*       CHECKCLS4 - CHECK SOURCE CLASS 4. 
*       CHECKSRALPHA - CHECK SOURCE ALPHABETIC. 
*       CHECKSRNUM - CHECK SOURCE NUMERIC.
*       CMOVE - CHARACTER MOVE. 
*       DISPLAYTOBIN - DISPLAY TO BINARY CONVERSION.
*       DC$BTOF - BINARY TO FLOATING CONVERSION.
*       DC$FTOD - FLOATING TO DISPLAY CODE CONVERSION.
*       DC$FTOF - FLOATING TO FLOATING CONVERSION WITH SCALING. 
*       EXTRACTSOP - EXTRACT SIGN OVERPUNCH.
*       GETSRCHAR - GET SOURCE CHARACTER. 
*       IGNOREBLANKS - IGNORE BLANKS. 
*       MOVETOALNUM - MOVE TO ALPHANUMERIC TARGET FIELD.
*       PADBLANKS - PAD TARGET WITH BLANKS. 
*       ROUND - ROUND NUMERIC STRING. 
*       SGNTSRLENGTH - SIGNIFICANT SOURCE LENGTH. 
*       STORSOP - STORE SIGN OVERPUNCH. 
*       TG4INITIAL - TARGET CLASS 4 INITIALIZATION. 
*       UNORMFLOAT - UNNORMALIZE FLOATING PT NUMBER.
* 
* DC  DESCRIPTIONS
*       CDCS SUPPORTS 8 DATA CLASSES, EACH WITH A UNIQUE CLASS CODE 
*     FOR IDENTIFICATION. THEY ARE: 
*         0  - DISPLAY ALPHANUMERIC:  
*              ALPHANUMERIC CHARACTERS WITH DISPLAY CODE 00 - 77. 
*         1  - DISPLAY ALPHABETIC:  
*              ALPHABETIC CHARACTERS WITH DISPLAY CODE 01 - 32, AND 55. 
*         3  - DISPLAY NUMERIC(INTEGER):  
*              MAX 18 CHARS INTEGER NUMERIC STRING IN DISPLAY CODE
*              33 - 44. LAST (RIGHTMOST) DIGIT MAY BE SIGN-OVER-PUNCH.
*              NO EXPLICIT SIGN. NO LEADING BLANK.
*         4  - DISPLAY FIXED POINT: 
*              MAX 18 CHARS NUMERIC STRING IN DISPLAY CODE 33 - 44 WITH 
*              ONE DECIMAL PT (IMPLICIT OR EXPLICIT WITH DISPLAY CODE 
*              57). RIGHTMOST DIGIT (OR IF IT IS EXPLICIT DECIMAL PT, 
*              THE 2ND RIGHTMOST), MAY BE SIGN-OVER-PUNCH. NO EXPLICIT
*              SIGN. NO LEADING BLANK. LEADING OR TRAILING ZEROS COULD
*              BE IMPLIED BY SPECIFYING DECIMAL POSITION BEYOND STRING. 
*         10 - INTEGER: 
*              48 BIT BINARY INTEGER, RIGHT JUSTIFIED (COBOL 5 COMP-1)
*         12 - CODED UNNORMALIZED FLOATING POINT: 
*              FLOATING PT NUMBER IN A 60 BIT WORD WITH EXPONENT OF 
*              EITHER O"2000" (+VE) OR O"5777" (-VE). 
*         13 - CODED NORMALIZED FLOATING POINT: 
*              60 BIT NORMALIZED FLOATING PT NUMBER.
*         14 - CODED DOUBLE PRECISION:  
*              2 NORMALIZED FLOATING PT NUMBERS, WITH EXPONENT OF 2ND 
*              WORD O"60" LESS THAN THAT OF THE 1ST. IF EXPONENT OF 1ST 
*              IS LESS THAN O"60", EXPONENT OF 2ND WILL BE 0. 
* 
*       TYPES OF CONVERSIONS SUPPORTED IN CDCS 1.0 ARE: 
*     0 - 0   ALPHANUMERIC TO ALPHANUMERIC
*             IF SOURCE IS JUSTIFIED RIGHT, LEADING BLANKS ARE
*           INSIGNIFICANT, OTHERWISE TRAILING BLANKS ARE. SOURCE STRING 
*           IS MOVED DIRECTLY TO TARGET STRING. TRUNCATION OTHER THAN 
*           THAT OF INSIGNIFICANT BLANKS WILL CAUSE CONVERSION
*           TERMINATION WITH ERROR CODE 665.
*     0 - 1   ALPHANUMERIC TO ALPHABETIC
*             SAME AS 0 - 0, EXCEPT ANY NON-ALPHABETIC AND NON-BLANK
*           CHAR IN SOURCE WILL RESULT IN ERROR CODE 664. 
*     0 - 3   ALPHANUMERIC TO DISPLAY NUMERIC 
*             SOURCE FIELD EXPECTED TO BE IN FOLLOWING FORM:  
*               OPTIONAL LEADING BLANKS,
*               OPTIONAL SIGN (DISPLAY CODE + OR -),
*               OPTIONAL INTERVENING BLANKS (ONE CONTIGUOUS STRING, 
*                 BEFORE FIRST NUMERIC CHARACTER),
*               NUMERIC DISPLAY CODE CHARS (MAY HAVE 1 DECIMAL POINT. 
*                 LAST DIGIT MAY BE SIGN-OVER-PUNCH), 
*               OPTIONAL TRAILING BLANKS. 
*           ANY DEPARTURE FROM ABOVE WILL CAUSE CONVERSION TERMINATION
*           WITH ERROR CODE 664.
*             IF SOURCE CONTAINS DECIMAL PART, IT WILL BE ROUNDED TO
*           NEAREST INTEGER VALUE BEFORE MOVING TO TARGET. ANY
*           TRUNCATION (OTHER THAN LEADING ZEROS) TO THIS INTEGER PART
*           WILL CAUSE TERMINATION WITH ERROR CODE 666. 
*             TARGET WILL NOT CONTAIN EXPLICIT SIGN. IF IT IS TO BE 
*           SIGNED, IT WILL BE STORED WITH SIGN-OVER-PUNCH IN LAST
*           DIGIT. IF TARGET IS NOT TO BE SIGNED, SIGN WILL BE IGNORED. 
*     1 - 0   ALPHABETIC TO ALPHANUMERIC. 
*             LEADING AND TRAILING BLANKS ARE NON-SIGNIFICANT FOR 
*           JUSTIFIED RIGHT AND JUSTIFIED LEFT SOURCES RESPECTIVELY.
*           TRUNCATION OTHER THAN THAT OF NON-SIGNIFICANT BLANKS
*           CAUSES TERMINATION WITH ERROR CODE 665. 
*     1 - 1   ALPHABETIC TO ALPHABETIC. 
*             SAME AS 1 - 0.
*     3 - 1   NUMERIC TO ALPHANUMERIC.
*             DATA STRING IS MOVED DIRECTLY TO TARGET WITH BLANK- 
*           PADDING IF NECESSARY. IF TARGET LENGTH SMALLER THAN SOURCE
*           LENGTH, TRUNCATION OTHER THAN THAT OF LEADING ZEROS WILL
*           CAUSE TERMINATION WITH ERROR CODE 666.
*     3 - 3   DISPLAY NUMERIC TO DISPLAY NUMERIC. 
*             DATA STRING IS MOVED DIRECTLY TO TARGET WITH ZERO-PADDING 
*           IF NECESSARY. TRUNCATION OTHER THAN THAT OF LEADING ZEROS 
*           WILL CAUSE TERMINATION WITH ERROR CODE 666. IF SOURCE IS
*           SIGNED AND TARGET IS NOT, SOURCE SIGN WILL BE IGNORED.
*     3 - 4   DISPLAY NUMERIC TO DISPLAY FIXED POINT. 
*             DIGITS TO RIGHT OF DECIMAL PT IN TARGET ARE FILLED WITH 
*           DISPLAY CODE ZERO. DATA STRING IS MOVED RIGHT JUSTIFIED TO
*           THE LEFT OF TARGET DECIMAL PT WITH ZERO-PADDING IF
*           NECESSARY. TRUNCATION OTHER THAN THAT OF LEADING-ZEROS WILL 
*           CAUSE TERMINATION WITH ERROR CODE 666. IF TARGET IS SIGNED, 
*           IT WILL HAVE SIGN-OVER-PUNCH IN RIGHTMOST DIGIT. IF 
*           UNSIGNED, SOURCE SIGN WILL BE IGNORED.
*     3 - 10  DISPLAY NUMERIC TO BINARY INTEGER.
*             SOURCE DATA STRING IS CONVERTED INTO BINARY INTEGER, WHICH
*           IS SCALED AND CONVERTED INTO TARGET CLASS.  IF SCALED DATA
*           STRING GREATER THAN 48 BITS, TERMINATE WITH ERROR CODE 666. 
*           IF SOURCE IS NEG, TARGET IS COMPLIMENTED. 
*     3 - 12  DISPLAY NUMERIC TO CODED UNNORMALIZED.
*             SOURCE DATA STRING IS CONVERTED INTO BINARY INTEGER, WHICH
*           IS SCALED AND CONVERTED INTO TARGET CLASS PACKED WITH 
*           EXPONENT O"2000". IF SCALED DATA STRING GREATER THAN 48 
*           BITS, TERMINATION WITH ERROR CODE 666. IF SOURCE IS NEG,
*           TARGET IS COMPLIMENTED. 
*     3 - 13  DISPLAY NUMERIC TO CODED NORMALIZED.
*             SOURCE DATA IS CONVERTED TO BINARY, AND THEN TO FLOATING
*           NORMALIZED, COMPLEMENTED IF NEG. LOSS OF SIGNIFICANCE 
*           DURING CONVERSION WILL CAUSE TERMINATION WITH ERROR CODE
*           666.
*     3 - 14  DISPLAY NUMERIC TO DOUBLE PRECISION.
*             SOURCE DATA IS CONVERTED TO BINARY, AND THEN TO DOUBLE
*           PRECISION (WITH SCALING) IN 2 NORMALIZED FLOATING PT NUMBERS
*           COMPLEMENTED IF NEG.  LOSS OF SIGNIFICANCE WILL CAUSE 
*           TERMINATION WITH ERROR CODE 666.
*     4 - 3   DISPLAY FIXED POINT TO DISPLAY NUMERIC. 
*             INTEGER PART OF SOURCE IS MOVED RIGHT JUSTIFIED ZERO- 
*           FILLED TO TARGET, ROUNDING ON LEAST SIGNIFICANT DIGIT 
*           ACCORDING TO DECIMAL PART OF SOURCE, AND SUPPLYING SIGN-
*           OVER-PUNCH IF SPECIFIED. TRUNCATION OF INTEGER PART OF DATA 
*           WILL CAUSE TERMINATION WITH ERROR CODE 666. 
*     4 - 4   DISPLAY FIXED POINT TO DISPLAY FIXED POINT. 
*             DATA IS MOVED JUSTIFIED ON DECIMAL PT POSITION, DISPLAY 
*           CODE ZERO FILLING BOTH ENDS, ROUNDING ON LEAST SIGNIFICANT
*           DIGIT IF NECESSARY, AND SUPPLYING SIGN-OVER-PUNCH IF
*           SPECIFIED. TRUNCATION OF INTEGER PART OF DATA WILL CAUSE
*           TERMINATION WITH ERROR CODE 666.
*     4 - 10  DISPLAY FIXED POINT TO BINARY INTEGER.
*             SOURCE DATA IS CONVERTED TO BINARY INTEGER.  A SCALING
*           FACTOR IS DERIVED FROM SOURCE AND TARGET DECIMAL POSITION.
*           RESULT IS COMPLEMENTED IF SOURCE IS NEG.  IF SCALED BINARY
*           STRING GREATER THAN 48 BITS, TERMINATE WITH ERROR CODE 666. 
*     4 - 12  DISPLAY FIXED POINT TO CODED UNNORMALIZED FLOATING. 
*             SOURCE DATA IS CONVERTED TO BINARY INTEGER. A SCALING 
*           FACTOR IS DERIVED FROM SOURCE AND TARGET DECIMAL POSITION.
*           RESULT IS PACKED WITH EXPONENT O"2000", AND COMPLIMENTED
*           IF NEG. IF SCALED BINARY STRING GREATER THAN 48 BITS, 
*           TERMINATION WITH ERROR CODE 666.
*     4 - 13  DISPLAY FIXED PT TO CODED NORMALIZED FLOATING.
*             SOURCE DATA IS CONVERTED TO BINARY INTEGER, AND THEN
*           TO NORMALIZED FLOATING PT, COMPLEMENTED IF NEG.  LOSS OF
*           SIGNIFICANCE WILL CAUSE TERMINATION WITH ERROR CODE 666.
*     4 - 14  DISPLAY FIXED PT TO DOUBLE PRECISION. 
*             SOURCE DATA IS CONVERTED TO BINARY INTEGER, AND THEN TO 
*           DOUBLE PRECISION (SCALED) IN 2 NORM FLOATING PT NUMBERS,
*           COMPLEMENTED IF NEG.  LOSS OF SIGNIFICANCE WILL CAUSE 
*           TERMINATION WITH ERROR CODE 666.
*     10 - 3  BINARY INTEGER TO DISPLAY NUMERIC.
*             SAME AS 12 - 3. 
*     10 - 4  BINARY INTEGER TO DISPLAY FIXED POINT.
*             SAME AS 12 - 4. 
*     10 - 10 BINARY INTEGER TO BINARY INTEGER. 
*             BASED ON SOURCE AND TARGET DECIMAL POSITIONS, DATA
*           IS RESCALED AND MOVED INTO TARGET.
*     10 - 12 BINARY INTEGER TO CODED UNNORM FLOATING PT. 
*             BASED ON SOURCE AND TARGET DECIMAL POSITIONS, DATA IS 
*           RESCALED AND PACKED BEFORE MOVING INTO TARGET.
*     10 - 13 BINARY INTEGER TO CODED NORM FLOATING PT. 
*             SAME AS 12 - 13.
*     10 - 14 BINARY INTEGER TO DOUBLE PRECISION. 
*             SAME AS 12 - 14.
*     12 - 3  CODED FLOATING UNNORM TO DISPLAY NUMERIC. 
*             SOURCE IS CONVERTED TO CHAR NUMERIC DISPLAY CODE WITH 
*           INTEGER AND DECIMAL PARTS. ONLY THE ROUNDED INTEGER PART
*           WILL BE MOVED TO TARGET, DISPLAY CODE ZERO FILLING ON LEFT
*           IF NECESSARY. SIGN-OVER-PUNCH SUPPLIED IF SPECIFIED. IF 
*           TARGET FIELD NOT LARGE ENOUGH FOR THIS INTEGER PART,
*           TERMINATION WITH ERROR 666. 
*     12 - 4  CODED FLOATING UNNORM TO DISPLAY FIXED POINT. 
*             SOURCE IS CONVERTED TO CHAR NUMERIC DISPLAY CODE
*           CHARACTERS WITH INTEGER AND DECIMAL PARTS, AND THEN MOVED TO
*           TARGET JUSTIFIED ON DECIMAL POSITION, DISPLAY CODE ZERO 
*           FILLING BOTH ENDS, ROUNDING ON LEAST SIGNIFICANT DIGIT IF 
*           NECESSARY, AND SUPPLYING SIGN-OVER-PUNCH IF SPECIFIED.
*           TRUNCATION OF ANY INTEGER PART DIGIT WILL CAUSE TERMINATION 
*           WITH ERROR CODE 666.
*     12 - 10 CODED UNNORM FLOATING TO BINARY INTEGER.
*             BASED ON SOURCE AND TARGET DECIMAL POSITIONS, DATA IS 
*           RESCALED AND THE O"2000" BIAS IS REMOVED. 
*     12 - 12 CODED UNNORM FLOATING TO CODED UNNORM FLOATING. 
*             BASED ON SOURCE AND TARGET DECIMAL POSITIONS, DATA IS 
*           RESCALED AND REPACKED BEFORE MOVING INTO TARGET.
*     12 - 13 CODED UNNORM FLOATING TO CODED NORM FLOATING. 
*             DATA IS RESCALED WITH SOURCE SCALING FACTOR, AND CONVERTED
*           TO NORMALIZED FORM. 
*     12 - 14 CODED UNNORM FLOATING TO DOUBLE PRECISION.
*             DATA IS RESCALED WITH SCALING FACTOR AND CONVERTED INTO 
*           DOUBLE PRECISION. 
*     13 - 3  CODED NORMALIZED FLOATING TO DISPLAY NUMERIC. 
*             SAME AS 12 - 3. 
*     13 - 4  CODED NORMALIZED FLOATING TO DISPLAY FIXED PT.
*             SAME AS 12 - 4. 
*     13 - 10 CODED NORM FLOATING TO BINARY INTEGER.
*             SOURCE DATA IS SCALED ACCORDING TO TARGET DECIMAL 
*           POSITION.  IF LOSS OF SIGNIFICANCE, TERMINATE WITH ERROR
*           666.
*     13 - 12 CODED NORM FLOATING TO CODED UNNORM FLOATING. 
*             SOURCE DATA IS SCALED ACCORDING TO TARGET DECIMAL 
*           POSITION, AND PACKED WITH EXPONENT O"2000". COMPLIMENT IF 
*           NEG.  IF LOSS OF SIGNIFICANCE, TERMINATION WITH ERROR 666.
*     13 - 13 CODED NORM FLOATING TO CODED NORM FLOATING. 
*             NO CONVERSION NEEDED. 
*     13 - 14 CODED NORM FLOATING TO DOUBLE PRECISION.
*             SOURCE DATA IS SCALED ACCORDING TO TARGET DECIMAL 
*           POSITION AND CONVERTED INTO DOUBLE PRECISION. 
*     14 - 3  DOUBLE PRECISION TO DISPLAY NUMERIC.
*             SAME AS 12 - 3. 
*     14 - 4  DOUBLE PRECISION TO DISPLAY FIXED POINT.
*             SAME AS 12 - 4. 
*     14 - 10 DOUBLE PRECISION TO BINARY INTEGER. 
*             DATA IS RESCALED AND CONVERTED TO A BINARY INTEGER. 
*     14 - 12 DOUBLE PRECISION TO CODED UNNORM FLOATING.
*             SAME AS 12 - 12.
*     14 - 13 DOUBLE PRECISION TO CODED NORM FLOATING.
*             SAME AS 12 - 13.
*     14 - 14 DOUBLE PRECISION TO DOUBLE PRECISION. 
*             SOURCE DATA IS RESCALED BASED ON SCALING FACTOR AND 
*           MOVED INTO TARGET.
* 
*       P R O G R A M   S T R U C T U R E : 
*       BASED ON SOURCE CLASS, A SWITCH "SOURCECLASS" WILL SEND CONTROL 
*     TO APPROPRIATE SECTION FOR INITIAL SETTINGS. THEY ARE LABELLED: 
*         SRALPHANUM - CLASS 0, 
*         SRALPHABET - CLASS 1, 
*         SRDNUMERIC - CLASS 3, 
*         SRDFIXEDPT - CLASS 4, 
*         SRINTGR    - CLASS 10,
*         SRUNNORM   - CLASS 12,
*         SRNORM     - CLASS 13,
*         SRDOUBLE   - CLASS 14.
*       THEN FROM EACH OF THESE SECTIONS (EXCEPT SRALPHABET), A SECOND
*     SWITCH WILL, BASED ON TARGET CLASS, SEND CONTROL TO APPROPRIATE 
*     SECTION FOR DESIRED CONVERSION PROCEDURE. THEY ARE LABELLED:  
*         ALNUMTOALNUM  0 - 0,
*         ALNUMTOALPHA  0 - 1,
*         ALNUMTODNUM   0 - 3,
*         DNUMTOALNUM   3 - 0,
*         DNUMTODNUM    3 - 3,
*         DNUMTODFXPT   3 - 4,
*         DNUMTOINT     3 - 10, 
*         DNUMTOUNORM   3 - 12, 
*         DNUMTONORM    3 - 13, 
*         DNUMTODOUBL   3 - 14, 
*         DFXPTTODNUM   4 - 3,
*         DFXPTTODFXPT  4 - 4,
*         DFXPTTOINT    4 - 10, 
*         DFXPTTOUNORM  4 - 12, 
*         DFXPTTONORM   4 - 13, 
*         DFXPTTODOUBL  4 - 14, 
*         INTTODNUM     10 - 3, 
*         INTTODFXPT    10 - 4, 
*         INTTOINT      10 - 10,
*         INTTOUNORM    10 - 12,
*         INTTONORM     10 - 13,
*         INTTODOUBL    10 - 14,
*         UNORMTODNUM   12 - 3, 
*         UNORMTODFXPT  12 - 4, 
*         UNORMTOINT    12 - 10,
*         UNORMTOUNORM  12 - 12,
*         UNORMTONORM   12 - 13,
*         UNORMTODOUBL  12 - 14,
*         NORMTODNUM    13 - 3, 
*         NORMTODFXPT   13 - 4, 
*         NORMTOINT     13 - 10,
*         NORMTOUNORM   13 - 12,
*         NORMTONORM    13 - 13,
*         NORMTODOUBL   13 - 14,
*         DOUBLTODNUM   14 - 3, 
*         DOUBLTODFXPT  14 - 4, 
*         DOUBLTOINT    14 - 10,
*         DOUBLTOUNORM  14 - 12,
*         DOUBLTONORM   14 - 13,
*         DOUBLTODOUBL  14 - 14.
*       EACH OF THESE SECTIONS WILL BE DESCRIBED IN DETAIL LATER. 
* 
*       IN CASES WHERE THE SPECIFIED CONVERSION IS NOT SUPPORTED, THE 
*     SWITCHES WILL SEND CONTROL TO LABEL "NONSUPPORT", WHERE ERROR 
*     EXIT WILL BE TAKEN WITH CODE 663. 
* 
*       ONE OTHER LABEL OF SIGNIFICANCE IN THE PROCEDURE IS "CONV$EXIT".
*     IT IS JUMPED TO FROM VARIOUS EMBEDDED PROCS. WHENEVER AN EMBEDDED 
*     PROC DETECTS AN ERROR DURING CONVERSION, "ERRCODE" WILL BE SET
*     AND CONTROL WILL JUMP OUT OF THE EMBEDDED PROC TO "CONV$EXIT" TO
*     RETURN TO CALLING PROGRAM.
* 
*       THE CONVERSION ROUTINE UTILIZES AN INTERNAL BUFFER "INTERBUF" 
*     OF SIZE 20 CHARS. IN CASES WHERE ROUNDING OR SIGNING OR ZERO- 
*     FILLING MAY NEED TO BE DONE BEFORE MOVING TO TARGET, THE DATA 
*     IS MOVED INTO "INTERBUF" FIRST (LENGTH MOVED IS TARGET LENGTH + 1,
*     OR RIGHT JUSTIFED TO IT IF DATA STRING IS NOT AS LONG). "INTERBUF"
*     WOULD HAVE ALREADY BEEN ZERO-FILLED. THEN ROUNDING WILL BE DONE 
*     IF NECESSARY, AND SIGN-OVER-PUNCH EXTRACTED OR ADDED IF REQD. THE 
*     DATA STRING WILL THEN BE MOVED FROM "INTERBUF" TO TARGET. AN ITEM 
*     "LOCINTERBUF" WILL BE SET TO ABS LOC OF "INTERBUF" FOR USE BY 
*     OUR PROGRAM.
* 
*       EVERY TIME "DC$CONV" IS CALLED, IT BEGINS BY STORING SOME 
*     PARAMETERS INTO LOCAL ITEMS FOR EASE OF REFERENCE AND 
*     MODIFICATION. THE LOCAL ITEMS ARE "SCURLOC", "SCURBYTE",
*     "SCURLENG", "SRDECPOS", "SRXPLICD", "TCURLOC", "TCURBYTE",
*     "TCURLENG", "TGDECPOS", AND "TGXPLICD". THUS IN CASE SOME OF
*     THESE REFERENCED PARAMETERS ARE NOT GIVEN IN CALLING SEQUENCE,
*     AN ARITHMETIC MODE ERROR MAY OCCUR. IN OTHER WORDS, ALL PARAMETERS
*     UP TO AND INCLUDING "TGXDEC" MUST BE SPECIFIED. 
* 
*       "INTERBUF" IS ZERO-FILLED EVERY TIME, EVEN THOUGH IT MAY NOT BE 
*     USED IN SOME PARTICULAR CONVERSIONS.
 #
  
  
      ITEM ERRCODE,          #RETURN ERROR CODE.                       #
           SRCLASS,          #SOURCE DATA CLASS.  REQD BY ALL CLASSES. #
           TGCLASS,          #TARGET DATA CLASS.  REQD BY ALL CLASSES. #
           SRLOC,            #SOURCE LOCATION.  REQD BY ALL CLASSES.   #
           TGLOC,            #TARGET LOCATION.                         #
           SRBIT,            #SOURCE BEGINNING BIT POSITION. 0-59.     #
                             #REQD BY ALL CLASSES.                     #
           TGBIT,            #TARGET BEGINNING BIT POSITION. 0-59.     #
           SRBLENG,          #SOURCE LENGTH IN BITS.  REQD BY ALL.     #
           TGBLENG,          #TARGET LENGTH IN BITS.                   #
           SRJRIGHT B,       #TRUE - SOURCE IS JUSTIFIED RIGHT.        #
                             #REQD BY ALL.                             #
           TGJRIGHT B,       #TARGET JUSTIFIED RIGHT.                  #
           SRDECPT,          #SOURCE DECIMAL POINT POSITION.
                              POS - PT IS TO LEFT OF RIGHTMOST DIGIT. 
                              NEG - PT IS TO RIGHT OF RIGHTMOST DIGIT. #
                             #REQD BY  4,12.                           #
           TGDECPT,          #TARGET DECIMAL POINT POSITION.           #
           SRXDEC B,         #TRUE - SOURCE IS EXPLICITLY DECIMALED.   #
                             #REQD BY  4.                              #
           TGXDEC B,         #TARGET EXPLICITLY DECIMALED.             #
           SRSIGNED B,       #SOURCE IS SIGNED.  REQD BY  3,4.         #
           TGSIGNED B;       #TARGET IS SIGNED.                        #
  
      DEF CALL # #; 
      DEF XCALL # #;
      DEF THRU #STEP 1 UNTIL#;
  
      COMMON DC$CMBF;        #COMMON FOR BINARY TO FLOATING CONVER.    #
        BEGIN 
        ITEM UPINT;          #UPPER 54 BITS OF 108 BIT INTEGER.        #
        ITEM LOWINT;         #LOWER 54 BITS OF 108 BIT INTEGER.        #
        ITEM EXPONEN;        #SCALING FACTOR.  POWER OF 10.            #
        ITEM SIGN;           #SIGN.  0 FOR POS, COMPLEMENT OF 0 FOR NEG#
        ITEM FLAGDBL B;      #TRUE - DOUBLE PRECISION DESIRED.         #
        ITEM SINGLE R;       #SINGLE PRECISION RESULT.                 #
        ITEM DOUBLE R;       #DOUBLE PRECISION RESULT. (LOWER HALF).   #
        ITEM RETURNC;        #RETURN CODE.                             #
        END 
  
      COMMON DC$CMFD;        #COMMON TO FLOATING TO DISPLAY CONVERSION.#
        BEGIN 
        ITEM ADDRSR;         #SOURCE LOCATION TO PASS TO "DC$FTOD".    #
        ITEM DBLFGSR B;      #TRUE - SOURCE IS DOUBLE PRECISION.       #
        ARRAY DISPCTG[1];    #CONTAINS 20 CHAR RESULT OF DC$FTOD CONV. #
          ITEM IDCTG U(0,0,60); 
        ITEM DECPTTG;        #DEC POSITION RELATIVE TO LEFTMOST CHAR
                              IN "DISPCTG". POS TO THE RIGHT, NEG LEFT.#
        ITEM SGNPLTG B;      #TRUE - SIGN IS POS.                      #
        ITEM CRETURN;        #RETURN CODE.  0 - NORMAL RETURN.         #
        END 
  
      SWITCH SOURCECLASS SRALPHANUM,   #CLASS 0 - ALPHANUMERIC.        #
                         SRALPHABET,   #CLASS 1 - ALPHABETIC.          #
                         NONSUPPORT,
                         SRDNUMERIC,   #CLASS 3 - DISPLAY NUMERIC.     #
                         SRDFIXEDPT,   #CLASS 4 - DISPLAY FIXED POINT. #
                         NONSUPPORT,
                         NONSUPPORT,
                         NONSUPPORT,
                         NONSUPPORT,
                         NONSUPPORT,
                         SRINTGR,      #CLASS 10 - BINARY INTEGER      #
                         NONSUPPORT,
                         SRUNNORM,     #CLASS 12 - UNNORMALIZED.       #
                         SRNORM,       #CLASS 13 - NORMALIZED.         #
                         SRDOUBLE;     #CLASS 14 - DOUBLE PRECISION.   #
  
      SWITCH SOURCECLS0 ALNUMTOALNUM,  #SWITCH FOR CLASS 0 SOURCE.     #
                        ALNUMTOALPHA, 
                        NONSUPPORT, 
                        ALNUMTODNUM,
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT; 
  
      SWITCH SOURCECLS3 DNUMTOALNUM,   #SWITCH FOR SOURCE CLASS 3.     #
                        NONSUPPORT, 
                        NONSUPPORT, 
                        DNUMTODNUM, 
                        DNUMTODFXPT,
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        DNUMTOINT,
                        NONSUPPORT, 
                        DNUMTOUNORM,
                        DNUMTONORM, 
                        DNUMTODOUBL;
  
      SWITCH SOURCECLS4 NONSUPPORT,    #SWITCH FOR SOURCE CLASS 4.     #
                        NONSUPPORT, 
                        NONSUPPORT, 
                        DFXPTTODNUM,
                        DFXPTTODFXPT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        DFXPTTOINT, 
                        NONSUPPORT, 
                        DFXPTTOUNORM, 
                        DFXPTTONORM,
                        DFXPTTODOUBL; 
  
      SWITCH SOURCECLS10 NONSUPPORT,   #SWITCH FOR SOURCE CLASS 10     #
                        NONSUPPORT, 
                        NONSUPPORT, 
                        INTTODNUM,
                        INTTODFXPT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        NONSUPPORT, 
                        INTTOINT, 
                        NONSUPPORT, 
                        INTTOUNORM, 
                        INTTONORM,
                        INTTODOUBL; 
  
      SWITCH SOURCECLS12 NONSUPPORT,   #SWITCH FOR SOURCE CLASS 12.    #
                         NONSUPPORT,
                         NONSUPPORT,
                         UNORMTODNUM, 
                         UNORMTODFXPT,
                         NONSUPPORT,
                         NONSUPPORT,
                         NONSUPPORT,
                         NONSUPPORT,
                         NONSUPPORT,
                         UNORMTOINT,
                         NONSUPPORT,
                         UNORMTOUNORM,
                         UNORMTONORM, 
                         UNORMTODOUBL;
  
      SWITCH SOURCECLS13 NONSUPPORT,   #SWITCH FOR SOURCE CLASS 13.    #
                         NONSUPPORT,
                         NONSUPPORT,
                         NORMTODNUM,
                         NORMTODFXPT, 
                         NONSUPPORT,
                         NONSUPPORT,
                         NONSUPPORT,
                         NONSUPPORT,
                         NONSUPPORT,
                         NORMTOINT, 
                         NONSUPPORT,
                         NORMTOUNORM, 
                         NORMTONORM,
                         NORMTODOUBL; 
  
      SWITCH SOURCECLS14 NONSUPPORT,   #SWITCH FOR SOURCE CLASS 14.    #
                         NONSUPPORT,
                         NONSUPPORT,
                         DOUBLTODNUM, 
                         DOUBLTODFXPT,
                         NONSUPPORT,
                         NONSUPPORT,
                         NONSUPPORT,
                         NONSUPPORT,
                         NONSUPPORT,
                         DOUBLTOINT,
                         NONSUPPORT,
                         DOUBLTOUNORM,
                         DOUBLTONORM, 
                         DOUBLTODOUBL;
  
  
      XREF PROC DC$BTOF;     #COMPASS ROUTINE FOR CONVERTING 108 BIT
                              BINARY TO FLOATING PT NUMBER.            #
      XREF PROC DC$FTOD;     #COMPASS ROUTINE FOR CONVERSION FROM 
                              FLOATING PT TO DISPLAY CODE.             #
      XREF PROC DC$FTOF;     #COMPASS ROUTINE TO CONVERT FLOATING PT TO 
                              FLOATING PT, EITHER SINGLE OR DOUBLE, 
                              NORMALIZED OR UNNORMALIZED.              #
  
      BASED ARRAY SRFIELD;             #SOURCE FIELD.                  #
        BEGIN 
        ITEM SRCHAR C(0,0,10);         #SOURCE IN 10-CHAR STRING.      #
        ITEM SRINTEGER I(0,0,60);      #SOURCE IN INTEGER.             #
        ITEM SRREAL R(0,0,60);         #SOURCE IN REAL.                #
        END 
      BASED ARRAY TGFIELD;             #TARGET FIELD.                  #
        BEGIN 
        ITEM TGCHAR C(0,0,10);
        ITEM TGINTEGER I(0,0,60); 
        ITEM TGREAL R(0,0,60);
        END 
  
      ITEM SCURLOC,          #SIGNIGICANT SOURCE LOCATION.             #
           SCURBYTE,         #SIGNIFICANT SOURCE STARTING BYTE.        #
           SCURLENG,         #SIGNIFICANT SOURCE LENGTH IN 6-BIT BYTE. #
           SRDECPOS,         #SOURCE DECIMAL POSITION.                 #
           SRXPLICD B,       #TRUE - SOURCE EXPLICITLY DECIMALED.      #
           TCURLOC,            #CORRESPONDING TARGET FIELDS.           #
           TCURBYTE,
           TCURLENG,
           TGDECPOS,
           TGXPLICD B;
  
      ITEM I;                #SCRATCH VARIABLE.                        #
      ITEM J;                #SCRATCH VARIABLE.                        #
      ITEM K;                #SCRATCH VARIABLE.                        #
      ITEM L;                #SCRATCH VARIABLE.                        #
      ITEM TEMP;             #TEMP STOR FOR CL 10 AND 12 SOURCE        #
      ITEM RI R;             #REAL SCRATCH VARIABLE.                   #
      ITEM RJ R;             #REAL SCRATCH ITEM.                       #
  
      ITEM ASSUMELEFT;       #COUNT OF ASSUMED LEFT ZEROS. FOR CLASS 4.#
      ITEM ASSUMERIGHT;      #COUNT OF ASSUMED RIGHT ZEROS. CLASS 4.   #
      ITEM CHAR;             #CURRENT CHARACTER IN SOURCE STRING.      #
      ITEM DECDIGITS;        #COUNT OF DECIMAL DIGITS IN CURRENT
                              NUMERIC STRING.                          #
      ITEM DECIMALED B;      #TRUE - CURRENT NUMERIC STRING HAS DECIMAL 
                                     POINT.                            #
      ITEM GETBYTE;          #BYTE IN "SRFIELD" TO BE ACCESSED.        #
      ITEM INTERBUF C(20);   #INTERMEDIATE BUFFER FOR MOVING SOURCE TO
                              TARGET, WHERE EDITING WILL BE DONE.      #
      ITEM LEADZEROS;        #COUNT OF LEADING ZEROS IN CURRENT NUMERIC 
                              STRING.                                  #
      ITEM LENGDIFF;        #LENGTH DIFFERENCE. USED IN VARIOUS PLACES.#
      ITEM LOCINTERBUF;      #LOC OF ARRAY "INTERBUF".                 #
      ITEM SGNTDIGITS;       #COUNT OF SIGNIFICANT DIGITS IN CURRENT
                              NUMERIC STRING (INTEGER PART EXCLUDING
                                LEADING ZEROS).                        #
      ITEM SGNTLENG;         #LENGTH OF CURRENT NUMERIC STRING EXCLUDING
                              LEADING ZEROS (SGNTDIGITS+DECDIGITS+1). 
                              USED WHEN CHECKING CLASS 0 SOURCE.       #
      ITEM SIGNED B;         #TRUE - CURRENT NUMERIC STRING IS SIGNED. #
      ITEM SIGNPLUS B;         #TRUE - CURRENT NUM STRING IS POS.      #
                               #FALSE- CURRENT NUM STRING IS NEG.      #
      ITEM TASMLEFT;         #TARGET ASSUMED LEFT ZERO COUNT.          #
      ITEM TASMRIGHT;        #TARGET ASSUMED RIGHT ZERO COUNT.         #
      ITEM TDECLEN;          #COUNT OF DECIMAL DIGITS IN TARGET, NOT
                              INCLUDING IMPLIED LEFT ZEROS.            #
      ITEM TSGNTLEN;         #COUNT OF SIGNIFICANT DIGITS IN TARGET,
                              NOT INCLUDING IMPLIED RIGHT ZEROS.       #
      CONTROL EJECT;
  
      ERRCODE=0;
  
      IF SRCLASS GR 14 OR TGCLASS GR 14 THEN     #TRUE - DATA CLASS 
                                                         NOT SUPPORTED.#
        GOTO NONSUPPORT;
  
      SCURLOC=SRLOC;
      SCURBYTE=SRBIT/6; 
      SCURLENG=SRBLENG/6; 
      SRDECPOS=SRDECPT; 
      SRXPLICD=SRXDEC;
      TCURLOC=TGLOC;
      TCURBYTE=TGBIT/6; 
      TCURLENG=TGBLENG/6; 
      TGDECPOS=TGDECPT; 
      TGXPLICD=TGXDEC;
  
      LOCINTERBUF=LOC(INTERBUF);      #SET "LOCINTERBUF" FOR LATER USE.#
  
      INTERBUF="00000000000000000000";  # ZERO FILL INTERBUFF.         #
  
      GOTO SOURCECLASS[SRCLASS];       #BRANCH TO APPROPRIATE SOURCE
                                        CLASS.                         #
      CONTROL EJECT;
  
SRALPHANUM:                  #SOURCE ALPHA-NUMERIC CLASS 0.            #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   SRALPHANUM - SOURCE ALPHANUMERIC CLASS 0
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       VALIDATE AND REDUCE TO STANDARD FORMAT CLASS 0 SOURCE DATA, 
*     AND BRANCH ACCORDING TO TARGET DATA CLASS.
* 
* DC  ENTRY CONDITIONS
*       SCURLOC  = SOURCE LOCATION. 
*       SCURBYTE = SOURCE BEGINNING BYTE POSITION.
*       SCURLENT = SOURCE LENGTH IN BYTES.
*       SRJRIGHT = TRUE IF SOURCE IS JUSTIFIED RIGHT. 
*       TGCLASS  = TARGET DATA CLASS. 
* 
* DC  EXIT CONDITIONS 
*       "SCURLOC","SCURBYTE","SCURLENG" UPDATED TO EXCLUDE LEADING
*     BLANKS IF JUSTIFIED RIGHT, OR TRAILING BLANKS IF NOT. 
*       SOURCE STRING VALIDATED TO BE NUMERIC IF TARGET IS TO BE SO.
* 
* DC  CALLED ROUTINES 
*       IGNOREBLANKS - TO UPDATE "SCURLOC","SCURBYTE","SCURLENG" TO 
*                      EXCLUDE LEADING BLANKS.
*       SGNTSRLENGTH - TO UPDATE "SCURLOC","SCURBYTE","SCURLENG" TO 
*                      EXCLUDE TRAILING BLANKS. 
*       CHECKSRNUM - CHECK IF SOURCE IS LEGAL NUMERIC STRING. 
* 
* DC  DESCRIPTIONS
*       IF "TGCLASS" IS 0 OR 1, CALL "IGNOREBLANKS" TO IGNORE LEADING 
*     BLANKS IF SOURCE JUSTIFIED RIGHT, OR CALL "SGNTSRLENGTH" TO 
*     IGNORE TRAILING BLANKS IF LEFT JUSTIFIED. 
*       IF "TGCLASS" IS GREATER THAN 1, TARGET IS NUMERIC, CALL 
*     "IGNOREBLANKS" TO IGNORE LEADING BLANKS. CALL "CHECKSRNUM" TO 
*     VALIDATE SOURCE TO BE NUMERIC.
*       BRANCH ACCORDING TO TARGET CLASS. 
 #
  
  
      IF TGCLASS LQ 1 THEN
        BEGIN 
        IF SRJRIGHT THEN     #YES - SOURCE STRING IS JUSTIFIED RIGHT.  #
          CALL IGNOREBLANKS(SCURLOC,SCURBYTE,SCURLENG); 
                             #IGNORE LEADING BLANKS.                   #
        ELSE
          CALL SGNTSRLENGTH; #IGNORE TRAILING BLANKS.                  #
        END 
      ELSE
        BEGIN 
        CALL IGNOREBLANKS(SCURLOC,SCURBYTE,SCURLENG); 
        CALL CHECKSRNUM;     #CHECK IF SOURCE IS LEGAL NUMERIC STRING. #
        END 
  
      GOTO SOURCECLS0[TGCLASS]; 
      CONTROL EJECT;
  
SRALPHABET:                  #SOURCE IS ALPHABETIC.                    #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   SRALPHABET - SOURCE ALPHABETIC CLASS 1
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       VALIDATE AND REDUCE TO STANDARD FORMAT CLASS 1 SOURCE DATA, 
*     AND BRANCH TO PERFORM REQD CONVERSION.
* 
* DC  ENTRY CONDITIONS
*       SCURLOC  = SOURCE LOCATION. 
*       SCURBYTE = SOURCE BEGINNING BYTE POSITION.
*       SCURLENG = SOURCE LENGTH IN BYTES.
*       SRJRIGHT = TRUE IF SOURCE IS JUSTIFIED RIGHT. 
*       TGCLASS  = TARGET DATA CLASS. 
* 
* DC  EXIT CONDITIONS 
*       "SCURLOC","SCURBYTE","SCURLENG" UPDATED TO EXCLUDE LEADING
*     BLANKS IF JUSTIFIED RIGHT, OR TRAILING BLANKS IF NOT. 
* 
* DC  CALLED ROUTINES 
*       IGNOREBLANKS - TO EXCLUDE SOURCE LEADING BLANKS.
*       SGNTSRLENGTH - TO EXCLUDE SOURCE TRAILING BLANKS. 
* 
* DC  DESCRIPTIONS
*       IF "TGCLASS" GR 1, CONVERSION IS NOT SUPPORTED, EXIT. 
*       UPDATE SOURCE DESCRIPTION BY EXCLUDING LEADING BLANKS IF
*     RIGHT JUSTIFIED, OR TRAILING BLANKS IF NOT. 
*       BRANCH TO MODULE FOR CLASS 0-1 CONVERSION.
 #
  
  
      IF TGCLASS GR 1 THEN   #TRUE - CONVERSION NOT SUPPORTED.         #
        GOTO NONSUPPORT;
      IF SRJRIGHT THEN
        CALL IGNOREBLANKS(SCURLOC,SCURBYTE,SCURLENG); 
      ELSE
        CALL SGNTSRLENGTH;
  
      GOTO ALNUMTOALPHA;     #FROM THIS POINT ON, PROCEDURE IS THE SAME 
                              AS CONVERTING FROM ALPHANUMERIC TO
                              ALPHABETIC.                              #
      CONTROL EJECT;
  
SRDNUMERIC:                  #SOURCE DISPLAY-NUMERIC CLASS 3.          #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   SRDNUMERIC - SOURCE DISPLAY NUMERIC CLASS 3 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       VALIDATE CLASS 3 SOURCE DATA AND BRANCH ACCORDING TO TARGET 
*     DATA CLASS. 
* 
* DC  ENTRY CONDITIONS
*       SCURLOC  = SOURCE LOCATION. 
*       SCURBYTE = SOURCE BEGINNING BYTE POSITION.
*       SCURLENG = SOURCE LENGTH IN BYTES.
*       TGCLASS  = TARGET DATA CLASS. 
* 
* DC  EXIT CONDITIONS 
*       DECDIGITS  = NUMBER OF DECIMAL DIGITS. SET TO 0.
*       SGNTDIGITS = NUMBER OF SIGNIFICANT DIGITS IN SOURCE DATA. 
*       LEADZEROS  = NUMBER OF LEADING ZEROS IN SOURCE DATA.
*       SIGNPLUS   = TRUE IF SOURCE DATA IS POS.
* 
* DC  CALLED ROUTINES 
*       CHECKCLS3 - CHECK SOURCE CLASS 3. 
* 
* DC  DESCRIPTIONS
*       CALL "CHECKCLS3" TO VERIFY THAT SOURCE DATA IS LEGAL CLASS 3
*             AND SET LEADZEROS.
*       SET "SGNTDIGITS" TO INDICATE NUMBER OF SIGNIFICANT DIGITS OTHER 
*     THAN LEADING ZEROS. 
*       SET "DECDIGITS" TO 0. 
*       BRANCH ACCORDING TO TARGET CLASS. 
 #
  
  
      CALL CHECKCLS3;        #CHECK IF SOURCE IS LEGAL CLASS 3.        #
                                       #AND SET LEADZEROS.             #
      SGNTDIGITS=SCURLENG-LEADZEROS;   #SIGNIFICANT DIGITS COUNT.      #
      DECDIGITS=0;                     #DECIMAL DIGITS COUNT.          #
  
      GOTO SOURCECLS3[TGCLASS]; 
      CONTROL EJECT;
  
SRDFIXEDPT:                  #SOURCE DISPLAY FIXED POINT. CLASS 4.     #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   SRFIXEDPT - SOURCE DISPLAY FIXED PT CLASS 4 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       VALIDATE CLASS 4 SOURCE DATA, AND BRANCH
*     ACCORDING TO TARGET CLASS.
* 
* DC  ENTRY CONDITIONS
*       SCURLOC  = SOURCE LOCATION. 
*       SCURBYTE = SOURCE BEGINNING BYTE POSITION.
*       SCURLENG = SOURCE LENGTH IN BYTES.
*       SRDECPOS = SOURCE DECIMAL PT POSITION.
*       SRXPLICD = TRUE IF SOURCE IS EXPLICITLY DECIMALED.
* 
* DC  EXIT CONDITIONS 
*       SIGNPLUS  = TRUE IF SOURCE IS POS.
*       LEADZEROS = NUMBER OF LEADING ZEROS IN SOURCE. INCLUDES ONLY
*                   EXPLICIT LEADING ZEROS OF INTEGER PART. 
*       ASSUMELEFT  = NUMBER OF ASSUMED LEFT ZEROS TO DECIMAL PT. 
*       ASSUMERIGHT = NUMBER OF ASSUMED RIGHT ZEROS.
*       SGNTDIGITS = NUMBER OF SIGNIFICANT DIGITS IN EXPLICIT INTEGER 
*                    PART OF SOURCE.
*       DECDIGITS  = NUMBER OF DECIMAL DIGITS IN EXPLICIT DECIMAL PART
*                    OF SOURCE. 
* 
* DC  DESCRIPTIONS
*       CALL "CHECKCLS4" TO VERIFY THAT SOURCE IS LEGAL CLASS 4 
*             AND SET LEADZEROS.
*       SET "ASSUMERIGHT", "ASSUMELEFT", "SGNTDIGITS", AND "DECDIGITS". 
*       BRANCH ACCORDING TO TARGET CLASS. 
 #
  
  
      CALL CHECKCLS4;        #CHECK IF SOURCE IS LEGAL CLASS 4.        #
                             #AND SET LEADZEROS.                       #
  
SRDFXPT1:                    #THIS LABEL IS ENTERED WHEN CONVERTING 
                              FROM FLOATING PT TO CLASSES 3 OR 4.  THE
                              FLOATING PT HAS BEEN CONVERTED TO DISPLAY 
                              CODE, AND IS TREATED AS DISPLAY FIXED PT
                              SOURCE FROM THIS POINT ON.               #
  
      ASSUMERIGHT=0;
      ASSUMELEFT=0; 
      IF SRDECPOS LS 0 THEN 
        BEGIN 
        SGNTDIGITS=SCURLENG-LEADZEROS;
        ASSUMERIGHT=-SRDECPOS;
        DECDIGITS=0;
        END 
      ELSE
        BEGIN 
        IF SRDECPOS GR SCURLENG THEN
          BEGIN 
          SGNTDIGITS=0; 
          DECDIGITS=SCURLENG; 
          ASSUMELEFT=SRDECPOS-SCURLENG; 
          END 
        ELSE
          BEGIN 
          DECDIGITS=SRDECPOS; 
          IF SRXPLICD THEN
            SGNTDIGITS=SCURLENG-LEADZEROS-DECDIGITS-1;
          ELSE
            SGNTDIGITS=SCURLENG-LEADZEROS-DECDIGITS;
          END 
        END 
  
      GOTO SOURCECLS4[TGCLASS]; 
      CONTROL EJECT;
  
SRINTGR:                     #SOURCE BINARY INTEGER. CLASS 10.         #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   SRINTGR - SOURCE BINARY INTEGER CLASS 10
* *   P R PINARD   12/15/75 
* 
* DC  PURPOSE 
*       VALIDATE CLASS 10 SOURCE DATA AND BRANCH ACCORDING TO TARGET
*     CLASS.
* 
* DC  ENTRY CONDITIONS
*       SCURLOC = SOURCE LOCATION.
*       TGCLASS = TARGET DATA CLASS.
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SOURCE DATA VERIFIED TO BE CLASS 10.
*       ERROR:  
*         ERRCODE = O"664". 
* 
* DC  DESCRIPTIONS
*       VERIFY THAT SOURCE IS LEGAL CLASS 10 BY CHECKING IF LEFTMOST
*     12 BITS IS EITHER O"0000" OR O"7777".  IF NOT, ERROR EXIT WITH
*     ERROR CODE 664.  OTHERWISE, CHANGE INTEGER TO CLASS 12
*     UNNORM BY ADDING A BIAS (O"2000") AND BRANCH ACCORDING TO 
*     TARGET CLASS. 
*     NOTE - CLASS 10 AND CLASS 12 USE THE SAME CONVERSION ROUTINES 
*     SINCE THE ONLY DIFFERENCE BETWEEN THEM IS THE O"2000" BIAS. 
 #
  
      P<SRFIELD>=SCURLOC; 
      TEMP = SRINTEGER[0];   #STORE SOURCE IN TEMP CELL                #
      SCURLOC = LOC(TEMP);
      P<SRFIELD>= SCURLOC;
  
# CHECK IF SOURCE IS LEGAL CLASS 12 OR CLASS 10                        #
      IF B<0,12>SRINTEGER[0] EQ O"0000" OR
      B<0,12>SRINTEGER[0] EQ O"2000"
        THEN B<0,12>SRINTEGER[0] = O"2000"; 
      ELSE
        IF B<0,12>SRINTEGER[0] EQ O"7777" OR
        B<0,12>SRINTEGER[0] EQ O"5777" THEN 
          B<0,12>SRINTEGER[0] = O"5777";
        ELSE
          BEGIN 
          ERRCODE = O"664"; 
          RETURN; 
          END 
  
      GOTO SOURCECLS10[TGCLASS];
      CONTROL EJECT;
  
SRUNNORM:                    #SOURCE UNNORMALIZED. CLASS 12.           #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   SRUNNORM - SOURCE UNNORMALIZED FLOATING CLASS 12
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       VALIDATE CLASS 12 SOURCE DATA AND BRANCH ACCORDING TO TARGET
*     CLASS.
* 
* DC  ENTRY CONDITONS 
*       SCURLOC = SOURCE LOCATION.
*       TGCLASS = TARGET DATA CLASS.
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SOURCE DATA VERIFIED TO BE CLASS 12.
*       ERROR:  
*         ERRCODE = O"664". 
* 
* DC  DESCRIPTIONS
*       VERIFY THAT SOURCE IS LEGAL CLASS 12 BY CHECKING IF LEFTMOST
*     12 BITS IS EITHER O"2000" OR O"5777". IF NOT, ERROR EXIT WITH 
*     ERROR CODE 664. 
*       BRANCH ACCORDING TO TARGET CLASS. 
 #
  
      P<SRFIELD>= SCURLOC;
      TEMP = SRINTEGER[0];   #STORE SOURCE IN TEMP CELL                #
      SCURLOC = LOC(TEMP);
      P<SRFIELD>= SCURLOC;
  
# CHECK IF SOURCE IS LEGAL CLASS 12 OR CLASS 10                        #
      IF B<0,12>SRINTEGER[0] EQ O"0000" OR
      B<0,12>SRINTEGER[0] EQ O"2000"
        THEN B<0,12>SRINTEGER[0] = O"2000"; 
      ELSE
        IF B<0,12>SRINTEGER[0] EQ O"7777" OR
        B<0,12>SRINTEGER[0] EQ O"5777" THEN 
          B<0,12>SRINTEGER[0] = O"5777";
        ELSE
        BEGIN 
        ERRCODE = O"664";    #ILLEGAL SOURCE                           #
        RETURN; 
        END 
  
      GOTO SOURCECLS12[TGCLASS];
      CONTROL EJECT;
  
SRNORM:                      #SOURCE NORMALIZED. CLASS 13.             #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   SRNORM - SOURCE NORMALIZED FLOATING CLASS 13
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       BRANCH ACCORDING TO TARGET CLASS FOR REQD CONVERSION. 
* 
* DC  ENTRY CONDITIONS
*       SCURLOC = SOURCE LOCATION.
*       TGCLASS = TARGET DATA CLASS.
* 
* DC  DESCRIPTIONS
*       BRANCH ACCORDING TO TARGET DATA CLASS.
 #
  
  
      P<SRFIELD>=SCURLOC; 
      GOTO SOURCECLS13[TGCLASS];
      CONTROL EJECT;
  
SRDOUBLE:                    #SOURCE DOUBLE PRECISION. CLASS 14.       #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   SRDOUBLE - SOURCE DOUBLE PRECISION CLASS 14 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       BRANCH ACCORDING TO DATA CLASS FOR REQD CONVERSION. 
* 
* DC  ENTRY CONDITIONS
*       SCURLOC = SOURCE LOCATION.
*       TGCLASS = TARGET DATA CLASS.
* 
* DC  DESCRIPTIONS
*       BRANCH ACCORDING TO TARGET DATA CLASS.
 #
  
  
      P<SRFIELD>=SCURLOC; 
      GOTO SOURCECLS14[TGCLASS];
      CONTROL EJECT;
  
ALNUMTOALNUM:                #ALPHANUMERIC TO ALPHANUMERIC.            #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   ALNUMTOALNUM - CONVERSION 0 - 0 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM ALPHANUMERIC TO ALPHANUMERIC. 
* 
* DC  ENTRY CONDITIONS
*       SCURLOC  = SOURCE LOCATION. 
*       SCURBYTE = SOURCE BEGINNING BYTE POSITION.
*       SCURLENG = SOURCE LENGTH IN BYTES.
*       TCURLOC  = TARGET LOCATION. 
*       TCURBYTE = TARGET BEGINNING BYTE POSITION.
*       TCURLENG = TARGET LENGTH IN BYTES.
*       TGJRIGHT = TRUE IF TARGET TO BE JUSTIFIED RIGHT.
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SOURCE DATA STRING MOVED TO TARGET. 
*       ERROR:  
*         ERRCODE = O"665". 
* 
* DC  NON-LOCAL VARIABLES 
*       LENGDIFF - TARGET/SOURCE LENGTH DIFFERENCE. 
* 
* DC  CALLED ROUTINES 
*       MOVETOALNUM - PERFORM DATA MOVE TO ALPHANUMERIC TARGET. 
* 
* DC  DESCRIPTIONS
*       CHECK IF TARGET SIZE LARGE ENOUGH TO HOLD SOURCE DATA. IF NOT,
*     ERROR EXIT WITH ERROR CODE 665. 
*       CALL "MOVETOALNUM" TO MOVE DATA TO TARGET.
 #
  
  
      LENGDIFF=TCURLENG-SCURLENG;      #TARGET/SOURCE LENGTH DIFF.     #
      IF LENGDIFF LS 0 THEN 
        ERRCODE=O"665";      #NON-BLANK TRUNCATED.                     #
      ELSE
        CALL MOVETOALNUM;    #MOVE TO ALPHANUMERIC TARGET.             #
      RETURN; 
      CONTROL EJECT;
  
ALNUMTOALPHA:                #ALPHANUMERIC TO ALPHABETIC.              #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   ALNUMTOALPHA - CONVERSION 0 - 1 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM ALPHANUMERIC TO ALPHABETIC. 
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG CONTAINS SOURCE DATA STRING WITH NO 
*     NON-SIGNIFICANT BLANK.
* 
* DC  EXIT CONDITIONS 
*       SOURCE DATA VALIDATED TO CONTAIN ONLY ALPHABETIC CHARS. 
* 
* DC  CALLED ROUTINES 
*       CHECKSRALPHA - CHECK SOURCE IS ALPHABETIC.
* 
* DC  DESCRIPTIONS
*       CALL "CHECKSRALPHA" TO VALIDATE THAT SOURCE CONTAINS ONLY 
*     ALPHABETIC CHARS. 
*       REMAINING PROCEDURE IDENTICAL TO 0 - 0 CONVERSION.
 #
  
  
      CALL CHECKSRALPHA;     #CHECK IF SOURCE IS LEGAL ALPHABETIC.     #
      GOTO ALNUMTOALNUM;     #FROM THIS POINT ON, THE SAME PROCEDURE
                              AS THAT FOR ALNUMTOALNUM IS CARRIED OUT. #
      CONTROL EJECT;
  
ALNUMTODNUM:                 #ALPHANUMERIC TO DISPLAY NUMERIC.         #
  
DNUMTODNUM:                  #DISPLAY NUMERIC TO DISPLAY NUMERIC.      #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   ALNUMTODNUM - CONVERSION 0 - 3
* *   DNUMTODNUM  - CONVERSION 3 - 3
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM ALPHANUMERIC/DISPLAY-NUMERIC TO 
*     DISPLAY NUMERIC.
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG CONTAINS SOURCE DATA. 
*       LEADZEROS = COUNT OF LEADING ZEROS IN SOURCE INTEGER PART.
*       SGNTDIGITS = COUNT OF SIGNIFICANT DIGITS IN SOURCE. 
*       DECDIGITS = COUNT OF DECIMAL DIGITS IN SOURCE.
*       SIGNPLUS = TRUE IF SOURCE DATA POS. 
*       TCURLOC = TARGET LOCATION.
*       TCURBYTE = TARGET BEGINNING BYTE POSITION.
*       TCURLENG = TARGET LENGTH IN BYTES.
*       LOCINTERBUF = ABS LOC OF DC$CONV INTERNAL BUFFER "INTERBUF".
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SOURCE DATA STRING CONVERTED TO TARGET AS REQD. 
*       ERROR:  
*         ERRCODE = O"666". 
* 
* DC  CALLED ROUTINES 
*       CMOVE      - CHARACTER MOVE.
*       EXTRACTSOP - EXTRACT SIGN OVERPUNCH.
*       ROUND      - ROUND NUMERIC STRING.
*       STORESOP   - STORE SIGN OVERPUNCH.
* 
* DC  DESCRIPTIONS
*       CHECK IF TARGET SIZE LARGE ENOUGH TO HOLD SIGNIFICANT PART OF 
*     SOURCE. IF NOT, ERROR EXIT WITH CODE 666. 
*       MOVE SIGNIFICANT PART OF SOURCE DATA INTO "INTERBUF" RIGHT
*     JUSTIFIED TO TARGET LENGTH AND ZERO-FILLING ON LEFT.
*       IF SOURCE DATA HAS DECIMAL PART, MOVE MOST SIGNIFICANT DECIMAL
*     DIGIT INTO "INTERBUF" RIGHT AFTER THE SIGNIFICANT PART. 
*       CALL "EXTRACTSOP", "ROUND", AND "STORESOP" TO EXTRACT S-O-P,
*     ROUND DATA, AND STORE S-O-P, IF NECESSARY.
*       MOVE DATA STRING FROM "INTERBUF" TO TARGET. 
 #
  
  
      IF TCURLENG LS SGNTDIGITS THEN
        BEGIN 
        ERRCODE=O"666";      #LOSS OF DIGIT OF SIGNIFICANCE.           #
        RETURN; 
        END 
  
      CALL CMOVE(SCURLOC,SCURBYTE+LEADZEROS,SGNTDIGITS,LOCINTERBUF, 
                 TCURLENG-SGNTDIGITS); #MOVE SIGNIFICANT PART FROM
                                        SOURCE INTO "INTERBUF".        #
      IF DECDIGITS EQ 0 THEN           #YES - NO DECIMAL DIGITS.       #
        CALL EXTRACTSOP(TCURLENG-1);   #EXTRACT SOP AT IT"S ONE 
                                        PROBABLE POSITION.             #
      ELSE
        BEGIN 
        CALL CMOVE(SCURLOC,SCURBYTE+SCURLENG-DECDIGITS,1,LOCINTERBUF, 
                   TCURLENG);          #GET MOST SIGNIFICANT DEC DIGIT.#
        CALL EXTRACTSOP(TCURLENG);     #THIS DIGIT COULD BE LAST DIGIT
                                        IN STRING AND THUS MAY BE SOP. #
        CALL ROUND(TCURLENG);          #ROUND OF THIS LAST DIGIT.      #
        END 
  
      CALL STORESOP(TCURLENG-1);       #STORE SOP, IF NEEDED.          #
      CALL CMOVE(LOCINTERBUF,0,TCURLENG,TCURLOC,TCURBYTE);
                                       #MOVE FROM "INTERBUF" TO TARGET.#
      RETURN; 
      CONTROL EJECT;
  
DNUMTOALNUM:                 #DISPLAY NUMERIC TO ALPHANUMERIC          #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   DNUMTOALNUM - CONVERSION 3 - 0
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM DISPLAY NUMERIC TO ALPHANUMERIC.
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG CONTAINS SOURCE DATA. 
*       TCURLOC = TARGET LOCATION.
*       TCURBYTE = TARGET BEGINNING BYTE POSITION.
*       TCURLENG = TARGET LENGTH IN BYTES.
*       TGJRIGHT = TRUE IF TARGET JUSTIFIED RIGHT.
*       LEADZEROS = COUNT OF LEADING ZEROS IN SOURCE. 
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SOURCE DATA CONVERTED AND MOVED TO TARGET.
*       ERROR:  
*         ERRCODE = O"666". 
* 
* DC  CALLED ROUTINES 
*       CMOVE       - CHARACTER MOVE
* 
* DC  NON-LOCAL VARIABLES 
*       LENGDIFF - LENGTH BY WHICH TARGET GREATER THAN SOURCE.
* 
* DC  DESCRIPTIONS
*       CHECK IF TARGET SIZE GREATER THAN OR EQUAL TO SOURCE SIZE.
*         IF YES, CALL "MOVETOALNUM" TO TRANSFER DATA TO TARGET.
*         IF NO, CONTINUE.
*       CHECK IF TARGET SIZE LARGE ENOUGH FOR WOURCE SIGNIFICANT PART.
*         IF YES, MOVE DATA TO TARGET TRUNCATING LEADING ZEROS IF REQD. 
*         IF NO, ERROR EXIT WITH CODE 666.
 #
  
  
      LENGDIFF=TCURLENG-SCURLENG; 
      IF LENGDIFF LS 0 THEN  #YES - SOURCE LONGER THAN TARGET.         #
        BEGIN 
        IF (-LENGDIFF) LQ LEADZEROS THEN #YES-NO LOSS IN SIGNIFICANCE. #
          CALL CMOVE(SCURLOC,SCURBYTE-LENGDIFF,TCURLENG,TCURLOC,
                     TCURBYTE);        #MOVE FROM SOURCE TO TARGET.    #
        ELSE
          ERRCODE=O"666";    #LOSS IN SIGNIFICANCE.                    #
        END 
      ELSE
        CALL MOVETOALNUM;    #MOVE TO ALPHANUMERIC TARGET.             #
      RETURN; 
      CONTROL EJECT;
  
DNUMTODFXPT:                 #DISPLAY NUMERIC TO DISPLAY FIXED POINT.  #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   DNUMTODFXPT - CONVERSION 3 - 4
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM DISPLAY NUMERIC TO DISPLAY FIXED PT.
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG CONTAINS SOURCE DATA. 
*       SIGNPLUS = TRUE IF SOURCE POS.
*       LEADZEROS = COUNT OF LEADING ZEROS IN SOURCE. 
*       SGNTDIGITS = COUNT OF SIGNIFICANT DIGITS IN SOURCE. 
*       DECDIGITS = COUNT OF DECIMAL DIGITS IN SOURCE. SET TO 0.
*       TCURLOC/TCURBYTE/TCURLENG/TGXPLICD/TGDECPOS/TGSIGNED INDICATE 
*     TARGET LOCATION AND FORMAT. 
* 
* DC  EXIT CONDITIONS 
*       ASSUMELEFT  = COUNT OF SOURCE ASSUMED LEFT ZEROS SET TO 0.
*       ASSUMERIGHT = COUNT OF SOURCE ASSUMED RIGHT ZEROS SET TO 0. 
* 
* DC  DESCRIPTIONS
*       PROCEDURE FOR CONVERSION 3-4 IS A SUBSET OF CONVERSION 4-4, 
*     WHEN SOURCE IS IMPLICITLY DECIMALED WITH DECIMAL POSITION 0.
*     THUS "ASSUMERIGHT" AND "ASSUMELEFT" WILL BE SET TO 0 TO INDICATE
*     THIS FACT, AND WILL BRANCH TO 4-4 CONVERSION MODULE.
 #
  
  
# PROCEDURE IS SAME AS CONVERTING FROM DISPLAY FIXED PT TO DISPLAY
  FIXED PT WITH 0 .LQ. SRDECPOS .LQ. SCURLENG.                         #
      ASSUMERIGHT=0;         #IMPLIES  0 .LQ. SRDECPOS.                #
      ASSUMELEFT=0;          #IMPLIES  SRDECPOS .LQ. SCURLENG.         #
      GOTO DFXPTTODFXPT;     #PERFORM PROCEDURE FOR DFXPT-DFXPT.       #
      CONTROL EJECT;
  
DNUMTOINT:                   #DISPLAY NUMERIC TO BINARY INTEGER        #
DNUMTOUNORM:                 #DISPLAY NUMERIC TO UNNORMALIZED.         #
DFXPTTOINT:                  #DISPLAY FIXED PT. TO BINARY INTEGER      #
DFXPTTOUNORM:                #DISPLAY FIXED PT TO UNNORMALIZED.        #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   DNUMTOINT - CONVERSION 3 - 10 
  *   DNUMTOUNORM - CONVERSION 3 - 12 
  *   DFXPTTOINT - CONVERSION 4 - 10
* *   DFXPTTOUNORM - CONVERSION 4 - 12
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM DISPLAY NUMERIC (CLASS 3) OR DISPLAY
*     FIXED PT (CLASS 4) TO UNNORMALIZED FLOATING (CLASS 12) OR 
*     BINARY INTEGER (CLASS 10).
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG GIVES LOCATION OF SOURCE DATA.
*       SRDECPOS/SRXPLICD GIVE DECIMAL PT INFO OF CLASS 4 SOURCE. 
*       TCURLOC/TGDECPOS GIVE LOCATION AND FORMAT OF TARGET.
*       LEADZEROS = COUNT OF LEADING ZEROS IN SOURCE. 
*       SIGNPLUS = TRUE IF SOURCE POS.
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SOURCE DATA CONVERTED AND MOVED TO TARGET 
*       ERROR:  
*         OVERFLOW - ERRCODE SET TO 666.
*         DC$BTOF DETECTED - ERRCODE SET TO THAT RETURNED BY DC$BTOF. 
* 
* DC  NON-LOCAL VARIABLES 
*       DC$CMBF 
*         EXPONEN - PARAMETER FOR "DC$BTOF". SCALING FACTOR.
*         FLAGDBL - PARAMETER FOR "DC$BTOF". DOUBLE PRECISION FLAG. 
*         SINGLE  - SINGLE PRECISION RESULT OF "DC$BTOF". 
*         RETURNC - RETURN CODE FORM "DC$BTOF". 0 - NORMAL. 
*       RI - REAL SCRATCH VARIABLE. 
*       I  - INTEGER SCRATCH VARIABLE.
*       BASED ARRAY "TGFIELD".
* 
* DC  CALLED ROUTINES 
*       DISPLAYTOBIN - DISPLAY TO BINARY CONVERSION.
*       DC$BTOF - BINARY TO FLOATING CONVERSION.
* 
* DC  DESCRIPTIONS
*       CALL "DISPLAYTOBIN" TO CONVERT SOURCE DISPLAY CODE TO BINARY
*     INTEGER.
*       WITH SCALING FACTOR SET IN "EXPONEN" BASED ON SOURCE AND TARGET 
*     DECIMAL POSITION, CALL "DC$BTOF" TO CONVERT BINARY INTEGER INTO 
*     NORMALIZED FLOATING PT. THE INTEGER PART OF THIS NORMALIZED 
*     FLOATING PT REPRESENTS THE VALUE OF THE MANTISSA OF THE DESIRED 
*     UNNORMALIZED FLOATING PT. 
*       CHECK IF THIS VALUE COULD BE FIT IN 48 BITS AS THE MANTISSA. IF 
*     NOT, ERROR EXIT WITH CODE 666.
*       CONVERT THE NORMALIZED FLOATING PT TO BINARY INTEGER, AND PACK
*     IT WITH EXPONENT O"2000" IF TARGET CLASS IS CLASS 12. 
*       MOVE TO TARGET. COMPLEMENT IF NEG.
 #
  
  
      CALL DISPLAYTOBIN;     #CONVERT SOURCE INTO 108 BIT BINARY.      #
      EXPONEN=TGDECPOS+EXPONEN;        #SET SCALING FACTOR.            #
      FLAGDBL=FALSE;         #SET FLAG TO INDICATE SINGLE PRECISION.   #
      CALL DC$BTOF;          #CONVERT BINARY TO FLOATING PT NUMBER.    #
      IF RETURNC NQ 0 THEN   #YES - DC$BTOF DETECTS ERROR.             #
        BEGIN 
        ERRCODE=RETURNC;
        RETURN; 
        END 
      RI=ABS(SINGLE)+0.5;    #ROUNDING. RI IS SCRATCH VARIABLE.        #
      IF RI GR O"00007777777777777777" THEN      #CHECK FOR OVERFLOW.  #
        BEGIN 
        ERRCODE=O"666"; 
        RETURN; 
        END 
      P<TGFIELD>=TCURLOC; 
      TGINTEGER[0] = RI;               #CONVERT TO INTEGER             #
      IF TGCLASS EQ 12 THEN            #PACK WITH O"2000" EXP.         #
        TGINTEGER[0] = O"20000000000000000000"+TGINTEGER[0];
      IF SINGLE LS 0. THEN             #YES - NEGATIVE VALUE.          #
        TGINTEGER[0] = -TGINTEGER[0]; 
      RETURN; 
      CONTROL EJECT;
  
DNUMTONORM:                  #DISPLAY NUMERIC TO NORMALIZED.           #
  
DFXPTTONORM:                 #DISPLAY FIXED PT TO NORMALEZED.          #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   DNUMTONORM - CONVERSION 3 - 13
* *   DFXPTTONORM - CONVERSION 4 - 13 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM DISPLAY NUMERIC (CLASS 3) OR DISPLAY
*     FIXED PT (CLASS 4) TO NORMALIZED FLOATING PT (CLASS 13).
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG GIVE LOCATION OF SOURCE DATA. 
*       SRDECPOS/SRXPLICD GIVE DEC PT INFO OF CLASS 4 SOURCE. 
*       TCURLOC = LOCATION OF TARGET. 
*       LEADZEROS = COUNT OF LEADING ZEROS IN SOURCE. 
*       SIGNPLUS = TRUE IF SOURCE POS.
* 
* DC  EXIT CONDITIONS 
*       NORMAL - SOURCE DATA CONVERTED TO NORMALIZED FLOATING FORM AND
*     MOVED TO TARGET.
*       ERROR - ERRCODE SET TO THAT RETURNED BY DC$BTOF.
* 
* DC  NON-LOCAL VARIABLES 
*       DC$CMBF 
*         FLAGDBL - DOUBLE PRECISION FLAG.
*         SINGLE  - SINGLE PRECISION RESULT.
*         RETURNC - RETURN CODE FROM "DC$BTOF". 0 - NORMAL. 
*       BASED ARRAY "TGFIELD".
* 
* DC  CALLED ROUTINES 
*       DISPLAYTOBIN - DISPLAY TO BINARY CONVERSION.
*       DC$BTOF - BINARY TO FLOATING CONVERSION.
* 
* DC  DESCRIPTIONS
*       CALL "DISPLAYTOBIN" TO CONVERT SOURCE DISPLAY CODE TO BINARY
*     INTEGER.
*       CALL "DC$BTOF" TO CONVERT THE BINARY INTEGER TO NORMALIZED
*     FLOATING PT, AND MOVE IT TO TARGET. IF "DC$BTOF" RETURNS ERROR, 
*     ERROR EXIT. 
 #
  
  
      CALL DISPLAYTOBIN;     #CONVERT SOURCE INTO 108 BIT BINARY.      #
      FLAGDBL=FALSE;
      CALL DC$BTOF;          #CONVERT BINARY TO FLOATING.              #
      IF RETURNC NQ 0 THEN   #YES - DC$BTOF DETECTS ERROR.             #
        BEGIN 
        ERRCODE=RETURNC;
        RETURN; 
        END 
      P<TGFIELD>=TCURLOC; 
      TGREAL[0]=SINGLE; 
      RETURN; 
      CONTROL EJECT;
  
DNUMTODOUBL:                 #DISPLAY NUMERIC TO DOUBLE PRECISION.     #
  
DFXPTTODOUBL:                #DISPLAY FIXED PT TO DOUBLE PRECISION.    #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   DNUMTODOUBL - CONVERSION 3 - 14 
* *   DFXPTTODOUBL - CONVERSION 4 - 14
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM DISPLAY NUMERIC (CLASS 3) OR DISPLAY
*     FIXED PT (CLASS 4) TO DOUBLE PRECISION (CLASS 14).
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG GIVE LOCATION OF SOURCE DATA. 
*       SRDECPOS/SRXPLICD GIVE DEC PT INFO OF CLASS 4 SOURCE. 
*       TCURLOC = LOCATION OF TARGET. 
*       LEADZEROS = COUNT OF LEADING ZEROS IN SOURCE. 
*       SIGNPLUS = TRUE IF SOURCE POS.
* 
* DC  EXIT CONDITIONS 
*       NORMAL - SOURCE DATA CONVERTED TO DOUBLE PRECISION FORM AND 
*     MOVED TO TARGET.
*       ERROR - ERRCODE SET TO THAT RETURNED BY DC$BTOF.
* 
* DC  NON-LOCAL VARIABLES 
*       DC$CMBF 
*         FLAGDBL - DOUBLE PRECISION FLAG.
*         SINGLE - SINGLE PRECISION RESULT. 
*         DOUBLE - DOUBLE PRECISION RESULT. 
*         RETURNC - RETURN CODE FROM "DC$BTOF". 
*       BASED ARRAY "TGFIELD".
        RI - REAL SCRATCH VARIABLE
        I - INTEGER SCRATCH VARIABLE
* 
* DC  CALLED ROUTINES 
*       DISPLAYTOBIN - DISPLAY TO BINARY CONVERSION.
*       DC$BTOF - BINARY TO FLOATING CONVERSION.
        DC$DBLA - DOUBLE PRECISION ADD ROUTINE
* 
* DC  DESCRIPTIONS
*       CALL "DISPLAYTOBIN" TO CONVERT SOURCE DISPLAY CODE TO BINARY
*     INTEGER.
*     SET SCALING FACTOR IN "EXPONEN", AND CALL "DC$BTOF" TO CONVERT
*     THE BINARY INTEGER TO DOUBLE PRECISION. MOVE RESULT TO TARGET.
*     IF "DC$BTOF" RETURNS ERROR, ERROR EXIT. 
 #
  
      XREF PROC DC$DBLA;     #DOUBLE PRECISION ADD ROUTINE. # 
  
      ITEM TOP R;            #GETS HIGH ORDER WORD OF DOUBLE PREC F.P. #
      ITEM BOTTOM R;         #GETS LOW ORDER WORD OF DOUBLE PREC F.P. # 
  
      CALL DISPLAYTOBIN;     #CONVERT SOURCE INTO 108 BIT BINARY.      #
      EXPONEN=TGDECPOS+EXPONEN;        #SET SCALING FACTOR.            #
      FLAGDBL=TRUE;          #SET FLAG TO INDICATE DOUBLE PRECISION.   #
      CALL DC$BTOF;          #CONVERT BINARY TO FLOATING.              #
      IF RETURNC NQ 0 THEN   #YES - DC$BTOF DETECTS ERROR.             #
        BEGIN 
        ERRCODE=RETURNC;
        RETURN; 
        END 
      P<TGFIELD>=TCURLOC; 
      TOP = ABS(SINGLE);
      BOTTOM = ABS(DOUBLE); 
  
      RI = 0.0; 
      I = 0;
      DC$DBLA(TOP,BOTTOM,RI,I,TOP,BOTTOM);  #ADD .5 TO DOUBL PREC VAL. #
  
      IF SINGLE LS 0. THEN
        BEGIN 
        TGREAL[0] = - TOP;
        TGREAL[1] = - BOTTOM; 
        END 
      ELSE
        BEGIN 
        TGREAL[0] = TOP;
        TGREAL[1] = BOTTOM; 
        END 
      RETURN; 
      CONTROL EJECT;
  
DFXPTTODNUM:                 #DISPLAY FIXED PT TO DISPLAY NUMERIC.     #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   DFXPTTODNUM - CONVERSION 4 - 3
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM DISPLAY FIXED PT (CLASS 4) TO DISPLAY 
*     NUMERIC (CLASS 3).
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG CONTAINS SOURCE DATA. 
*       ASSUMERIGHT = COUNT OF SOURCE ASSUMED RIGHT ZEROS.
*       ASSUMELEFT = COUNT OF SOURCE ASSUMED LEFT ZEROS.
*       SGNTDIGITS = COUNT OF SOURCE SIGNIFICANT DIGITS.
*       DECDIGITS = COUNT OF SOURCE DECIMAL DIGITS. 
*       LEADZEROS = COUNT OF SOURCE LEADING ZEROS.
*       TCURLOC/TCURBYTE/TCURLENG GIVE LOCATION OF TARGET.
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SOURCE DATA CONVERTED AND MOVED TO TARGET.
*       ERROR:  
*         ERRCODE = O"666". 
*       IF NO ASSUMED ZEROS, CONTROL TO "ALNUMTODNUM".
* 
* DC  CALLED ROUTINES 
*       CMOVE      - CHARACTER MOVE.
*       EXTRACTSOP - EXTRACT SIGN OVERPUNCH.
*       STORESOP   - STORE SIGN OVERPUNCH.
* 
* DC DESCRIPTIONS 
*       IF NO ASSUMED ZERO IN SOURCE, PROCEDURE REMAINING IDENTICAL 
*     TO THAT OF CONVERSION 0 - 3. GOTO "ALNUMTODNUM".
*       IF SOURCE HAS ASSUMED LEFT ZEROS, TARGET VALUE WILL BE 0. 
*       IF SOURCE HAS ASSUMED RIGHT ZEROS, CHECK IF TARGET LARGE ENOUGH 
*     TO HOLD SOURCE VALUE. IF NOT, ERROR EXIT WITH CODE 666. IF YES, 
*     MOVE DATA INTO "INTERBUF" WITH TRAILING ZEROS IN PLACE. EXTRACT 
*     S-O-P IF NECESSARY. 
*       STORE S-O-P IF REQD AND MOVE DATA FROM "INTERBUF" TO TARGET.
 #
  
  
      IF ASSUMERIGHT EQ 0 THEN         #TRUE - SRDECPOS .GQ. 0.        #
        BEGIN 
        IF ASSUMELEFT EQ 0 THEN        #TRUE - SRDECPOS .LQ. SCURLENG. #
          GOTO ALNUMTODNUM;  #PROCEDURE SAME AS ALPHANUM TO DISPLAYNUM.#
        END 
      ELSE                             #SRDECPOS .LS. 0.               #
        BEGIN 
        IF TCURLENG LS (SGNTDIGITS+ASSUMERIGHT) THEN
          BEGIN 
          ERRCODE=O"666";    #LOSS OF SIGNIFICANT DIGITS.              #
          RETURN; 
          END 
        CALL CMOVE(SCURLOC,SCURBYTE+LEADZEROS,SGNTDIGITS, 
                   LOCINTERBUF,TCURLENG-SGNTDIGITS-ASSUMERIGHT);
        CALL EXTRACTSOP(TCURLENG-ASSUMERIGHT-1);
        END 
      CALL STORESOP(TCURLENG-1);
      CALL CMOVE(LOCINTERBUF,0,TCURLENG,TCURLOC,TCURBYTE);
      RETURN; 
      CONTROL EJECT;
  
DFXPTTODFXPT:                #DISPLAY FIXED POINT TO DISPLAY FIXED PT. #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   DFXPTTODFXPT - CONVERSION 4 - 4 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM DISPLAY FIXED PT (CLASS 4) TO DISPLAY 
*     FIXED PT (CLASS 4). 
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG CONTAINS SOURCE DATA. 
*       SGNTDIGITS = COUNT OF SIGNIFICANT DIGITS IN SOURCE. 
*       DECDIGITS = COUNT OF DECIMAL DIGITS IN SOURCE.
*       LEADZEROS - COUNT OF LEADING ZEROS IN SOURCE. 
*       SIGNPLUS = TRUE IF SOURCE POS.
*       TCURLOC/TCURBYTE/TCURLENG/TGXPLICD/TGDECPOS GIVE LOCATION AND 
*     FORMAT OF TARGET. 
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SOURCE DATA CONVERTED AND MOVED TO TARGET.
*       ERROR:  
*         ERRCODE = O"666". 
* 
* DC  NON-LOCAL VARIABLES 
*       TSGNTLEN - COUNT OF SIGNIFICANT DIGITS IN TARGET. 
*       TDECLEN - COUNT OF DECIMAL DIGITS IN TARGET.
*       TASMRIGHT - COUNT OF ASSUMED RIGHT ZERO IN TARGET.
*       TASMLEFT - COUNT OF ASSUMED LEFT ZEROS IN TARGET. 
*       LENGDIFF - TARGET/SOURCE LENGTH DIFFERENCE. 
*       I - SCRATCH ITEM. 
*       J - SCRATCH ITEM. 
* 
* DC  CALLED ROUTINES 
*       TG4INITIAL - TARGET CLASS 4 INITIALIZATION. 
*       CMOVE - CHARACTER MOVE. 
*       CHECKALLZERO - CHECK SPECIFIED STRING FOR ALL ZEROS.
*       EXTRACTSOP - EXTRACT SIGN OVER PUNCH. 
*       STORESOP - STORE SIGN OVER PUNCH. 
*       ROUND - ROUND NUMERIC STRING. 
* 
* DC  DESCRIPTIONS
*       CALL "TG4INITIAL" TO SET UP DESCRIPTIONS OF TARGET FORMAT.
*       CHECK IF TARGET SIZE LARGE ENOUGH TO HOLD DATA. IF NOT, ERROR 
*     EXIT WITH CODE 666. 
*       DEPENDING ON SOURCE DECIMAL POSITION, ONE OF 3 PATHS WILL BE
*     TAKEN. THEY ARE:  
*       (1). SRDECPOS < 0.
*       (2). SRDECPOS > SCURLENG. 
*       (3). 0 .LQ. SRDECPOS .LQ. SCURLENG. 
*       THEN FROM EACH OF THESE, AGAIN ONE OF 3 PATHS WILL BE TAKEN,
*     THIS TIME BASED ON TARGET DECIMAL POSITION: 
*       (1). TGDECPOS < 0.
*       (2). TGDECPOS > TCURLENG. 
*       (3). 0 .LQ. TGDECPOS .LQ. TCURLENG. 
*       IN EACH OF THESE SUBPARTS, THE SOURCE DATA IS MOVED, PART BY
*     PART IF NECESSARY, INTO "INTERBUF" BASED ON TARGET FORMAT. SIGN-
*     EXTRACTING, ROUNDING, SIGN-INSERTING, AND DECIMAL-INSERTING ARE 
*     DONE IF REQD. THE DATA IS THEN MOVED FROM "INTERBUF" TO TARGET. 
 #
  
  
      CALL TG4INITIAL;       #INITIALIZATION FOR TARGET CLASS 4.       #
      LENGDIFF=TSGNTLEN+TASMRIGHT-SGNTDIGITS-ASSUMERIGHT; 
      IF LENGDIFF LS 0 THEN  #TRUE - TARGET NOT LARGE ENOUGH FOR
                                     SIGNIFICANT SOURCE PART.          #
        BEGIN 
        ERRCODE=O"666"; 
        RETURN; 
        END 
  
# THIS MODULE WILL BE IN 3 PARTS, DEPENDING ON SOURCE DECIMAL POSITION. 
    (1).  SRDECPOS < 0. 
    (2).  SRDECPOS > SCURLENG.
    (3).  0 @ SRDECPOS @ SCURLENG.
  EACH PART WILL IN TURN BE IN 3 SUBPARTS.
    (1).  TGDECPOS < 0. 
    (2).  TGDECPOS > TCURLENG.
    (3).  0 @ TGDECPOS @ TCURLENG.                                     #
  
      IF ASSUMERIGHT NQ 0 THEN         #TRUE - SRDECPOS < 0.           #
        BEGIN 
        IF SGNTDIGITS NQ 0 THEN        #TRUE - VALUE OF SOURCE NOT 0.  #
          BEGIN 
          IF TASMRIGHT GR ASSUMERIGHT THEN       #DECIDE MOVE LENGTH.  #
            I=SGNTDIGITS+ASSUMERIGHT-TASMRIGHT+1; 
          ELSE
            I=SGNTDIGITS; 
          CALL CMOVE(SCURLOC,SCURBYTE+LEADZEROS,I,LOCINTERBUF,LENGDIFF);
          CALL EXTRACTSOP(LENGDIFF+I-1);
          END 
        IF TGXPLICD THEN               #TRUE - 0 @ TGDECPOS @ TCURLENG.#
          C<TSGNTLEN>INTERBUF=O"57";             #STORE DECIMAL POINT. #
        END 
      ELSE
        BEGIN 
        IF ASSUMELEFT NQ 0 THEN        #TRUE - SRDECPOS > SCURLENG.    #
          BEGIN 
  
          IF TASMRIGHT EQ 0 THEN       #TRUE - TARGET HAS DEC DIGITS.  #
            BEGIN 
            LENGDIFF=TASMLEFT-ASSUMELEFT; 
            IF LENGDIFF GR 0 THEN 
              BEGIN 
              IF LENGDIFF GR SCURLENG THEN
                J=SCURLENG; 
              ELSE
                J=LENGDIFF; 
              CALL CHECKALLZERO(SCURLOC,SCURBYTE,J);
                             #CHECK IF IMPLIED PART IN TARGET ALL 0.   #
              IF TCURLENG LS (SCURLENG-LENGDIFF) THEN 
                I=TCURLENG+1; 
              ELSE
                I=SCURLENG-LENGDIFF;
              CALL CMOVE(SCURLOC,SCURBYTE+LENGDIFF,I,LOCINTERBUF,0);
              CALL EXTRACTSOP(I-1); 
              END 
            ELSE
              BEGIN 
              IF TDECLEN  LS (SCURLENG-LENGDIFF) THEN 
                I=TDECLEN +LENGDIFF+1;
              ELSE
                I=SCURLENG; 
              J=TCURLENG-TDECLEN -LENGDIFF; 
              CALL CMOVE(SCURLOC,SCURBYTE,I,LOCINTERBUF,J); 
              CALL EXTRACTSOP(J+I-1); 
              END 
            IF TGXPLICD THEN
              C<TSGNTLEN>INTERBUF=O"57";
            END 
          END 
        ELSE                 # 0 @ SRDECPOS @ SCURLENG.                #
          BEGIN 
          IF TASMRIGHT GR 0 THEN
            BEGIN 
            CALL CMOVE(SCURLOC,SCURBYTE+LEADZEROS,
                       SGNTDIGITS-TASMRIGHT+1,LOCINTERBUF,
                       TCURLENG+TASMRIGHT-SGNTDIGITS);
            CALL EXTRACTSOP(TCURLENG);
            END 
          ELSE
            BEGIN 
            IF TASMLEFT GR 0 THEN 
              BEGIN 
              IF TASMLEFT GR DECDIGITS THEN 
                J=DECDIGITS;
              ELSE
                J=TASMLEFT; 
              CALL CHECKALLZERO(SCURLOC,SCURBYTE+SCURLENG-DECDIGITS,J); 
              IF TCURLENG LS (DECDIGITS-TASMLEFT) THEN
                I=TCURLENG+1; 
              ELSE
                I=DECDIGITS-TASMLEFT; 
              CALL CMOVE(SCURLOC,SCURBYTE+SCURLENG-DECDIGITS+TASMLEFT,
                         I,LOCINTERBUF,0);
              CALL EXTRACTSOP(I-1); 
              END 
            ELSE             # 0 @ TGDECPOS @ TCURLENG.                #
              BEGIN 
              CALL CMOVE(SCURLOC,SCURBYTE+LEADZEROS,SGNTDIGITS, 
                         LOCINTERBUF,TSGNTLEN-SGNTDIGITS);
              IF TGXPLICD THEN
                C<TSGNTLEN>INTERBUF=O"57";
              IF TDECLEN LS DECDIGITS THEN
                I=TDECLEN+1;
              ELSE
                I=DECDIGITS ; 
              CALL CMOVE(SCURLOC,SCURBYTE+SCURLENG-DECDIGITS,I, 
                         LOCINTERBUF,TCURLENG-TDECLEN); 
              CALL EXTRACTSOP(TCURLENG-TDECLEN+I-1);
              END 
            END 
          END 
        END 
  
      CALL ROUND(TCURLENG); 
      CALL STORESOP(TCURLENG-1);
      CALL CMOVE(LOCINTERBUF,0,TCURLENG,TCURLOC,TCURBYTE);
      RETURN; 
      CONTROL EJECT;
  
INTTODNUM:                   #BINARY INTEGER TO DISPLAY NUMERIC.       #
UNORMTODNUM:                 #UNNORMALIZED TO DISPLAY NUMERIC.         #
INTTODFXPT:                  #BINARY INTEGER TO DISPLAY FIXED PT.      #
UNORMTODFXPT:                #UNNORMALIED TO DISPLAY FIXED PT.         #
NORMTODNUM:                  #NORMALIZED TO DISPLAY NUMERIC.           #
NORMTODFXPT:                 #NORMALIZED TO DISPLAY FIXED PT.          #
DOUBLTODNUM:                 #DOUBLE PRECISION TO DISPLAY NUMERIC.     #
DOUBLTODFXPT:                #DOUBLE PRECISION TO DISPLAY FIXED PT.    #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   INTTODNUM-CONVERSION 10-3 UNORMTODNUM-CONVERSION 12-3 
  *   INTTODFXPT-CONVERSION 10-4 UNORMTODFXPT-CONVERSION 12-4 
  *   NORMTODNUM-CONVERSION 13-3 NORMTODFXPT-CONVERSION 13-4
  *   DOUBLTODNUM-CONVERSION 14-3 DOUBLTODFXPT-CONVERSION 14-4
*     C C CHOW     6/15/74
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM INTEGER AND FLOATING POINT
*     UNNORMALIZED, NORMALIZED, OR DOUBLE PRECISION TO DISPLAY
*     CODE NUMERIC OR FIXED PT. 
* 
* DC  ENTRY CONDITIONS
*       SRCLASS = SOURCE DATA CLASS.
*       SCURLOC = SOURCE LOCATION.
*       TCURLOC/TCURBYTE/TCURLENG GIVE LOCATION OF TARGET.
*       TGDECPOS/TGXPLICD GIVE TARGET FORMAT IF TARGET CLASS 4. 
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         INFORMATION SET UP FOR CONVERSION TO CONTINUE WITH A DISPLAY
*       FIXED PT DATA STRING AS SOURCE. 
*         SCURLOC = LOC OF DISPLAY FIXED PT STRING THAT WILL BE TREATED 
*                   AS SOURCE. SET TO LOC(DISPCTG) IN "DC$CMFD".
*         SCURBYTE = BEGINNING BYTE POSITION. SET TO 0. 
*         SCURLENG = DATA STRING LENGTH. SET TO 19. 
*         SRDECPOS = DECIMAL POSITION OF THE DISPLAY FIXED PT STRING. 
*         SRXPLICD = EXPLICIT DECIMAL FLAG. SET TO FALSE. 
*         LEADZEROS = COUNT OF LEADING ZEROS. SET TO 0. 
*       ERROR:  
*         ERROR EXIT ON ERROR DETECTED BY "DC$FTOD".
* 
* DC  CALLED ROUTINES 
*       DC$FTOD - CONVERSION FLOATING TO DISPLAY CODE.
* 
* DC  NON-LOCAL VARIABLES 
*       DC$CMFD 
*         ADDRSR - LOCATION OF SOURCE.
*         DBLFGSR - TRUE IF SOURCE DOUBLE PRECISION.
*         ARRAY DISPCTG - DISPLAY CODE RESULT FROM "DC$FTOD" CONVERSION.
*         DECPTTG - DECIMAL POSITION OF DATA IN "DISPCTG".
*         SIGNPLUS = TRUE IF DATA STRING POS. 
*         CRETURN - RETURN CODE FROM "DC$FTOD". 
* 
* DC  DESCRIPTIONS
*       CALL "DC$FTOD" TO CONVERT FLOATING PT SOURCE TO DISPLAY CODE. 
*     THE RESULT WILL BE FOUND IN ARRAY "DISPCTG". "DECPTTG" WILL GIVE
*     THE POSITION OF THE ASSUMED DECIMAL PT RELATIVE TO LEFTMOST BYTE
*     IN "DISPCTG". IF "DC$FTOD" RETURNS ERROR, SET "ERRCODE" AND EXIT. 
*       CHECK IF LEFT MOST CHAR IN "DISPCTG" IS DISPLAY CODE 0. IF YES, 
*     LEFT SHIFT DATA IN "DISPCTG" ONE CHAR TO LEFT. THIS IS BECAUSE
*     WE WILL BE TREATING THE DATA AS 19 CHAR STRING STARTING AT BYTE 0.
*     "DC$FTOD" CONVERTS THE FLOATING PT SOURCE TO A 19 CHAR DISPLAY
*     CODE STRING STARTING AT BYTE 1 IN "DISPCTG". BYTE 0 IS RESERVED 
*     FOR THE EXTREME ROUNDING CASE WHEN THE WHOLE STRING WILL BE 
*     ROUNDED TO A "1" IN BYTE 0. 
*       SET "SCURLOC" TO LOC OF "DISPCTG", "SCURLENG" TO 19, AND
*     "SCURBYTE" TO 0. SET "SRDECPOS" TO INDICATE DECIMAL POSITION, AND 
*     "SRXPLICD" TO FALSE. SET "SIGNPLUS" TO INDICATE DATA SIGN, AND
*     "LEADZEROS" TO 0. CONTINUE WITH PROCEDURE FOR CONVERTING FROM 
*     DISPLAY FIXED PT SOURCE.
 #
  
  
      ADDRSR=SCURLOC;        #PARAMETER FOR DC$FTOD. SOURCE LOCATION.  #
      IF SRCLASS EQ 14 THEN  #YES - SOURCE IS DOUBLE PRECISION.        #
        DBLFGSR=TRUE;        #PARAMETER FOR DC$FTOD. INDICATE DP.      #
      ELSE
        DBLFGSR=FALSE;
      XCALL DC$FTOD;         #FLOATING TO DISPLAY CODE CONVERSION.     #
      IF CRETURN NQ 0 THEN   #YES - DC$FTOD DETECTS ERROR.             #
        BEGIN 
        ERRCODE=CRETURN;
        RETURN; 
        END 
  
# NOW WE HAVE A CHARACTER STRING IN DISPLAY FIXED PT (CLASS 4) FORMAT.
  WE WILL CARRY OUT PROCEDURE AS IF SOURCE IS DISPLAY FIXED PT. 
  IF THE 1ST CHAR OF THIS STRING IS O"33", WE WILL SHIFT THE STRING 
  LEFT 1 DIGIT, AND ADJUST THE DECIMAL POSITION. IF NOT, IT MUST BE 
  O"34" WITH REST OF STRING BEING O"33". THIS WILL ONLY HAPPEN AT THE 
  EXTREME ROUNDING CASE, WHEN THE LAST 19 DIGITS OF STRING ARE ALL 9"S, 
  AND ROUNDING HAS TO BE DONE.                                         #
  
      IF B<0,6>IDCTG[0] EQ O"33" THEN  #YES - WILL HAVE TO LEFT SHIFT 
                                        "DISPCTG" 1 DIGIT.             #
        BEGIN 
        B<0,54>IDCTG[0]=B<6,54>IDCTG[0];
        B<54,6>IDCTG[0]=B<0,6>IDCTG[1]; 
        B<0,54>IDCTG[1]=B<6,54>IDCTG[1];
        DECPTTG=DECPTTG-1;             #ADJUST DECIMAL PT POSITION.    #
        END 
      SCURLOC=LOC(DISPCTG); 
      SCURLENG=19;
      SCURBYTE=0; 
      IF SRCLASS EQ 13 THEN  #YES - CAN IGNORE SOURCE DECIMAL POSITION.#
        SRDECPOS=19-DECPTTG;
      ELSE
        SRDECPOS=19-DECPTTG+SRDECPOS; 
      SRXPLICD=FALSE; 
      SIGNPLUS=SGNPLTG; 
      LEADZEROS=0;
      GOTO SRDFXPT1;         #CONTINUE AS IF SOURCE IS DISPLAY FX-PT.  #
      CONTROL EJECT;
  
INTTOINT:                    #BINARY INTEGER TO BINARY INTEGER         #
INTTOUNORM:                  #BINARY INTEGER TO UNNORMALIZED           #
UNORMTOINT:                  #UNNORMALIZED TO BINARY INTEGER           #
UNORMTOUNORM:                #UNNORMALIZED TO UNNORMALIZED.            #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   INTTOINT - CONVERSION 10 - 10 
  *   INTTOUNORM - CONVERSION 10 - 12 
  *   UNORMTOINT - CONVERSION 12 - 10 
  *   UNORMTOUNORM - CONVERSION 12 - 12 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*     PERFORM CONVERSION FROM INTEGER OR UNNORMALIZED FLOATING
*     (CLASS 12) TO INTEGER (CLASS 10) OR UNNORMALIZED FLOATING PT. 
* 
* DC  ENTRY CONDITIONS
*       BASED ARRAY "SRFIELD" POINTS TO SOURCE DATA.
*       SRDECPOS = SOURCE DECIMAL POSITION. 
*       TGDECPOS = TARGET DECIMAL POSITION. 
*       TCURLOC = TARGET LOCATION.
* 
* DC  EXIT CONDITIONS 
*       SOURCE DATA CONVERTED AND MOVED TO TARGET.
* 
* DC  CALLED ROUTINES 
*       DC$FTOF - CONVERTS FLOATING PT TO FLOATING PT.
*       UNORMFLOAT - UNNORMALIZES FLOATING PT DATA. 
* 
* DC  DESCRIPTIONS
*       CALL "DC$FTOF" WITH SOURCE INFO, AND THEN CALL "UNORMFLOAT".
 #
  
  
      XCALL DC$FTOF(SRREAL[0],0,TGDECPOS-SRDECPOS,1); 
      CALL UNORMFLOAT;       #CONVERT TO UNNORMALIZED NUMBER.          #
      RETURN; 
      CONTROL EJECT;
  
INTTONORM:                   #INTEGER TO NORMALIZED                    #
UNORMTONORM:                 #UNNORMALIZED TO NORMALIZED.              #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   INTTONORM - CONVERSION 10 - 13
  *   UNORMTONORM - CONVERSION 12 - 13
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM INTEGER (CLASS 10) OR UNNORMALIZED
*     FLOATING PT (CLASS 12) TO NORMALIZED FLOATING PT (CLASS 13).
* 
* DC  ENTRY CONDITIONS
*       BASED ARRAY "SRFIELD" POINTS TO SOURCE DATA.
*       SRDECPOS = SOURCE DECIMAL POSITION. 
*       TCURLOC = TARGET LOCATION.
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SOURCE DATA CONVERTED AND MOVED TO TARGET.
*       ERROR:  
*         "ERRCODE" SET TO INDICATE ERROR DETECTED BY "DC$SCAF".
* 
* DC  NON-LOCAL VARIABLES 
*       BASED ARRAY "TGFIELD".
*       DC$CMBF 
*         SINGLE - NORMALIZED FLOATING RESULT OF CONVERSION.
* 
* DC  CALLED ROUTINES 
*       DC$FTOF - CONVERTS FLOATING PT TO FLOATING PT.
* 
* DC  DESCRIPTIONS
*       CALL "DC$FTOF" TO CONVERT AND SCALE SOURCE DATA INTO NORMALIZED 
*     FLOATING PT AND MOVE IT TO TARGET. IF "DC$FTOF" RETURNS ERROR,
*     SET "ERRCODE" AND EXIT. 
 #
  
  
      XCALL DC$FTOF(SRREAL[0],0,-SRDECPOS,1); 
      IF RETURNC NQ 0 THEN   #YES - DC$FTOF DETECTS ERROR.             #
        BEGIN 
        ERRCODE=RETURNC;
        RETURN; 
        END 
      P<TGFIELD>=TCURLOC; 
      TGREAL[0]=SINGLE; 
      RETURN; 
      CONTROL EJECT;
  
INTTODOUBL:                  #INTEGER TO DOUBLE PRECISION              #
UNORMTODOUBL:                #UNNORMALIZED TO DOUBLE PRECISION.        #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   INTTODOUBL - CONVERSION 10 - 14 
  *   UNORMTODOUBL - CONVERSION 12 - 14 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM INTEGER (CLASS 10) OR UNNORMALIZED
*     FLOATING PT (CLASS 12) TO DOUBLE PRECISION (CLASS 14).
* 
* DC  ENTRY CONDITIONS
*       BASED ARRAY "SRFIELD" POINTS TO SOURCE DATA.
*       SRDECPOS = SOURCE DECIMAL POSITION. 
*       TCURLOC = TARGET LOCATION.
* 
* DC  EXIT CONDITIONS 
*       NORMAL - SOURCE DATA CONVERTED AND MOVED TO TARGET. 
*       ERROR - ERRCODE SET TO THAT RETURNED BY DC$FTOF.
* 
* DC  NON-LOCAL VARIABLES 
*       BASED ARRAY "TGFIELD".
*       DC$CMBF 
*         SINGLE - 1ST PART OF DOUBLE PRECISION RESULT. 
*         DOUBLE - 2ND PART OF DOUBLE PRECISION RESULT. 
* 
* DC  CALLED ROUTINES 
*       DC$FTOF - FLOATING TO FLOATING CONVERSION.
* 
* DC  DESCRIPTIONS
*       CALL "DC$FTOF" TO CONVERT AND SCALE SOURCE DATA INTO DOUBLE 
*     PRECISION AND MOVE TO TARGET. 
*       IF "DC$FTOF" RETURNS ERROR, SET "ERRCODE" AND EXIT. 
 #
  
  
      XCALL DC$FTOF(SRREAL[0],0,TGDECPOS-SRDECPOS,2); 
      IF RETURNC NQ 0 THEN   #YES - DC$FTOF DETECTS ERROR.             #
        BEGIN 
        ERRCODE=RETURNC;
        RETURN; 
        END 
      P<TGFIELD>=TCURLOC; 
      TGREAL[0]=SINGLE; 
      TGREAL[1]=DOUBLE; 
      RETURN; 
      CONTROL EJECT;
  
NORMTOINT:                   #NORMALIZED TO INTEGER                    #
NORMTOUNORM:                 #NORMALIZED TO UNNORMALIZED.              #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   NORMTOINT - CONVERSION 13 - 10
  *   NORMTOUNORM - CONVERSION 13 - 12
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM NORMALIZED FLOATING PT (CLASS 13) TO
*     INTEGER (CLASS 10) OR UNNORMALIZED FLOATING PT (CLASS 12).
* 
* DC  ENTRY CONDITIONS
*       BASED ARRAY "SRFIELD" POINTS TO SOURCE DATA.
*       TCURLOC = TARGET LOCATION.
*       TGDECPOS = TARGET DECIMAL POSITION. 
* 
* DC  EXIT CONDITIONS 
*       SOURCE DATA CONVERTED AND MOVED TO TARGET.
* 
* DC  CALLED ROUTINES 
*       DC$FTOF - FLOATING TO FLOATING CONVERSION.
*       UNORMFLOAT - UNNORMALIZE FLOATING PT DATA.
* 
* DC  DESCRIPTIONS
*       CALL "DC$FTOF" TO SCALE SOURCE DATA WITH SCALING FACTOR, AND
*     CALL "UNORMFLOAT" TO PACK DATA APPROPRIATELY. 
 #
  
  
      XCALL DC$FTOF(SRREAL[0],0,TGDECPOS,1);
      CALL UNORMFLOAT;       #CONVERT TO UNNORMALIZED.                 #
      RETURN; 
      CONTROL EJECT;
  
NORMTONORM:                  #NORMALIZED TO NORMALIZED.                #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   NORMTONORM - CONVERSION 13 - 13 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM NORMALIZED FLOATING PT (CLASS 13) TO
*     NORMALIZED FLOATING PT (CLASS 13).
* 
* DC  ENTRY CONDITIONS
*       BASED ARRAY "SRFIELD" POINTS TO SOURCE DATA.
*       TCURLOC = TARGET LOCATION.
* 
* DC  EXIT CONDITIONS 
*       SOURCE DATA MOVED TO TARGET.
* 
* DC  NON-LOCAL VARIABLES 
*       BASED ARRAY "TGFIELD".
* 
* DC  DESCRIPTIONS
*       MOVE SOURCE DATA TO TARGET DIRECTLY. NO CONVERSION NEEDED.
 #
  
  
      P<TGFIELD>=TCURLOC; 
      TGREAL[0]=SRREAL[0];
      RETURN; 
      CONTROL EJECT;
  
NORMTODOUBL:                 #NORMALIZED TO DOUBLE PRECISION.          #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   NORMTODOUBL - CONVERSION 13 - 14
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM NORMALIZED FLOATING PT (CLASS 13) TO
*     DOUBLE PRECISION (CLASS 14).
* 
* DC  ENTRY CONDITIONS
*       BASED ARRAY "SRFIELD" POINTS TO SOURCE DATA.
*       TCURLOC = TARGET LOCATION.
* 
* DC  EXIT CONDITIONS 
*       NORMAL - SOURCE DATA CONVERTED AND MOVED TO TARGET. 
*       ERROR - ERRCODE SET TO THAT RETURNED BY DC$FTOF.
* 
* DC  NON-LOCAL VARIABLES 
*       BASED ARRAY "TGFIELD".
*       DC$CMBF 
*         SINGLE - 1ST PART OF DOUBLE PRECISION RESULT. 
*         DOUBLE - 2ND PART OF DOUBLE PRECISION RESULT. 
* 
* DC  CALLED ROUTINES 
*       DC$FTOF - FLOATING TO FLOATING CONVERSION.
* 
* DC  DESCRIPTIONS
*       CALL "DC$FTOF" TO CONVERT AND SCALE SOURCE DATA INTO DOUBLE 
*     PRECISION, AND MOVE TO TARGET. IF "DC$FTOF" RETURNS ERROR, SET
*     "ERRCODE" AND EXIT. 
 #
  
  
      XCALL DC$FTOF(SRREAL[0],0,TGDECPOS,2);
      IF RETURNC NQ 0 THEN
        BEGIN 
        ERRCODE=RETURNC;
        RETURN; 
        END 
      P<TGFIELD>=TCURLOC; 
      TGREAL[0]=SINGLE; 
      TGREAL[1]=DOUBLE; 
      RETURN; 
      CONTROL EJECT;
  
DOUBLTOINT:                  #DOUBLE PRECISION TO INTEGER              #
DOUBLTOUNORM:                #DOUBLE PRECISION TO UNNORMALIZED.        #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   DOUBLTOINT - CONVERSION 14 - 10 
  *   DOUBLTOUNORM - CONVERSION 14 - 12 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM DOUBLE PRECISION (CLASS 14) TO
*     INTEGER (CLASS 10) OR UNNORMALZIED FLOATING PT (CLASS 12).
* 
* DC  ENTRY CONDITIONS
*       BASED ARRAY "SRFIELD" POINTS TO SOURCE DATA.
*       TCURLOC = TARGET LOCATION.
*       TGDECPOS = TARGET DECIMAL POSITION. 
* 
* DC  EXIT CONDITIONS 
*       SOURCE DATA CONVERTED AND MOVED TO TARGET.
* 
* DC  CALLED ROUTINES 
*       DC$FTOF - FLOATING TO FLOATING CONVERSION.
*       UNORMFLOAT - UNNORMALIZE FLOATING PT DATA.
* 
* DC  DESCRIPTIONS
*       CALL "DC$FTOF" TO CONVERT AND SCALE SOURCE DATA WITH SCALING
*     FACTOR. THEN CALL "UNORMFLOAT" TO REPACK RESULT INTO UNNORMALIZED 
*     FORM. 
 #
  
  
      XCALL DC$FTOF(SRREAL[0],SRREAL[1],TGDECPOS-SRDECPOS,1); 
      CALL UNORMFLOAT;
      RETURN; 
      CONTROL EJECT;
  
DOUBLTONORM:                 #DOUBLE PRECISION TO NORMALIZED.          #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   DOUBLTONORM - CONVERSION 14 - 13
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM DOUBLE PRECISION (CLASS 14) TO
*     NORMALIZED FLOATING PT (CLASS 13).
* 
* DC  ENTRY CONDITIONS
*       BASED ARRAY "SRFIELD" POINTS TO SOURCE DATA.
*       TCURLOC = TARGET LOCATION.
* 
* DC  EXIT CONDITIONS 
*       NORMAL - SOURCE DATA CONVERTED AND MOVED TO TARGET. 
*       ERROR - ERRCODE SET TO THAT RETURNED BY DC$FTOF.
* 
* DC  NON-LOCAL VARIABLES 
*       BASED ARRAY "TGFIELD".
*       DC$CMBF 
*         SINGLE - NORMALIZED FLOATING PT CONVERSION RESULT.
* 
* DC  CALLED ROUTINES 
*       DC$FTOF - FLOATING TO FLOATING CONVERSION.
* 
* DC  DESCRIPTIONS
*       CALL "DC$FTOF" TO CONVERT SOURCE DATA INTO SINGLE PRECISION 
*     NORMALIZED FLOATING PT AND MOVE TO TARGET. IF "DC$FTOF" RETURNS 
*     ERROR, SET "ERRCODE" AND EXIT.
 #
  
  
      XCALL DC$FTOF(SRREAL[0],SRREAL[1],-SRDECPOS,1); 
      IF RETURNC NQ 0 THEN
        BEGIN 
        ERRCODE=RETURNC;
        RETURN; 
        END 
      P<TGFIELD>=TCURLOC; 
      TGREAL[0]=SINGLE; 
      RETURN; 
      CONTROL EJECT;
  
DOUBLTODOUBL:                #DOUBLE PRECISION TO DOUBLE PRECISION.    #
  
 #
  *   DC$CONV                                    PAGE 1 
  *   DOUBLTODOUBL - CONVERSION 14 - 14 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PERFORM CONVERSION FROM DOUBLE PRECISION (CLASS 14) TO
*     DOUBLE PRECISION (CLASS 14).
* 
* DC  ENTRY CONDITIONS
*       BASED ARRAY "SRFIELD" POINTS TO SOURCE DATA.
*       TCURLOC = TARGET LOCATION.
* 
* DC  EXIT CONDITIONS 
*       NORMAL - SOURCE DATA MOVED TO TARGET. 
*       ERROR - ERRCODE SET TO THAT RETURNED BY DC$FTOF.
* 
* DC  NON-LOCAL VARIABLES 
*       BASED ARRAY "TGFIELD".
*       DC$CMBF 
*         SINGLE - 1ST PART OF DOUBLE PRECISION RESULT. 
*         DOUBLE - 2ND PART OF DOUBLE PRECISION RESULT. 
* 
* DC  CALLED ROUTINES 
*       DC$FTOF - FLOATING TO FLOATING CONVERSION.
* 
* DC  DESCRIPTIONS
*       CALL "DC$FTOF" TO SCALE SOURCE DATA APPROPRIATELY AND MOVE TO 
*     TARGET. IF "DC$FTOF" RETURNS ERROR, SET "ERRCODE" AND EXIT. 
 #
  
  
      XCALL DC$FTOF(SRREAL[0],SRREAL[1],TGDECPOS-SRDECPOS,2); 
      IF RETURNC NQ 0 THEN
        BEGIN 
        ERRCODE=RETURNC;
        RETURN; 
        END 
      P<TGFIELD>=TCURLOC; 
      TGREAL[0]=SINGLE; 
      TGREAL[1]=DOUBLE; 
  
      RETURN; 
      CONTROL EJECT;
  
NONSUPPORT:                  #NON-SUPPORTED CONVERSION.                #
  
      ERRCODE=O"663"; 
  
  
  
CONV$EXIT:                   #CONVERSION ROUTINE EXIT.                 #
  
      RETURN; 
      CONTROL EJECT;
  
      PROC CHECKSRNUM;       #CHECK-SOURCE-NUMERIC.                    #
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   CHECKSRNUM - CHECK SOURCE NUMERIC 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       CHECK IF SOURCE DATA STRING CONTAINS LEGAL NUMERIC DISPLAY CODE 
*     STRING. 
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG CONTAINS SOURCE DATA STRING WITH NO 
*     LEADING BLANKS. 
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SIGNPLUS = TRUE IS SOURCE DATA POS NUMERIC
*         LEADZEROS = COUNT OF LEADING ZEROS IN SOURCE. 
*         SGNTDIGITS = COUNT OF SIGNIFICANT DIGITS IN SOURCE. 
*         DECDIGITS = COUNT OF DECIMAL DIGITS IN SOURCE.
*       ERROR:  
*         ERRCODE = O"664". 
* 
* DC  NON-LOCAL VARIABLES 
*       SIGNED - TO INDICATE THAT SIGN HAS BEEN SCANNED IN SOURCE.
*       DECIMALED - TO INDICATE THAT DEC PT HAS BEEN SCANNED IN SOURCE. 
*       SGNTLENG - TO KEEP TRACK OF NUMBER OF SOURCE CHARS SCANNED. 
*                  INCREMENT BY 1 EVERY TIME A SOURCE CHAR IS SCANNED.
*       GETBYTE - PARAMETER FOR "GETSRCHAR". POSITION OF BYTE TO GET. 
*       CHAR - SET BY "GETSRCHAR" TO VALUE OF CURRENT SOURCE BYTE.
*       I - LOOP VARIABLE WHILE IDENTIFYING LEADING ZEROS. ALSO USED AS 
*           SCRATCH ITEM. 
*       J - LOOP VARIABLE FOR IDENTIFYING REST OF DATA STRING. ALSO 
*           USED AS SCRATCH ITEM. 
* 
* DC  CALLING ROUTINES
*       MODULE "SRALPHANUM".
* 
* DC  CALLED ROUTINES 
*       GETSRCHAR - GET SOURCE CHARACTER. 
*       IGNOREBLANKS - IGNORE BLANKS. 
* 
* DC  DESCRIPTIONS
*       SOURCE STRING EXPECTED TO BE IN FOLLOWING FORM: 
*         OPTIONAL SIGN(DISPLAY CODE + OR -), 
*         OPTIONAL INTERVENING BLANKS (ONE CONTIGUOUS STRING, BEFORE
*           FIRST NUMERIC CHARACTER), 
*         NUMERIC DISPLAY CODE CHARS (MAY HAVE 1 DECIMAL POINT. LAST
*           DIGIT MAY BE SIGN-OVER-PUNCH),
*         OPTIONAL SIGN (DISPLAY CODE + OR -),
*         OPTIONAL TRAILING BLANKS. 
*       THERE COULD BE NO MORE THAN 1 SIGN (OR SIGN-OVER-PUNCH), AND
*     1 DECIMAL POINT.
*       THIS PROC WILL SCAN THE SOURCE STRING BYTE BY BYTE TO CHECK IF
*     IT CONFORMS TO THE ABOVE FORMAT, AND SET "SIGNPLUS", "LEADZEROS", 
*     "SGNTDIGITS", AND "DECDIGITS". IF IT DOES NOT CONFORM TO ABOVE
*     FORMAT, ERROR EXIT WITH CODE 664. 
*       CASES THAT NEED SPECIAL ATTENTION:  
*       (1) WHEN DATA STRING IS ALL ZERO WITH LAST DIGIT ZERO SOP,
*     "LEADZEROS" SHOULD INCLUDE THE SOP ZERO.
*       (2) SIGN-OVER-PUNCH IS ALWAYS THE LAST DIGIT (NOT COUNTING
*     TRAILING BLANKS). THE ONLY EXCEPTION IS WHEN THE LAST DIGIT IS A
*     DECIMAL PT, IN WHICH CASE SIGN-OVER-PUNCH IS 2ND LAST DIGIT.
 #
  
  
      SIGNED=FALSE;          #INITIALIZE TO INDICATE NO SIGN.          #
      SIGNPLUS=TRUE;         #INITIALIZE TO INDICATE POSITIVE.         #
      DECIMALED=FALSE;       #NO DECIMAL POINT.                        #
      LEADZEROS=0;           #NO LEADING ZEROS.                        #
      SGNTDIGITS=0;          #SIGNIFICANT DIGITS.                      #
      DECDIGITS=0;           #DECIMAL DIGITS.                          #
      SGNTLENG=0;            #SIGNIFICANT LENGTH.                      #
      IF SCURLENG LQ 0 THEN  #YES - SOURCE STRING IS NULL.             #
        RETURN; 
  
# CHECK IF STRING HAS LEADING EXPLICIT SIGN.                           #
  
      P<SRFIELD>=SCURLOC; 
      GETBYTE=SCURBYTE; 
      CALL GETSRCHAR;        #GET CHAR FROM SOURCE.                    #
  
      IF CHAR EQ O"45" OR CHAR EQ O"46" THEN     #YES - LEADING SIGN.  #
        BEGIN 
        SIGNED=TRUE;         #TO INDICATE SIGN SCANNED.                #
        IF CHAR EQ O"46" THEN          #YES - MINUS SIGN.              #
          SIGNPLUS=FALSE;              #TO INDICATE NEG SOURCE.        #
        SCURBYTE=SCURBYTE+1; #UPDATE SOURCE POSITIONING TO NEXT NON-
                              BLANK.                                   #
        SCURLENG=SCURLENG-1;
        CALL IGNOREBLANKS(SCURLOC,SCURBYTE,SCURLENG); 
        END 
  
# START SCANNING SOURCE STRING WITH IDENTIFYING LEADING ZEROS.         #
  
      P<SRFIELD>=SCURLOC; 
      GETBYTE=SCURBYTE; 
      FOR I=1 THRU SCURLENG DO
        BEGIN 
        CALL GETSRCHAR;      #GET CHAR FROM SOURCE.                    #
        IF CHAR NQ O"33" THEN          #YES - NOT ZERO.                #
          GOTO DONELEADZERO;           #DONE WITH IDENTIFYING LEADING 
                                        ZEROS.                         #
        LEADZEROS=LEADZEROS+1;         #LEADING ZERO COUNT.            #
        END 
      RETURN;                #WHOLE SOURCE STRING HAS BEEN SCANNED. IN
                              THIS CASE, IT IS ALL ZEROS.              #
  
DONELEADZERO:                #LEADING ZEROS IN SOURCE STRING HAVE BEEN
                              IDENTIFIED. NOW CONTINUE WITH REST OF 
                              STRING.                                  #
      GETBYTE=GETBYTE-1;     #MOVE BACK SCANNING POSITION BY ONE.      #
      FOR J=I THRU SCURLENG DO
        BEGIN 
        CALL GETSRCHAR; 
  
# CHECK FOR LEGAL NUMERIC DIGITS "0" TO "9".                           #
  
        IF CHAR GQ O"33" AND CHAR LQ O"44" THEN  #YES - LEGAL NUMERIC. #
          BEGIN 
          SGNTLENG=SGNTLENG+1;
          TEST; 
          END 
  
# CHECK FOR BLANK.                                                     #
  
        IF CHAR EQ O"55" THEN          #YES - CHAR IS BLANK.           #
          GOTO CHECKALLBLNK;           #CHECK IF REMAINING ALL BLANKS. #
  
# CHECK FOR SIGN IF YET UNSIGNED.                                      #
  
        IF NOT SIGNED THEN   #YES - YET UNSIGNED.                      #
          BEGIN 
  
# CHECK FOR EXPLICIT SIGN.                                             #
  
          IF CHAR EQ O"45" OR CHAR EQ O"46" THEN #YES - EXPLICIT SIGN. #
            BEGIN 
            SIGNED=TRUE;
            IF CHAR EQ O"46" THEN      #YES - NEGATIVE.                #
              SIGNPLUS=FALSE; 
            GOTO CHECKALLBLNK;         #CHECK IF REMAINING ALL BLANKS. #
            END 
  
# CHECK FOR SIGN-OVER-PUNCH.                                           #
  
          IF CHAR EQ O"66" OR CHAR EQ O"72" OR (CHAR GQ O"01" AND 
             CHAR LQ O"22") THEN       #YES - CHAR IS SOP.             #
            BEGIN 
            SIGNED=TRUE;
            IF CHAR GQ O"12" AND CHAR NQ O"72" THEN #YES- NEGATIVE SOP.#
              SIGNPLUS=FALSE; 
# IF SOP ZERO IMMED FOLLOWS LEADING ZEROES, INCLUDE IN LEADZEROS.#
            IF J EQ I AND (CHAR EQ O"72" OR CHAR EQ O"66") THEN 
              LEADZEROS=LEADZEROS+1;
            ELSE
              SGNTLENG=SGNTLENG+1;
            IF NOT DECIMALED THEN      #YES - SOURCE UNDECIMALED UPTO 
                                        PRESENT POSITION. SINCE A SOP 
                                        COULD ONLY BE FOLLOWED BY ALL 
                                        BLANKS PRECEDED BY AN OPTIONAL
                                        DECIMAL POINT, WE HAVE TO CHECK 
                                        IF THE DECIMAL POINT EXISTS.   #
              BEGIN 
              IF J NQ SCURLENG THEN    #YES - NOT YET END OF STRING.
                                        THUS DECIMAL POINT COULD EXIST.#
                BEGIN 
                CALL GETSRCHAR; 
                IF CHAR EQ O"57" THEN  #YES - DECIMAL POINT.           #
                  BEGIN 
                  DECIMALED=TRUE; 
                  SGNTDIGITS=SGNTLENG;
                  SGNTLENG=SGNTLENG+1;
                  J=J+1;
                  END 
                ELSE
                  GETBYTE=GETBYTE-1;
                END 
              END 
            GOTO CHECKALLBLNK;         #CHECK IF REMAINING ALL BLANKS. #
            END 
          END 
  
# CHECK FOR DECIMAL POINT IF YET UNDECIMALED.                          #
  
        IF NOT DECIMALED AND CHAR EQ O"57" THEN  #YES - DECIMAL POINT. #
          BEGIN 
          DECIMALED=TRUE; 
          SGNTDIGITS=SGNTLENG;
          END 
        ELSE                           #CHAR IS ILLEGAL.               #
          BEGIN 
          ERRCODE=O"664"; 
          GOTO CONV$EXIT; 
          END 
        SGNTLENG=SGNTLENG+1;
        END 
  
NORMEXIT:                    #NORMAL EXIT. SET "SGNTDIGITS" OR
                              "DECDIGITS".                             #
      IF DECIMALED THEN 
        DECDIGITS=SGNTLENG-SGNTDIGITS-1;
      ELSE
        SGNTDIGITS=SGNTLENG;
      RETURN; 
  
CHECKALLBLNK:                #IN "SRFIELD", STARTING AT "GETBYTE",
                              CHECK IF THERE IS A STRING OF BLANKS OF 
                              LENGTH "SCURLENG-J". IF NOT, ERROR.      #
      I=SCURLENG-J; 
      CALL IGNOREBLANKS(LOC(SRFIELD),GETBYTE,I);
      IF I NQ 0 THEN         #YES - NOT ALL BLANKS.                    #
        BEGIN 
        ERRCODE=O"664";      #ILLEGAL SOURCE STRING.                   #
        GOTO CONV$EXIT; 
        END 
      ELSE
        BEGIN 
        SCURLENG=J-1;        #UPDATE SOURCE LENGTH, IGNORING TRAILING 
                              BLANKS.                                  #
        GOTO NORMEXIT;
        END 
  
      END 
      CONTROL EJECT;
  
      PROC CHECKCLS3;        #CHECK-SOURCE-CLASS3.                     #
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   CHECKCLS3 - CHECK SOURCE CLASS 3
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       VERIFY THAT SOURCE DATA IS LEGAL CLASS 3. 
* 
* DC  ENTRY CONDITIONS
*       SCURLOC  = SOURCE LOCATION. 
*       SCURBYTE = SOURCE BEGINNING BYTE POSITION.
*       SCURLENG = SOURCE LENGTH IN BYTES.
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SIGNPLUS = TRUE IF SOURCE DATA POS. 
*         LEADZEROS = NUMBER OF LEADING ZEROS IN SOURCE DATA. 
*       ERROR:  
*         ERRCODE = O"664". 
* 
* DC  NON-LOCAL VARIABLES 
*       GETBYTE - PARAMETER FOR "GETSRCHAR". POSITION OF BYTE TO GET. 
*       CHAR    - SET BY "GETSRCHAR" TO VALUE OF CURRENT SOURCE BYTE. 
* 
* DC  CALLING ROUTINES
*       MODULE "SRDNUMERIC".
* 
* DC  CALLED ROUTINES 
*       GETSRCHAR - GET SOURCE CHARACTER. 
* 
* DC  DESCRIPTIONS
*       SCAN SOURCE DATA STRING CHAR BY CHAR AND CHECK IF EACH IS 
*     DISPLAY CODE 0 TO 9. IF NOT, CHECK IF IT IS LAST DIGIT AND SIGN-
*     OVER-PUNCH, AND IF IT IS NOT, EXIT WITH ERRCODE 664.
*       SET "SIGNPLUS" AND "LEADZEROS" TO INDICATE SOURCE SIGN AND
*     NUMBER OF LEADING ZEROS, IF ANY.
 #
  
  
      SIGNPLUS=TRUE;         #INITIALIZE SIGN TO POS.                  #
      LEADZEROS=0;           #NO LEADING ZEROS.                        #
  
# IDENTIFY LEADING ZEROS.                                              #
  
      P<SRFIELD>=SCURLOC; 
      GETBYTE=SCURBYTE; 
      FOR I=1 THRU SCURLENG DO
        BEGIN 
        CALL GETSRCHAR;      #GET CHAR FROM SOURCE.                    #
        IF CHAR NQ O"33" THEN          #YES - NOT ZERO.                #
          BEGIN 
          GETBYTE=GETBYTE-1;
          GOTO THRULEADZERO; #THRU WITH IDENTIFYING LEADING ZEROS.     #
          END 
        LEADZEROS=LEADZEROS+1;         #INCREMENT LEADING ZERO COUNT.  #
        END 
      RETURN;                #WHOLE SOURCE STRING HAS BEEN SCANNED. IN
                              THIS CASE, IT"S ALL ZEROS.               #
  
THRULEADZERO:                #LEADING ZEROS HAVE BEEN IDENTIFIED. NOW 
                              CONTINUE WITH REST OF SOURCE STRING.     #
      FOR J=I THRU SCURLENG DO
        BEGIN 
        CALL GETSRCHAR; 
  
# CHECK FOR LEGAL NUMERIC DIGITS "0" TO "9"                            #
  
        IF CHAR GQ O"33" AND CHAR LQ O"44" THEN  #YES - LEGAL NUMERIC. #
          TEST; 
  
# CHECK IF IT IS LAST DIGIT AND SIGN-OVER-PUNCH.                       #
  
        IF J EQ SCURLENG THEN          #YES - LAST DIGIT.              #
          BEGIN 
          IF CHAR EQ O"72" OR CHAR EQ O"66" THEN        #YES - SOP "0".#
            BEGIN 
            IF J EQ I THEN   #YES - BYTE RIGHT AFTER LEADING ZEROS.    #
              LEADZEROS=LEADZEROS+1;
            IF CHAR EQ O"66" THEN 
              SIGNPLUS=FALSE; 
            RETURN; 
            END 
          IF CHAR GQ O"01" AND CHAR LQ O"11" THEN       #YES - POS SOP.#
            RETURN; 
          IF CHAR GQ O"12" AND CHAR LQ O"22" THEN       #YES - NEG SOP.#
            BEGIN 
            SIGNPLUS=FALSE; 
            RETURN; 
            END 
          END 
  
        ERRCODE=O"664";      #ILLEGAL SOURCE STRING ERROR.             #
        GOTO CONV$EXIT;      #RETURN TO CALLER.                        #
        END 
      END 
      CONTROL EJECT;
  
      PROC CHECKCLS4;        #CHECK-SOURCE-CLASS4.                     #
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   CHECKCLS4 - CHECK SOURCE CLASS 4
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       VERIFY THAT SOURCE DATA IS LEGAL CLASS 4. 
* 
* DC  ENTRY CONDITIONS
*       SCURLOC  = SOURCE LOCATION. 
*       SCURBYTE = SOURCE BEGINNING BYTE POSITION.
*       SCURLENG = SOURCE LENGTH IN BYTES.
*       SRDECPOS = SOURCE DECIMAL PT POSITION.
*       SRXPLICD = TRUE IF SOURCE EXPLICITLY DECIMALED. 
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SIGNPLUS  = TRUE IF SOURCE DATA POS.
*         LEADZEROS = NUMBER OF LEADING ZEROS IN SOURCE. WILL INCLUDE 
*                     ONLY THE EXPLICIT LEADING ZEROS OF INTEGER PART.
*       ERROR:  
*         ERRCODE = O"664". 
* 
* DC  NON-LOCAL VARIABLES 
*       GETBYTE - PARAMETER FOR "GETSRCHAR". POSITION OF BYTE TO GET. 
*       CHAR    - SET BY "GETSRCHAR" TO VALUE OF CURRENT SOURCE BYTE. 
* 
* DC  CALLING ROUTINE 
*       MODULE "SRDFIXEDPT".
* 
* DC  CALLED ROUTINES 
*       GETSRCHAR - GET SOURCE CHARACTER. 
* 
* DC  DESCRIPTIONS
*       SCAN SOURCE DATA STRING CHAR BY CHAR AND VERIFY THAT IT CONTAINS
*     ONLY DISPLAY CODE 0 TO 9, WITH OPTIONAL DECIMAL PT AND LAST DIGIT 
*     SIGN-OVER-PUNCH IF SPECIFIED. IN CASE LAST DIGIT IS EXPLICIT
*     DECIMAL POINT, SIGN-OVER-PUNCH MAY BE AT 2ND LAST POSITION. 
*       SET "SIGNPLUS" AND "LEADZEROS" TO INDICATE SOURCE SIGN AND
*     NUMBER OF LEADING ZEROS. ("LEADZEROS" WILL ONLY INCLUDE THE 
*     EXPLICIT LEADING ZEROS OF THE INTEGER PART OF SOURCE.)
 #
  
  
      SIGNPLUS=TRUE;         #INITIALIZE TO INDICATE POS SIGN.         #
      LEADZEROS=0;           #INITIALIZE LEADING ZERO COUNT TO ZERO.   #
  
# IDENTIFY LEADING ZEROS.                                              #
  
      P<SRFIELD>=SCURLOC; 
      GETBYTE=SCURBYTE; 
      IF SRDECPOS GQ SCURLENG THEN     #DEC PT IS LEFT OF SOURCE.      #
        BEGIN 
        LEADZEROS=0;
        I=SCURLENG;          #SET "I" FOR LATER USE.                   #
        END 
      ELSE
        BEGIN 
        FOR I=SCURLENG STEP -1 UNTIL 1 DO 
          BEGIN 
          IF I EQ SRDECPOS THEN        #YES - ALL ZEROS BEFORE DEC PT. #
            BEGIN 
            IF SRXPLICD THEN           #YES - SOURCE EXPLICITLY DEC.   #
              BEGIN 
              ERRCODE=O"664";          #A "0" WAS WHERE "." SHOULD BE. #
              GOTO CONV$EXIT; 
              END 
            GOTO OVERLEADZERO;
            END 
          CALL GETSRCHAR; 
          IF CHAR NQ O"33" THEN 
            BEGIN 
            GETBYTE=GETBYTE-1;
            GOTO OVERLEADZERO;
            END 
          LEADZEROS=LEADZEROS+1;
          END 
        RETURN;              #SOURCE STRING IS ALL ZEROS.              #
        END 
  
OVERLEADZERO:                #DONE WITH IDENTIFYING LEADING ZEROS.     #
  
      FOR J=I STEP -1 UNTIL 1 DO
        BEGIN 
        CALL GETSRCHAR; 
  
# CHECK FOR EXPLICIT DECIMAL POINT.                                    #
  
        IF SRXPLICD THEN     #YES - SOURCE EXPLICITLY DECIMALED.       #
          BEGIN 
          IF SRDECPOS EQ (J-1) THEN    #YES - AT DECIMAL POSITION.     #
            BEGIN 
            IF CHAR EQ O"57" THEN      #YES - DECIMAL PT.              #
              TEST; 
            ELSE
              BEGIN 
              ERRCODE=O"664"; 
              GOTO CONV$EXIT; 
              END 
            END 
          END 
  
# CHECK FOR LEGAL NUMERIC DIGITS "0" TO "9".                           #
  
        IF CHAR GQ O"33" AND CHAR LQ O"44" THEN  #YES - LEGAL NUMERIC. #
          TEST; 
  
# CHECK IF IT IS LAST DIGIT AND SIGN-OVER-PUNCH.                       #
  
        IF J EQ 1 OR                   #YES - LAST BYTE IN SOURCE.     #
           (J EQ 2 AND SRDECPOS EQ 0 AND SRXPLICD) THEN 
                             #YES - LAST BYTE AHEAD OF DECIMAL.        #
          BEGIN 
          IF CHAR EQ O"72" OR CHAR EQ O"66" THEN        #YES - SOP "0".#
            BEGIN 
            IF J EQ I THEN   #YES - BYTE RIGHT AFTER LEADING ZEROS.    #
              LEADZEROS=LEADZEROS+1;
            IF CHAR EQ O"66" THEN 
              SIGNPLUS=FALSE; 
            TEST; 
            END 
          IF CHAR GQ O"01" AND CHAR LQ O"11" THEN       #YES - POS SOP.#
            TEST; 
          IF CHAR GQ O"12" AND CHAR LQ O"22" THEN       #YES - NEG SOP.#
            BEGIN 
            SIGNPLUS=FALSE; 
            TEST; 
            END 
          END 
  
        ERRCODE=O"664";      #ILLEGAL SOURCE STRING ERROR.             #
        GOTO CONV$EXIT; 
        END 
      END 
      CONTROL EJECT;
  
      PROC CMOVE(SLOC,SBYTE,MVLENG,TLOC,TBYTE); 
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   CMOVE - CHARACTER MOVE
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       MOVE A SPECIFIED LENGTH OF DATA STRING FROM ONE LOCATION/ 
*     POSITION TO ANOTHER.
* 
* DC  ENTRY CONDITIONS
*       PARAMETERS PASSED:  
*         SLOC   = SOURCE LOCATION. 
*         SBYTE  = SOURCE BEGINNING BYTE POSITION.
*         MVLENG = LENGTH TO BE MOVED IN BYTES. 
*         TLOC   = TARGET LOCATION. 
*         TBYTE  = TARGET BEGINNING BYTE POSITION.
* 
* DC  EXIT CONDITIONS 
*       DATA STRING MOVED TO TLOC/TBYTE, LENGTH "MVLENG". 
* 
* DC  NON-LOCAL VARIABLES 
*       BASED ARRAY "SRFIELD".
*       BASED ARRAY "TGFIELD".
* 
* DC  DESCRIPTIONS
*       IF "MVLENG" EQ 0, RETURN. 
*       BYTE BY BYTE, "MVLENG" CHARS WERE MOVED FROM SOURCE TO TARGET.
 #
  
  
      ITEM SLOC;             #SOURCE LOCATION.                         #
      ITEM SBYTE;            #SOURCE BYTE.                             #
      ITEM MVLENG;           #LENGTH OF STRING TO BE MOVED.            #
      ITEM TLOC;             #TARGET LOCATION.                         #
      ITEM TBYTE;            #TARGET BYTE.                             #
  
      ITEM LENGMVED;         #LENGTH MOVED SO FAR.                     #
      ITEM MVSRBYTE;         #CURRENT SOURCE BYTE TO BE MOVED.         #
      ITEM MVTGBYTE;         #CURRENT TARGET BYTE.                     #
  
      IF MVLENG LQ 0 THEN    #TRUE - NOTHING TO BE MOVED.              #
        RETURN; 
  
      P<SRFIELD>=SLOC;
      P<TGFIELD>=TLOC;
      LENGMVED=0; 
      MVSRBYTE=SBYTE; 
      MVTGBYTE=TBYTE; 
  
      FOR K=K WHILE LENGMVED LS MVLENG DO 
        BEGIN 
  
        FOR K=K WHILE MVSRBYTE GR 9 DO #UPDATE "SRFIELD" AND "MVSRBYTE"#
          BEGIN 
          MVSRBYTE=MVSRBYTE-10; 
          P<SRFIELD>=LOC(SRFIELD)+1;
          END 
        FOR K=K WHILE MVTGBYTE GR 9 DO
          BEGIN 
          MVTGBYTE=MVTGBYTE-10; 
          P<TGFIELD>=LOC(TGFIELD)+1;
          END 
  
        C<MVTGBYTE>TGCHAR[0]=C<MVSRBYTE>SRCHAR[0];    #MOVE CHAR.      #
  
        MVTGBYTE=MVTGBYTE+1;
        MVSRBYTE=MVSRBYTE+1;
        LENGMVED=LENGMVED+1;
        END 
  
      END 
      CONTROL EJECT;
  
      PROC MOVETOALNUM;      #MOVE TO ALPHANUMERIC TARGET.             #
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   MOVETOALNUM - MOVE TO ALPHANUMERIC TARGET 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       MOVE SOURCE DATA STRING TO ALPHANUMERIC TARGET FIELD, BLANK-
*     FILLING IF NECESSARY. 
* 
* DC  ENTRY CONDITIONS
*       SCURLOC  = SOURCE LOCATION. 
*       SCURBYTE = SOURCE BEGINNING BYTE POSITION.
*       SCURLENG = SOURCE LENGTH IN BYTES.
*       TCURLOC  = TARGET LOCATION. 
*       TCURBYTE = TARGET BEGINNING BYTE POSITION.
*       TCURLENG = TARGET LENGTH IN BYTES.
*       TGJRIGHT = TRUE IF TARGET JUSTIFIED RIGHT.
*       LENGDIFF = LENGTH BY WHICH TARGET BIGGER THAN SOURCE. 
* 
* DC  EXIT CONDITIONS 
*       SOURCE DATA MOVED TO TARGET, BLANK-FILLED IF NECESSARY. 
* 
* DC  CALLING ROUTINES
*       MODULE "ALNUMTOALNUM".
*       MODULE "DNUMTOALNUM". 
* 
* DC  CALLED ROUTINES 
*       CMOVE - CHARACTER MOVE. 
*       PADBLANKS - BLANK PADDING.
* 
* DC  DESCRIPTIONS
*       IF TARGET JUSTIFIED RIGHT, FILL TARGET WITH "LENGDIFF" NUMBER 
*     OF BLANKS ON LEFT, AND CALL "CMOVE" TO MOVE SOURCE DATA OVER
*     RIGHT JUSTIFIED. IF TARGET LEFT JUSTIFIED, MOVE SOURCE DATA OVER
*     LEFT JUSTIFIED AND FILL BLANKS ON RIGHT.
 #
  
  
      IF TGJRIGHT THEN       #YES - TARGET IS JUSTIFIED RIGHT.         #
        BEGIN 
        CALL PADBLANKS(LENGDIFF);      #LEFT-FILL WITH BLANKS.         #
        CALL CMOVE(SCURLOC,SCURBYTE,SCURLENG,TCURLOC,TCURBYTE+LENGDIFF);
        END 
      ELSE
        BEGIN 
        CALL CMOVE(SCURLOC,SCURBYTE,SCURLENG,TCURLOC,TCURBYTE); 
        TCURBYTE=TCURBYTE+SCURLENG;    #UPDATE FOR CALL TO "PADBLANKS".#
        CALL PADBLANKS(LENGDIFF); 
        END 
      END 
  
      CONTROL EJECT;
  
      PROC GETSRCHAR;        #GET-SOURCE-CHARACTER.                    #
  
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   GETSRCHAR - GET SOURCE CHARACTER
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       GET CURRENT CHAR BEING SCANNED FROM SOURCE. 
* 
* DC  ENTRY CONDITIONS
*       BASED ARRAY "SRFIELD" POINTS TO SOURCE DATA.
*       GETBYTE = CURRENT BYTE POSITION IN SOURCE WORD. 
* 
* DC  EXIT CONDITIONS 
*       CHAR = DISPLAY CODE VALUE OF CURRENT SOURCE CHAR. 
*       GETBYTE = BYTE POSITION OF NEXT CHAR TO BE SCANNED. 
*       P<SRFIELD> INCREMENTED BY 1 IF NECESSARY. 
* 
* DC  NON-LOCAL VARIABLES 
*       K - LOOP VARIABLE.
* 
* DC  CALLING ROUTINES
*       CHECKSRNUM - CHECK SOURCE NUMERIC.
*       CHECKCLS3 - CHECK SOURCE CHARS 3. 
*       CHECKCLS4 - CHECK SOURCE CLASS 4. 
*       CHECKSRALPHA - CHECK SOURCE ALPHABETIC. 
*       DISPLAYTOBIN - DISPLAY TO BINARY. 
* 
* DC  DESCRIPTIONS
*       IF "GETBYTE" GR 9, SET "SRFIELD" BASE TO NEXT WORD AND SET
*     "GETBYTE" TO 0. 
*       SET "CHAR" TO VALUE OF BYTE SPECIFIED BY "GETBYTE". 
*       INCREMENT "GETBYTE" BY 1. 
 #
  
  
      FOR K=0 WHILE GETBYTE GR 9 DO 
        BEGIN 
        GETBYTE=GETBYTE-10; 
        P<SRFIELD>=LOC(SRFIELD)+1;
        END 
      CHAR=C<GETBYTE>SRCHAR[0]; 
      GETBYTE=GETBYTE+1;
      END 
      CONTROL EJECT;
  
      PROC CHECKSRALPHA;               #CHECK-SOURCE-ALPHABETIC.       #
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   CHECKSRALPHA - CHECK SOURCE ALPHABETIC
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       CHECK IF SOURCE DATA STRING IS LEGAL ALPHABETIC.
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG CONTAINS SOURCE DATA STRING.
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SOURCE VERIFIED TO BE LEGAL ALPHABETIC. 
*       ERROR:  
*         ERRCODE = O"664". 
* 
* DC  NON-LOCAL VARIABLES 
*       BASED ARRAY "SRFIELD".
*       GETBYTE - PARAMETER FOR "GETSRCHAR". POSITION OF BYTE TO GET. 
*       CHAR - SET BY "GETSRCHAR" TO VALUE OF CURRENT SOURCE BYTE.
*       I - LOOP VARIABLE.
* 
* DC  CALLING ROUTINE 
*       MODULE "ALNUMTOALPHA".
* 
* DC  CALLED ROUTINES 
*       GETSRCHAR - GET SOURCE CHARACTER. 
* 
* DC  DESCRIPTIONS
*       CHAR BY CHAR, THE SOURCE DATA STRING IS CHECKED FOR DEPARTURE 
*     FROM DISPLAY CODE 01 THRU 32 AND 55. ERROR EXIT WITH CODE 664 
*     IF SUCH DEPARTURE IS DETECTED.
 #
  
  
      P<SRFIELD>=SCURLOC; 
      GETBYTE=SCURBYTE; 
      FOR I=1 THRU SCURLENG DO
        BEGIN 
        CALL GETSRCHAR; 
        IF CHAR LS O"01" OR (CHAR GR O"32" AND CHAR NQ O"55") THEN
                             #TRUE - CHAR NON ALPHABET AND NON BLANK.  #
          BEGIN 
          ERRCODE=O"664"; 
  
          GOTO CONV$EXIT;              #EXIT RETURN TO CALLING PRGM.   #
          END 
        END 
      END 
      CONTROL EJECT;
  
      PROC TG4INITIAL;       #TARGET CLASS 4 INITIALIZATION.           #
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   TG4INITIAL - TARGET CLASS 4 INITIALIZATION
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       STUDY DISPLAY FIXED PT TARGET (CLASS 4) FORMAT AND SET ITEMS
*     DESCRIBING IT FOR LATER USE.
* 
* DC  ENTRY CONDITIONS
*       TCURLENG = TARGET LENGTH IN BYTES.
*       TGDECPOS = TARGET DECIMAL PT POSITION.
*       TGXPLICD = TRUE IF TARGET EXPLICITLY DECIMALED. 
* 
* DC  EXIT CONDITIONS 
*       TSGNTLEN = COUNT OF SIGNIFICANT DIGITS IN TARGET. 
*       TDECLEN = COUNT OF DECIMAL DIGITS IN TARGET.
*       TASMRIGHT = COUNT OF ASSUMED RIGHT ZEROS IN TARGET. 
*       TASMLEFT = COUNT OF ASSUMED LEFT ZEROS IN TARGET. 
* 
* DC  CALLING ROUTINES
*       MODULE "DFXPTTODFXPT".
* 
* DC  DESCRIPTIONS
*       BASED ON TARGET FORMAT DESCRIPTION, "TSGNTLEN", "TDECLEN",
*     "TASMRIGHT", AND "TASMLEFT" ARE SET.
 #
  
  
      TSGNTLEN=0;            #TARGET EXPLICIT SIGNIFICANT DIGIT COUNT. #
      TDECLEN=0;             #TARGET EXPLICIT DECIMAL DIGIT COUNT.     #
      TASMRIGHT=0;           #TARGET ASSUMED RIGHT ZERO COUNT.         #
      TASMLEFT=0;            #TARGET ASSUMED LEFT ZERO COUNT.          #
  
      IF TGDECPOS LS 0 THEN 
        BEGIN 
        TASMRIGHT=-TGDECPOS;
        TSGNTLEN=TCURLENG;
        END 
      ELSE
        BEGIN 
        IF TGDECPOS GR TCURLENG THEN
          BEGIN 
          TASMLEFT=TGDECPOS-TCURLENG; 
          TDECLEN=TCURLENG; 
          END 
        ELSE                 # 0 .LQ. TGDECPOS .LQ. TCURLENG.          #
          BEGIN 
          TDECLEN=TGDECPOS; 
          IF TGXPLICD THEN
            TSGNTLEN=TCURLENG-TDECLEN-1;
          ELSE
            TSGNTLEN=TCURLENG-TDECLEN;
          END 
        END 
      END 
  
      CONTROL EJECT;
  
      PROC PADBLANKS(LENG); 
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   PADBLANKS - PAD BLANKS
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       PAD TARGET WITH SPECIFIED LENGTH OF BLANKS. 
* 
* DC  ENTRY CONDITIONS
*       PARAMETER PASSED: 
*         LENG - LENGTH OF DESIRED STRING OF BLANKS.
*       TCURLOC = TARGET LOCATION.
*       TCURBYTE = TARGET BEGINNING BYTE POSITION.
* 
* DC  EXIT CONDITIONS 
*       STARTING AT "TCURBYTE", TARGET IS PADDED WITH "LENG" BLANKS.
* 
* DC  NON-LOCAL VARIABLES 
*       BASED ARRAY "TGFIELD".
*       I - LOOP VARIABLE.
*       L - LOOP VARIABLE.
* 
* DC  CALLING ROUTINES
*       MOVETOALNUM - MOVE TO ALPHANUMERIC TARGET.
* 
* DC  DESCRIPTIONS
*       BYTE BY BYTE, TARGET IS FILLED WITH BLANKS STARTING AT
*     "TCURBYTE" BYTE POSITION, AND FOR A LENGTH OF "LENG". 
 #
  
  
      ITEM LENG;             #LENGTH OF DESIRED BLANK STRING.          #
  
      ITEM BYTEPOS;          #BYTE POSITION FOR BLANK-FILLING.         #
  
      BYTEPOS=TCURBYTE; 
      P<TGFIELD>=TCURLOC; 
  
      FOR L=LENG STEP -1 UNTIL 1 DO 
        BEGIN 
        FOR I=0 WHILE BYTEPOS GR 9 DO 
          BEGIN 
          P<TGFIELD>=LOC(TGFIELD)+1;
          BYTEPOS=BYTEPOS-10; 
          END 
        C<BYTEPOS>TGCHAR[0]=O"55";
        BYTEPOS=BYTEPOS+1;
        END 
      END 
  
      CONTROL EJECT;
  
      PROC SGNTSRLENGTH;     #SIGNIFICANT-SOURCE-LENGTH.               #
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   SGNTSRLENGTH - SIGNIFICANT SOURCE LENGTH
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       UPDATE SOURCE LENGTH BY EXCLUDING TRAILING BLANKS.
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG CONTAINS DATA THAT MAY HAVE TRAILING
*     BLANKS. 
* 
* DC  EXIT CONDITIONS 
*       SCURLENG UPDATED TO EXCLUDE TRAILING BLANKS.
* 
* DC  NON-LOCAL VARIABLES 
*       BASED ARRAY "SRFIELD".
*       I - LOOP VARIABLE.
*       J - SCRATCH ITEM. 
*       L - SCRATCH ITEM. 
* 
* DC  CALLING ROUTINES
*       MODULE "SRALPHANUM".
*       MODULE "SRALPHABET".
* 
* DC  CALLED ROUTINES 
*       IGNOREBLANKS - IGNORE BLANKS. 
* 
* DC  DESCRIPTIONS
*       CHAR BY CHAR, THE SOURCE STRING IS CHECKED FOR BLANK. IF A
*     BLANK IS REACHED, CHECK IF REST OF STRING IS ALL BLANKS. IF YES,
*     SET "TCURLENG" TO ONLY INCLUDE UP TO LAST NON-BLANK. IF NO, 
*     RESUME CHECKING AT NEXT NON-BLANK. REPEAT PROCESS UNTIL END OF
*     STRING IS REACHED.
 #
  
  
      ITEM CHKBYTE;          #IDENTIFIES CURRENTLY SCANNED BYTE.       #
      P<SRFIELD>=SCURLOC; 
      CHKBYTE=SCURBYTE;      #REPRESENTS CURRENTLY SCANNED BYTE.       #
      FOR I=SCURLENG STEP -1 WHILE I GQ 1 DO
        BEGIN 
        IF CHKBYTE GR 9 THEN
          BEGIN 
          P<SRFIELD>=LOC(SRFIELD)+1;
          CHKBYTE=CHKBYTE-10; 
          END 
        IF C<CHKBYTE>SRCHAR[0] EQ O"55" THEN     #YES - BLANK.         #
          BEGIN 
          J=LOC(SRFIELD); 
          L=I-1;
          CHKBYTE=CHKBYTE+1;
          CALL IGNOREBLANKS(J,CHKBYTE,L);  #CHECK REMAINING ALL BLANKS.#
          IF L EQ 0 THEN               #YES - REMAINING IS ALL BLANKS. #
            BEGIN 
            SCURLENG=SCURLENG-I;       #UPDATE "SCURLENG".             #
            RETURN; 
            END 
          ELSE               #RESTART SCANNING AT FIRST NON-BLANK.     #
            BEGIN 
            P<SRFIELD>=J; 
            I=L+1;
            END 
          END 
        ELSE
          CHKBYTE=CHKBYTE+1;
        END 
      END 
      CONTROL EJECT;
  
      PROC IGNOREBLANKS(LOCN,BYTE,LENG);
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   IGNOREBLANKS - IGNORE BLANKS
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       STARTING AT LOCATION AND BYTE SPECIFIED, IDENTIFY BLANK STRING, 
*     AND UPDATE PARAMETERS TO INDICATE NEXT NON-BLANK. 
* 
* DC  ENTRY CONDITIONS
*       PARAMETERS PASSED:  
*         LOCN = LOCATION STARTING WHERE CHECKING IS TO BE DONE.
*         BYTE = BYTE POSITION AT WHICH CHECKING IS TO START. 
*         LENG = LENGTH IN CHARS OF STRING TO BE CHECKED. 
* 
* DC  EXIT CONDITIONS 
*       LOCN = LOCATION LAST SCANNED. 
*       BYTE = BYTE POSITION LAST SCANNED TO BE NON-BLANK.
*       LENG = STARTING AT NON-BLANK BYTE LAST SCANNED, LENGTH OF STRING
*              LEFT THAT NEEDS TO BE SCANNED. 
* 
* DC  NON-LOCAL VARIABLES 
*       BASED ARRAY "TGFIELD".
*       K - LOOP VARIABLE.
* 
* DC  CALLING ROUTINES
*       MODULE "SRALPHANUM".
*       MODULE "SRALPHABET".
*       CHECKSRNUM - CHECK SOURCE NUMERIC.
*       SGNTSRLENGTH - SIGNIFICANT SOURCE LENGTH. 
* 
* DC  DESCRIPTIONS
*       STARTING AT LOCATION AND BYTE POSITION SPECIFIED, CHECK FOR 
*     FIRST NON-BLANK, AND SET "LOCN" AND "BYTE" TO POINT TO IT, AND
*     SET "LENG" TO INDICATE LENGTH OF STRING REMAINING STARTING AT 
*     THAT NON-BLANK. IF STRING EXHAUSTED WITH NO NON-BLANK DETECTED, 
*     SET "LENG" TO 0.
 #
  
  
      ITEM LOCN;
      ITEM BYTE;
      ITEM LENG;
      P<TGFIELD>=LOCN;
      FOR K=1 THRU LENG DO
        BEGIN 
        IF BYTE GR 9 THEN 
          BEGIN 
          P<TGFIELD>=LOC(TGFIELD)+1;
          BYTE=BYTE-10; 
          END 
        IF C<BYTE>TGCHAR[0] NQ O"55" THEN        #YES - NONBLANK.      #
          BEGIN 
          LOCN=LOC(TGFIELD);           #SET PARAMETERS.                #
          LENG=LENG-K+1;
          RETURN; 
          END 
        BYTE=BYTE+1;
        END 
      LENG=0;                #FALL THRU LOOP - STRING IS ALL BLANK.    #
      LOCN=LOC(TGFIELD);
      END 
      CONTROL EJECT;
  
      PROC CHECKALLZERO(LOCN,BYTE,LENG);         #CHECK-ALL-ZEROS.     #
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   CHECKALLZERO - CHECK ALL ZEROS
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       CHECK THAT SPECIFIED STRING CONTAINS ALL DISPLAY CODE ZEROS.
* 
* DC  ENTRY CONDITIONS
*       PARAMETERS PASSED:  
*         LOCN = LOCATION STARTING WHERE CHECKING IS TO BE DONE.
*         BYTE = BYTE POSITION AT WHICH CHECKING IS TO START. 
*         LENG = LENGTH IN CHARS OF STRING TO BE CHECKED. 
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         SPECIFIED STRING VERIFIED TO BE ALL DISPLAY CODE ZEROS. 
*       ERROR:  
*         ERRCODE = O"666". 
* 
* DC  NON-LOCAL VARIABLES 
*       BASED ARRAY "TGFIELD".
*       K - LOOP VARIABLE.
* 
* DC  CALLING ROUTINES
*       MODULE "DFXPTTODFXPT".
* 
* DC  DESCRIPTIONS
*       STARTING AT LOCATION AND BYTE POSITION SPECIFIED, CHECK BYTE BY 
*     BYTE FOR NON-ZERO UNTIL SPECIFIED LENGTH EXHAUSTED. IF NON-ZERO 
*     DETECTED, ERROR EXIT WITH CODE 666. 
 #
  
  
      ITEM LOCN;             #LOCATION AT WHICH CHECKING IS TO BE DONE.#
      ITEM BYTE;             #BYTE AT WHICH CHECKING IS TO START.      #
      ITEM LENG;             #LENGTH IN BYTES TO BE CHECKED.           #
      ITEM CHKBYTE;          #BYTE CURRENTLY CHECKING.                 #
      CHKBYTE=BYTE; 
      P<TGFIELD>=LOCN;
      FOR K=1 THRU LENG DO
        BEGIN 
        IF CHKBYTE GR 9 THEN
          BEGIN 
          P<TGFIELD>=LOC(TGFIELD)+1;
          CHKBYTE=CHKBYTE-10; 
          END 
        IF C<CHKBYTE>TGCHAR[0] NQ O"33" THEN     #YES - NONZERO.       #
          BEGIN 
          ERRCODE=O"666";    #LOSS OF SIGNIFICANT DIGITS.              #
          GOTO CONV$EXIT; 
          END 
        CHKBYTE=CHKBYTE+1;
        END 
      END 
      CONTROL EJECT;
  
      PROC ROUND(POS);
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   ROUND - PERFORM ROUNDING OF DATA
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       ROUND DATA IN "INTERBUF" AT POSITION SPECIFIED. "INTERBUF" IS 
*     A 20 CHAR CONVERSION ROUTINE INTERNAL BUFFER. 
* 
* DC  ENTRY CONDITIONS
*       PARAMETER PASSED: 
*         POS - BYTE POSITION IN "INTERBUF" WHERE ROUNDING TO BE DONE.
*       "INTERBUF" CONTAINS DISPLAY CODE NUMERIC STRING.
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*         DATA STRING IN "INTERBUF" ROUNDED.
*       ERROR:  
*         ERRCODE = O"666". 
* 
* DC  NON-LOCAL VARIABLES 
*       CHAR - VALUE OF CURRENTLY SCANNED CHAR IN "INTERBUF". 
*       K - LOOP VARIABLE.
* 
* DC  CALLING ROUTINES
*       MODULE "ALNUMTODNUM"/"DNUMTODNUM".
*       MODULE "DFXPTTODFXPT".
* 
* DC  DESCRIPTIONS
*       EXAMINE BYTE "POS" IN "INTERBUF". IF LESS THAN DISPLAY CODE 5,
*     NO ROUNDING NEEDED AND EXIT, OTHERWISE CONTINUE.
*       ADD 1 TO BYTE ("POS"-1), CARRY OVER TO THE NEXT BYTE IF 
*     NECESSARY. CONTINUE WITH THE CARRY OVER UNTIL IT STOPS. IF THIS 
*     RESULT IN "INTERBUF" OVERFLOW (WHEN ALL DIGITS ORIGINALLY 9"S), 
*     ERROR EXIT WITH CODE 666. IF DECIMAL PT HIT DURING PROCESS, 
*     SKIP OVER IT. 
 #
  
  
      ITEM POS; 
      IF C<POS>INTERBUF LS O"40" THEN      # < "5". NO ROUNDING NEEDED.#
        RETURN; 
      FOR K=(POS-1) STEP -1 UNTIL 0 DO
        BEGIN 
        CHAR=C<K>INTERBUF;
        IF CHAR EQ O"57" THEN          #YES - DECIMAL POINT.           #
          TEST;              #CONTINUE WITH NEXT DIGIT.                #
        CHAR=CHAR+1;
        IF CHAR LQ O"44" THEN          #ROUNDING PROCESS FINISHED.     #
          BEGIN 
          C<K>INTERBUF=CHAR;
          RETURN; 
          END 
        C<K>INTERBUF=O"33"; 
        END 
  
# IF LOOP FALLS THRU, TARGET SIZE NOT LARGE ENOUGH FOR ROUNDED RESULT. #
  
      ERRCODE=O"666";        #LOSS OF SIGNIFICANCE.                    #
      GOTO CONV$EXIT; 
      END 
      CONTROL EJECT;
  
      PROC STORESOP(POS);              #STORE SIGN-OVER-PUNCH.         #
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   STORESOP - STORE SIGN OVER PUNCH
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       ADD SIGN-OVER-PUNCH TO DATA STRING IN "INTERBUF" AT POSITION
*     SPECIFIED, IF TARGET IS TO BE SIGNED. 
* 
* DC  ENTRY CONDITIONS
*       PARAMETER PASSED: 
*         POS = POSITION IN "INTERBUF" THAT SOP IS TO BE ADDED. 
*       SIGNPLUS = TRUE IF DATA IS POS. 
*       TGSIGNED = TRUE IF TARGET IS TO BE SIGNED.
*       "INTERBUF" CONTAINS DISPLAY CODE NUMERIC STRING.
* 
* DC  EXIT CONDITIONS 
*       SIGN-OVER-PUNCH ADDED TO DATA STRING IN "INTERBUF" AT POSITION
*     SPECIFIED, IF TARGET IS TO BE SIGNED. 
* 
* DC  NON-LOCAL VARIABLES 
*       CHAR - VALUE OF CURRENT BYTE IN "INTERBUF" STRING.
*       K - SCRATCH ITEM. 
* 
* DC  CALLING ROUTINES
*       MODULE "ALNUMTODNUM"/"DNUMTODNUM".
*       MODULE "DFXPTTODNUM". 
*       MODULE "DFXPTTODFXPT".
* 
* DC  DESCRIPTIONS
*       IF TARGET IS NOT TO BE SIGNED, EXIT.
*       AT POSITION SPECIFIED IN "INTERBUF", CHECK VALUE OF THE DIGIT,
*     AND SET IT TO APPROPRIATE VALUE TO INDICATE SIGN-OVER-PUNCH AS
*     GIVEN BY "SIGNPLUS".
*       IF POSITION SPECIFIED IS DECIMAL POINT, STORE SOP AT POSITION 
*     ("POS"-1). IF LENGTH OF STRING IS 1, AND IT CONTAINS THIS DECIMAL 
*     PT, JUST EXIT.
 #
  
  
      ITEM POS; 
      IF NOT TGSIGNED THEN
        RETURN; 
      K=POS;
      IF K LS 0 THEN
        RETURN; 
      IF C<K>INTERBUF EQ O"57" THEN 
        BEGIN 
        K=K-1;
        IF K LS 0 THEN
          RETURN; 
        END 
      CHAR=C<K>INTERBUF;
      IF CHAR EQ O"33" THEN            #YES - NUMERIC "0".             #
        BEGIN 
        IF SIGNPLUS THEN
          C<K>INTERBUF=O"72"; 
        ELSE
          C<K>INTERBUF=O"66"; 
        END 
      ELSE
        BEGIN 
        IF CHAR LQ O"44" AND CHAR GQ O"34" THEN  #YES - NUMERIC 1 - 9. #
          BEGIN 
          IF SIGNPLUS THEN
            C<K>INTERBUF=CHAR-O"33";             #POS SOP.             #
          ELSE
            C<K>INTERBUF=CHAR-O"22";             #NEG SOP.             #
          END 
        END                  #IF NONE OF ABOVE, MUST BE SOP ALREADY.   #
      END 
      CONTROL EJECT;
  
      PROC EXTRACTSOP(POS);            #EXTRACT SIGN-OVER-PUNCH.       #
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   EXTRACTSOP - EXTRACT SIGN OVER PUNCH
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       REPLACE SIGN OVER PUNCH DIGIT AT SPECIFIED POSITION WITH THE
*     DIGIT VALUE WITHOUT THE SOP.
* 
* DC  ENTRY CONDITIONS
*       PARAMETER PASSED: 
*         POS - BYTE POSITION IN "INTERBUF" THAT SOP IS TO BE EXTRACTED.
*       "INTERBUF" CONTAINS DISPLAY CODE NUMERIC CHARS. 
* 
* DC  NON-LOCAL VARIABLES 
*       CHAR - VALUE OF CURRENT BYTE IN "INTERBUF" STRING.
*       K - SCRATCH ITEM. 
* 
* DC  CALLING ROUTINES
*       MODULE "ALNUMTODNUM"/"DNUMTODNUM".
*       MODULE "DFXPTTODNUM". 
*       MODULE "DFXPTTODFXPT".
* 
* DC  DESCRIPTIONS
*       IF POSITION SPECIFIED LESS THAN 0, EXIT.
*       IF BYTE AT POSITION SPECIFIED IS A DECIMAL PT, CHECK BYTE BEFORE
*     IT. 
*       IF BYTE AT POSITION SPECIFIED IS SOP, REPLACE IT WITH THE DIGIT 
*     VALUE WITHOUT SOP.
 #
  
  
      ITEM POS;              #BYTE POSITION IN "INTERBUF" THAT WILL 
                              BE EXAMINED FOR S-O-P.                   #
      K=POS;
      IF K LS 0 THEN
        RETURN; 
      IF C<K>INTERBUF EQ O"57" THEN              #YES - DECIMAL PT.    #
        BEGIN 
        K=K-1;               #WE WILL EXAMINE THE CHAR BEFORE DEC PT.  #
        IF K LS 0 THEN
          RETURN; 
        END 
      CHAR=C<K>INTERBUF;
      IF CHAR GR O"44" THEN  #YES - SOP "0". SINCE STRING IS LEGAL
                                    NUMERIC AND DEC PT HAS BEEN IDENT. #
        C<K>INTERBUF=O"33";            #REPLACE WITH NUMERIC "0".      #
      ELSE
        BEGIN 
        IF CHAR LQ O"11" THEN                    #YES - POS SOP.       #
          C<K>INTERBUF=CHAR+O"33";
        ELSE
          BEGIN 
          IF CHAR LQ O"22" THEN                  #YES - NEG SOP.       #
            C<K>INTERBUF=CHAR+O"22";
          END 
        END 
      END 
      CONTROL EJECT;
  
      PROC UNORMFLOAT;       #UNNORMALIZE FLOATING PT "RI" WITH 
                              SCALING FACTOR "I".                      #
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   UNORMFLOAT - UNNORMALIZE FLOATING PT NUMBER 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       CONVERT A FLOATING PT NUMBER TO AN UNNORMALIZED FLOATING PT 
*     IF TARGET IS CLASS 12 OR TO A BINARY INTEGER IF TARGET IS 
*     CLASS 10. 
* 
* DC  ENTRY CONDITIONS
*       "DC$FTOF" HAS JUST BEEN CALLED. 
*       TCURLOC = TARGET LOCATION.
*       TGCLASS = TARGET CLASS
* 
* DC  EXIT CONDITIONS 
*       NORMAL: 
*     DATA CONVERTED TO INTEGER OR UNNORMALIZED FLOATING PT 
*     AND MOVED TO TARGET.
*       ERROR:  
*         ERRCODE = O"666" OR THAT DETECTED BY DC$FTOF. 
* 
* DC  NON-LOCAL VARIABLES 
*       DC$CMBF 
*         SINGLE - FLOATING PT NUMBER TO BE CONVERTED.
*       I - SCRATCH VARIABLE. 
*       RI - SCRATCH VARIABLE.
*       BASED ARRAY "TGFIELD".
* 
* DC  CALLING ROUTINES
*       MODULE "UNORMTOUNORM".
*       MODULE "NORMTOUNORM". 
*       MODULE "DOUBLTOUNORM".
* 
* DC  DESCRIPTIONS
*       CHECK IF "DC$FTOF" RETURNS ERROR. IF SO, SET "ERRCODE" AND
*     EXIT, ELSE CONTINUE. VALUE TO BE CONVERTED IS "SINGLE". 
*       ROUND THE VALUE TO NEAREST INTEGER, AND CHECK IF IT CAN FIT 
*     INTO 48 BITS BY COMPARING IT TO O"7777777777777777". IF IT CANNOT 
*     BE, ERROR EXIT WITH CODE 666. 
*       IF TARGET IS CLASS 12, PACK IT WITH EXPONENT O"2000". 
*       MOVE TO TARGET, COMPLIMENT IF NEG.
 #
  
  
      IF RETURNC NQ 0 THEN   #YES - DC$FTOF DETECTS ERROR.             #
        BEGIN 
        ERRCODE=RETURNC;
        GOTO CONV$EXIT; 
        END 
      RI=ABS(SINGLE)+0.5;    #ROUND THE NUMBER.                        #
      IF RI GR O"00007777777777777777" THEN 
        BEGIN 
        ERRCODE=O"666";      #LOSS OF SIGNIFICANT DIGITS.              #
        GOTO CONV$EXIT; 
        END 
      P<TGFIELD>=TCURLOC; 
      TGINTEGER[0] = RI;     #CONVERT TO INTEGER                       #
      IF TGCLASS EQ 12 THEN  #PACK WITH O"2000" EXP.                   #
        TGINTEGER[0] = O"20000000000000000000"+TGINTEGER[0];
      IF SINGLE LS 0 THEN    #YES - NEGATIVE VALUE.                    #
        TGINTEGER[0] = -TGINTEGER[0]; 
      END 
      CONTROL EJECT;
  
      PROC DISPLAYTOBIN;     #DISPLAY TO BINARY.                       #
      BEGIN 
  
 #
  *   DC$CONV                                    PAGE 1 
  *   DISPLAYTOBIN - DISPLAY TO BINARY CONVERSION 
* *   C C CHOW      6/15/74 
* 
* DC  PURPOSE 
*       CONVERT A DISPLAY CODE NUMERIC STRING TO 108 BIT BINARY INTEGER.
* 
* DC  ENTRY CONDITIONS
*       SCURLOC/SCURBYTE/SCURLENG CONTAINS DISPLAY CODE NUMERIC STRING. 
*       SIGNPLUS = TRUE IF DATA POS.
*       SRCLASS = SOURCE CLASS. 
*       SRDECPOS = SOURCE DECIMAL POSITION IF SOURCE CLASS 4. 
*       SGNTDIGITS = COUNT OF SOURCE SIGNIFICANT DIGITS.
*       LEADZEROS = COUNT OF SOURCE LEADING ZEROS.
* 
* DC  EXIT CONDITIONS 
*       DC$CMBF 
*         UPINT = UPPER 54 BITS OF 108 BIT INTEGER. 
*         LOWINT = LOWER 54 BITS OF 108 BIT INTEGER.
*         EXPONEN = NEG POWER OF 10 FOR THE BINARY INTEGER MAGNITUDE. 
*         SIGN = 0 IF POS, COMPLEMENT OF 0 IF NEG.
* 
* DC  NON-LOCAL VARIABLES 
*       DECIMALED - TO INDICATE THAT DECIMAL PT HAS BEEN SCANNED. 
*       DECDIGITS - COUNT OF DEC DIGITS SCANNED. FOR SETTING "EXPONEN". 
*       CHAR - TO HOLD VALUE OF DIGIT CURRENTLY SCANNING. 
*       I - LOOP VARIABLE.
*       J - SCRATCH ITEM. 
*       K - SCRATCH ITEM. 
* 
* DC  CALLING ROUTINES
*       MODULE "DNUMTOUNORM"/"DFXPTTOUNORM".
*       MODULE "DNUMTONORM"/"DFXPTTONORM".
*       MODULE "DNUMTODOUBL"/"DFXPTTODOUBL".
* 
* DC  DESCRIPTIONS
*       THIS PROC CONVERTS A DISPLAY CODE NUMERIC STRING INTO AN 108
*     BIT BINARY INTEGER, STORED IN THE LOWER 54 BITS OF 2 WORDS, 
*     "UPINT" AND "LOWINT". "EXPONEN" WILL KEEP TRACK OF THE MAGNITUDE
*     OF THIS BINARY INTEGER IN POWER OF 10. "SIGN" WILL SHOW THE SIGN
*     OF THE NUMBER.
*       THE CONVERSION IS DONE BY CONVERTING THE SOURCE NUMERIC STRING
*     DIGIT BY DIGIT, STARTING WITH THE LEFTMOST ONE. THE CONVERTING
*     VALUE IS STORED INTO "LOWINT". AS MORE AND MORE DIGITS ARE
*     CONVERTED, VALUE IN "LOWINT" INCREASES. AS THE VALUE IN "LOWINT"
*     GETS LARGER THAN 54 BITS, THE MORE SIGNIFICANT BITS WILL BE SAVED 
*     IN "UPINT", AND PROCESS CONTINUES. THE NUMBER OF DECIMAL DIGITS 
*     INVOLVED IN THE CONVERSION IS NOTED, SO THAT AT END OF CONVERSION,
*     "EXPONEN" COULD BE SET TO INDICATE POWER OF 10 MAGNITUDE. IF THE
*     54 BITS IN "UPINT" OVERFLOW, CONVERSION WILL STOP, AND "EXPONEN"
*     WILL BE SET TO INDICATE APPROPRIATE MAGNITUDE OF THE NUMBER.
 #
  
  
# INITIALIZE...                                                        #
  
      DECIMALED=FALSE;       #INDICATES IF DECIMAL PT HAS BEEN SCANNED.#
      DECDIGITS=0;           #DECIMAL DIGITS.                          #
      UPINT=0;               #UPPER 54 BITS OF DESIRED 108 BIT BINARY. #
      LOWINT=0;              #LOWER 54 BITS OF DESIRED 108 BIT BINARY. #
  
      P<SRFIELD>=SCURLOC; 
      GETBYTE=SCURBYTE+LEADZEROS;      #SKIP LEADING ZEROS.            #
  
      FOR I=LEADZEROS+1 THRU SCURLENG DO
        BEGIN 
        CALL GETSRCHAR;      #GET SOURCE CURRENT CHAR.                 #
        IF CHAR LS O"33" OR CHAR GR O"44" THEN   #TRUE - NOT NUMERIC.  #
          BEGIN 
          IF CHAR EQ O"57" THEN        #TRUE - DECIMAL POINT.          #
            BEGIN 
            DECIMALED=TRUE; 
            TEST; 
            END 
          IF CHAR GR O"11" THEN        #TRUE - NOT POS SOP 1 THRU 9.   #
            BEGIN 
            IF CHAR LQ O"22" THEN      #TRUE -MUST BE NEG SOP 1 THRU 9.#
              CHAR=CHAR-O"11";
            ELSE             #MUST BE EITHER POS OR NEG SOP 0.         #
              CHAR=0; 
            END 
          END 
        ELSE                 #CHAR IS NUMERIC DISPLAY CODE.            #
          CHAR=CHAR-O"33";
  
        J=LOWINT*10+CHAR;    #ADD CURRENT CHAR TO BINARY INTEGER.      #
                             #SCRATCH ITEM J REPRESENTS UPDATED LOWINT.#
        IF B<0,6>J NQ 0 THEN #TRUE - MORE THAN 54 BITS IN BINARY.      #
          BEGIN 
          K=UPINT*10;        #SCRATCH ITEM K REPRESENTS UPDATED UPINT. #
          K=K+B<0,6>J;
          IF B<0,6>K NQ 0 THEN         #TRUE - 108 BIT BINARY OVERFLOW.#
                                       #QUIT. SIGNIFICANCE UPTO CURRENT#
                                       #DIGIT.                         #
            BEGIN            #SET "EXPONEN" TO NEG POWER OF 10.        #
            IF DECIMALED THEN 
              EXPONEN=DECDIGITS;
            ELSE
              EXPONEN=I-SGNTDIGITS+1-LEADZEROS; 
            GOTO SETSIGN; 
            END 
          B<0,6>J=0;
          UPINT=K;
          END 
        LOWINT=J; 
        IF DECIMALED THEN 
          DECDIGITS=DECDIGITS+1;
        END 
  
#SET "EXPONEN" TO INDICATE NEG POWER OF 10.                            #
  
      IF SRCLASS EQ 4 THEN
        EXPONEN=SRDECPOS; 
      ELSE
        EXPONEN=DECDIGITS;
  
SETSIGN:                     #SET "SIGN" FOR LATER CONVERSION USE.     #
      IF SIGNPLUS THEN
        SIGN=0; 
      ELSE
        SIGN=LNO(0);
  
# COMPLIMENT "EXPONEN" FOR CALL TO "DC$BTOF".                          #
  
      EXPONEN=-EXPONEN; 
  
      END 
  
  
  
      END  #DC$CONV#
      TERM
