*DECK CBCKCNV;
USETEXT TSBP2CM 
      PROC CBCKCNV; 
      BEGIN 
  
# EXTERNAL REFERENCES#
      XREF PROC CBERROR;       #ERROR HANDLER#
  
      CONTROL EJECT;
 #
      A SINGLE DIMENSIONED ARRARY IS USED TO DETERMINE CONVERSION 
      LEGALITY.  THIS IS POSSIBLE BECAUSE CONVERSION IS SYMMETRIC.
      THE DIMENSION OF THE ARRAY REPRESENT THE CLASS OF THE FROM
      ITEM, AND THE BITS OF THE ITEM IN THAT DIMENSION REPRESENT
      THE CLASS OF THE TO ITEM.  IF THE BIT IS SET THEN THE CONVER- 
      SION IS LEGAL.
 #
  
      ARRAY [0:20];                # SPACE ALLOWED FOR 21 CLASSES      #
        ITEM LEGALITY     U(00,00,21) = [ 
  
                             O"6400000",    # CLASS 0                  #
                             O"6000000",    # CLASS 1                  #
                             0, 
                             O"4602304",    # CLASS 3                  #
                             O"0602304",    # CLASS 4                  #
                             0, 
                             0, 
                             0, 
                             0, 
                             0, 
                             O"0602354",    # CLASS 10                 #
                             0, 
                             0, 
                             O"0602344",    # CLASS 13                 #
                             O"0602344",    # CLASS 14                 #
                             O"0002344",    # CLASS 15                 #
                             0, 
                             O"0002010",    # CLASS 17                 #
                             O"0602344",    # CLASS 18                 #
                             0, 
                             0 ]; 
  
  
      IF B<SCITEMCLASS[SCITEMOFFSET]> 
        LEGALITY[SBITMDBCLASS[SSITEMOFFSET]]
      EQ 0
      THEN
# IF THE CONVERSION ARRAY SAYS THE CONVERSION IS ILLEGAL, IT IS STILL#
# LEGAL IF THERE IS AN ENCODE AND A DECODE DB PROC FOR CONVERSION#
        BEGIN 
        IF SBITMTYPE[SSITEMOFFSET] EQ 0 OR
          SBITMTYPE[SSITEMOFFSET] EQ 2 OR 
          SBITMTYPE[SSITEMOFFSET] EQ 3 OR 
          SBITMTYPE[SSITEMOFFSET] EQ 6 THEN 
            RETURN; 
        IF SCITMENCDPTR[SCITEMOFFSET] EQ 0 THEN 
          GOTO ERROR; 
        ADDRESS = SCITEMOFFSET+SCITMENCDPTR[SCITEMOFFSET]-1;
        INDEX = 0;
LOOP: 
        ADDRESS = ADDRESS+1;
        IF SCITEMENCODE[ADDRESS] EQ 0 THEN
          INDEX = INDEX LOR 1;
        ELSE
          INDEX = INDEX LOR 2;
        IF INDEX EQ 3 THEN
          RETURN; 
        IF SCITEMNEXTON[ADDRESS] THEN 
          GOTO LOOP;
ERROR:  
        CBERROR(307,TRUE);
        END 
      END 
      TERM; 
