*DECK S$GTIKY 
          PROC S$GTIKY(RP$);
#**       S$GTIKY -  COLLECT RAW PARAMETERS TO FORM SPEC-PARTS         #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         S$GTIKY(RP$):                                                #
#                                                                      #
#     GIVEN-                                                           #
#         RP$ = ARRAY CONTAINING TYPES OF RAW PARAMETERS               #
#                                                                      #
#     DOES-                                                            #
#         INTERACTIVELY QUERIES USER TO FORM SPEC-PARTS RELATED TO KEYS#
  
          BEGIN 
*CALL A 
  
*CALL KT$ 
  
*CALL QUERY$
  
*CALL RP$ 
  
*CALL LINE$ 
*CALL RSFLAGS 
          XREF
              BEGIN 
              PROC  S$ABORT;           # HANDLE INTERNAL ABORT ERROR   #
              PROC  S$ANSEP;           # GET COLLATING SEQ NAME        #
              PROC  S$ANSKS;           # GETS KEY TYPE STATUS          #
              PROC  S$ANSNM;           # GETS NON-NEGATIVE INTEGER     #
              PROC  S$ANSYN;           # GETS Y/N ANSWER FROM I/U      #
              PROC  S$GTCOL;           # GET COLLATING SEQ ELEMENTS    #
              PROC  S$GTEQU;           # GET EQUATE SEQUENCE ELEMENTS  #
              FUNC  S$NEWGR      I;    # GET A NEW GROUP NUMBER        #
              PROC  S$PTQUE;           # PUT QUERY TO USER             #
              PROC  S$PUTLN;
  
              ITEM S$HLP   I;    # KIND OF HELP DESIRED                #
              END 
  
          ARRAY [1:20]  S(2); 
              BEGIN 
              ITEM  NAMEOFNUM    C(0, 0,11)  =
                                       [ "           "
                                       , "SECOND     "
                                       , "THIRD      "
                                       , "FOURTH     "
                                       , "FIFTH      "
                                       , "SIXTH      "
                                       , "SEVENTH    "
                                       , "EIGHTH     "
                                       , "NINTH      "
                                       , "TENTH      "
                                       , "ELEVENTH   "
                                       , "TWELFTH    "
                                       , "THIRTEENTH "
                                       , "FOURTEENTH "
                                       , "FIFTEENTH  "
                                       , "SIXTEENTH  "
                                       , "SEVENTEENTH"
                                       , "EIGHTEENTH "
                                       , "NINETEENTH "
                                       , "TWENTIETH  "
                                       ]; 
              ITEM  LENGTHOFNAME I(1,54, 6)  =
                                       [  -1     #                     #
                                       ,  6      # SECOND              #
                                       ,  5      # THIRD               #
                                       ,  6      # FOURTH              #
                                       ,  5      # FIFTH               #
                                       ,  5      # SIXTH               #
                                       ,  7      # SEVENTH             #
                                       ,  5      # EIGHTH              #
                                       ,  5      # NINTH               #
                                       ,  5      # TENTH               #
                                       ,  8      # ELEVENTH            #
                                       ,  7      # TWELFTH             #
                                       ,  10     # THIRTEENTH          #
                                       ,  10     # FOURTEENTH          #
                                       ,  9      # FIFTEENTH           #
                                       ,  9      # SIXTEENTH           #
                                       ,  11     # SEVENTEENTH         #
                                       ,  10     # EIGHTEENTH          #
                                       ,  10     # NINETEENTH          #
                                       ,  9      # TWENTIETH           #
                                       ]; 
              END 
  
          ARRAY  CSARRAY [0:256];      # ARRAY OF COL SEQ ELEMENTS     #
              ITEM  CSELMT   I(0,0,60);# CHAR OR OCTAL VALUE           #
  
          ARRAY ASCIICODE [0:63] S(1);
              BEGIN 
              ITEM  ASCIICS  U( 0, 0,60) =
              [ 45,54,52,48,43,51,55,56,41,42,39,37,46,38,47,40,
                27,28,29,30,31,32,33,34,35,36, 0,63,58,44,59,57,
                60, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,
                16,17,18,19,20,21,22,23,24,25,26,49,61,50,62,53]; 
              END 
  
  
          SWITCH  GTKYLOC 
               ,  GTKYLOC1
               ,  GTKYLOC2
               ,  GTKYLOC3
               ,  GTKYLOC4
               ,  GTKYLOC5
               ,  GTKYLOC6
               ,  GTKYLOC7
               ,  GTKYLOC8
               ,  GTKYLOC9
               ,  GTIKYEND
                ,  GOTCSNAME
                ,  GOTCSELMT
               ,  GOTEQNAME 
               ,  GOTEQELMT 
               ,  GOTKEYCS
               ,  GOTASCII6 
               ;
  
  
          ITEM  GKSW         I=1;      # INDEX TO SWITCH GTKYLOC       #
          ITEM  KTSW         I;        # INDEX TO SWITCH KTSW$         #
          ITEM  NKEYFIELDS   I;        # NUM OF USERS KEY FIELDS       #
          ITEM  ORD          I;        # ORDINAL OF VALUE              #
          ITEM  CSNAME       C(7);     # COL SEQ NAME                  #
          ITEM  KEYTYPENAME  C(12);    # NAME OF KEYTYPE USER WANTS    #
          ITEM  NUM          I;        # NUMERIC RESPONSE FROM S$ANSNM #
          ITEM  NUM2         I;        # NUMERIC RESPONSE FROM S$ANSNM #
          ITEM  YES          B;        # INDICATE RESPONSE TO S$ANSYN  #
          ITEM  YES2         B;        # INDICATE RESPONSE TO S$ANSYN  #
          ITEM  ALLKEYASC    B;        # IF ALL CHAR. KEYS ASCENDING   #
          ITEM  GROUP        I;        # NEW GROUP NUMBER FROM S$NEWGR #
          ITEM  I            I;        # SCRATCH                       #
          ITEM  L            I;        # SCRATCH                       #
  
  
CONTROL DISJOINT; 
  
CONTROL INERT;
  
CONTROL EJECT;
  
#      CHECK FLAG, IF FIRST TIME OR RESTART THEN RESET SWITCH          #
  
          IF B<1,1>S$FLAGS EQ 0 THEN
              BEGIN 
              GKSW = 1;                # RESET SWITCH FOR GTIKY        #
              B<1,1>S$FLAGS = 1;       # CHANGE FLAG                   #
              END 
  
          $BEGIN
          IF GKSW LS 1
              OR GKSW GR 16 THEN
              S$ABORT("S$GTIKY-1"); 
          $END
  
          GOTO GTKYLOC[GKSW]; 
  
# QUERY AS TO WHETHER KEYS TO BE SORTED ACCORDING TO ASCII CODE        #
  
GTKYLOC1: 
          QUERY$LINE[1] = 
          "THE STANDARD COLLATING SEQUENCE IS ASCII6. ";
          QUERY$LLINE[1] = 43;
          QUERY$LINE[2] = 
          "HERE IS THE WHOLE ASCII6 COLLATING SEQUENCE LISTED"; 
          QUERY$LLINE[2] = 50;
  
          FOR I = 0 STEP 1 UNTIL 63 DO
              C<I,1>QUERY$LINE[3] = ASCIICS[I]; 
          QUERY$LLINE[3] = 64;
          QUERY$LINE[4] = 
          "DO ALL OF YOUR KEYS CONSIST OF CHARACTER DATA TO BE ORDERED";
          QUERY$LLINE[4] = 59;
          QUERY$LINE[5] = "ACCORDING TO THE ASCII6 COLLATING SEQUENCE"; 
          QUERY$LLINE[5] = 42;
          QUERY$NLINES = 5; 
          S$HLP = 300;
          S$ANSYN(QUERY$, YES); 
          IF NOT YES THEN 
  
# QUERY AS TO WHETHER THE USER KNOWS OF THE NAMES OF THE KEY TYPES     #
  
              BEGIN    # NOT ALL CHARACTER DATA # 
              QUERY$LINE[1] = 
             "DO YOU KNOW THE NAME(S) OF THE KEY TYPES YOU WANT TO USE";
              QUERY$LLINE[1] = 56;
              QUERY$NLINES = 1; 
              S$HLP = 305;
              S$ANSYN(QUERY$, YES); 
              QUERY$LINE[1] = 
              "DO YOU WANT TO DEFINE YOUR OWN COLLATING SEQUENCE(S)"; 
              QUERY$LLINE[1] = 52;
              QUERY$NLINES = 1; 
              S$HLP = 310;
              S$ANSYN(QUERY$, YES2);
              IF (NOT YES) OR YES2 THEN 
  
# ASK IF USERS RECORDS CONSIST ENTIRELY OF CHARACTERS                  #
  
                  BEGIN    # KEY TYPE NAME NOT KNOWN #
                  QUERY$LINE[1] = 
                       "DO YOUR RECORDS CONSIST ENTIRELY OF CHARACTERS";
                  QUERY$LLINE[1] = 46;
                  QUERY$NLINES = 1; 
                  S$HLP = 315;
                  S$ANSYN(QUERY$, YES); 
                  IF NOT YES THEN 
  
# EXPLAIN TO USER ABOUT DIFFERENT KEY TYPES                            #
  
                      BEGIN    # RECORDS CONSIST ONLY OF CHAR # 
                      QUERY$LINE[1] = 
            "NON-CHARACTER DATA MAY BE ORDERED ACCORDING TO ITS BINARY";
                      QUERY$LLINE[1] = 57;
                      QUERY$LINE[2] = 
     "(SIGNED OR UNSIGNED) VALUE, OR REAL (I.E. FLOATING POINT) VALUE.";
                      QUERY$LLINE[2] = 64;
                      QUERY$LINE[3] = " ";
                      QUERY$LLINE[3] = 1; 
                      QUERY$LINE[4] = 
         "A SIGNED BINARY KEY INTERPRETS THE BITS WITHIN THE KEY FIELD";
                      QUERY$LLINE[4] = 60;
                      QUERY$LINE[5] = 
      "AS A ONE'S COMPLEMENT NUMBER. IF THE LEFT MOST BIT IS ZERO THEN";
                      QUERY$LLINE[5] = 63;
                      QUERY$LINE[6] = 
        "THE NUMBER IS POSITIVE. IF THE LEFT MOST BIT IS ONE THEN THE ";
                      QUERY$LLINE[6] = 61;
                      QUERY$LINE[7] = 
      "NUMBER IS NEGATIVE AND THE MAGNITUDE OF THE NUMBER IS THAT WITH";
                      QUERY$LLINE[7] =63; 
                      QUERY$LINE[8] = 
         "ALL BITS COMPLEMENTED. IF THE KEY FIELD STARTS AND ENDS ON A";
                      QUERY$LLINE[8] = 60;
                      QUERY$LINE[9] = 
        "CHARACTER BOUNDARY THEN THE KEY TYPE IS 'INTEGER', OTHERWISE"; 
                      QUERY$LLINE[9] = 60;
              QUERY$LINE[10] = "IT IS 'INTEGER_BITS'."; 
                      QUERY$LLINE[10] = 21; 
                      QUERY$LINE[11] = " "; 
                      QUERY$LLINE[11] = 1;
                      QUERY$LINE[12] =
     "AN UNSIGNED BINARY KEY INTERPRETS THE BITS WITHIN THE KEY FIELD"; 
                      QUERY$LLINE[12] = 63; 
                      QUERY$LINE[13] =
      "AS A BINARY NUMBER. THE LEFT-MOST BIT IN THE FIELD CONTRIBUTES"; 
                      QUERY$LLINE[13] = 62; 
                      QUERY$LINE[14] =
      "TO THE NUMERIC VALUE JUST LIKE ANY OTHER BITS IN THE FIELD. IF"; 
                      QUERY$LLINE[14] = 62; 
                      QUERY$LINE[15] =
      "THE KEY FIELD STARTS AND ENDS ON A CHARACTER BOUNDARY THEN THE"; 
                      QUERY$LLINE[15] = 62; 
                      QUERY$LINE[16] =
          "KEY TYPE IS 'BINARY', OTHERWISE IT IS 'BINARY_BITS'."; 
                      QUERY$LLINE[16] = 52; 
                      QUERY$LINE[17] = " "; 
                      QUERY$LLINE[17] = 1;
                      QUERY$LINE[18] =
        "A REAL OR FLOATING-POINT KEY INTERPRETS A 60-BITS VALUE AS A"; 
                      QUERY$LLINE[18] = 60; 
                      QUERY$LINE[19] =
          "STANDARD FLOATING-POINT NUMBER. THE KEY TYPE IS 'REAL'.";
              QUERY$LLINE[19] = 55; 
                      QUERY$NLINES = 19;
  
                      S$PTQUE(QUERY$);    # PUT QUERY TO USER # 
  
# QUERY AS TO WHETHER USER WANTS MORE INFO ON KEY TYPES                #
  
GTKYINFO: 
                      QUERY$LINE[1] = " ";
                      QUERY$LLINE[1] = 1; 
                      QUERY$LINE[2] = 
      "IF YOU WANT MORE INFORMATION ABOUT A KEY TYPE, INCLUDING HOW TO";
                      QUERY$LLINE[2] = 63;
                      QUERY$LINE[3] = 
"SPECIFY IT, TYPE THE NAME OF THE KEY TYPE. (OTHERWISE, TYPE A SPACE.)";
                      QUERY$LLINE[3] = 69;
                      QUERY$NLINES = 3; 
                      S$HLP = 300;
                      S$ANSKS(QUERY$, KEYTYPENAME, KTSW); 
  
                      IF KEYTYPENAME EQ "BINARY" THEN 
                          BEGIN 
                          QUERY$LINE[1] = 
         "A BINARY KEY FIELD IS SPECIFIED BY NAMING THE FIRST AND LAST";
                          QUERY$LLINE[1] = 60;
                          QUERY$LINE[2] = 
                                    "CHARACTER POSITIONS OF THE FIELD.";
                          QUERY$LLINE[2] = 33;
                          QUERY$LINE[3] = 
                  "(THE FIRST CHARACTER POSITION IN THE RECORD IS 1.)"; 
                          QUERY$LLINE[3] = 50;
                          QUERY$NLINES = 3; 
                          S$PTQUE(QUERY$);
  
                          GOTO GTKYINFO;
                          END 
  
                      ELSE
                      IF KEYTYPENAME EQ "BINARY_BITS" THEN
                          BEGIN 
                          QUERY$LINE[1] = 
         "A BINARY-BITS KEY FIELD IS SPECIFIED BY NAMING THE FIRST AND";
                          QUERY$LLINE[1] = 60;
                          QUERY$LINE[2] = 
         "LAST BIT POSITIONS OF THE FIELD. (THE FIRST BIT POSITION IN ";
                          QUERY$LLINE[2] = 60;
                          QUERY$LINE[3] = "THE RECORD IS 1.)";
                          QUERY$LLINE[3] = 17;
                          QUERY$NLINES = 3; 
                          S$PTQUE(QUERY$);
  
                          GOTO GTKYINFO;
                          END 
  
                      ELSE
                      IF KEYTYPENAME EQ "INTEGER" THEN
                          BEGIN 
                          QUERY$LINE[1] = 
         "AN INTEGER KEY FIELD IS SPECIFIED BY NAMING THE FIRST AND   ";
                          QUERY$LLINE[1] = 60;
                          QUERY$LINE[2] = 
         "LAST CHARACTER POSITIONS OF THE FIELD. (THE FIRST CHARACTER ";
                          QUERY$LLINE[2] = 60;
                          QUERY$LINE[3]="POSITION IN THE RECORD IS 1.)";
                          QUERY$LLINE[3] = 29;
                          QUERY$NLINES = 3; 
                          S$PTQUE(QUERY$);
  
                          GOTO GTKYINFO;
                          END 
  
                      ELSE
                      IF KEYTYPENAME EQ "INTEGER_BITS" THEN 
                          BEGIN 
                          QUERY$LINE[1] = 
         "AN INTEGER-BITS KEY FIELD IS SPECIFIED BY NAMING THE FIRST  ";
                          QUERY$LLINE[1] = 60;
                          QUERY$LINE[2] = 
         "AND LAST BIT POSITIONS OF THE FIELD. (THE FIRST BIT POSITION";
                          QUERY$LLINE[2] = 60;
                          QUERY$LINE[3] = "IN THE RECORD IS 1.)"; 
                          QUERY$LLINE[3] = 20;
                          QUERY$NLINES = 3; 
                          S$PTQUE(QUERY$);
  
                          GOTO GTKYINFO;
                          END 
  
                      ELSE
                      IF KEYTYPENAME EQ "REAL" THEN 
                          BEGIN 
                          QUERY$LINE[1] = 
         "A REAL KEY FIELD IS SPECIFIED BY NAMING THE FIRST AND LAST  ";
                          QUERY$LLINE[1] = 60;
                          QUERY$LINE[2] = 
         "CHARACTER POSITIONS OF THE FIELD. SINCE REAL KEY FIELDS MUST";
                          QUERY$LLINE[2] = 60;
                          QUERY$LINE[3] = 
         "BE FULL WORDS AND BE ALIGNED ON WORD BOUNDARIES, THE FIRST  ";
                          QUERY$LLINE[3] = 60;
                          QUERY$LINE[4] = 
         "CHARACTER POSITION MUST SPECIFY THE FIRST CHARACTER OF A    ";
                          QUERY$LLINE[4] = 60;
                          QUERY$LINE[5] = 
         "WORD AND THE SECOND CHARACTER POSITION MUST SPECIFY THE LAST";
                          QUERY$LLINE[5] = 60;
                          QUERY$LINE[6] = 
         "CHARACTER OF A WORD. IF THE SECOND CHARACTER POSITION IS NOT";
                          QUERY$LLINE[6] = 60;
                          QUERY$LINE[7] = 
                                 "SPECIFIED, A FULL WORD IS ASSUMED.";
                          QUERY$LLINE[7] = 34;
                          QUERY$NLINES = 7; 
                          S$PTQUE(QUERY$);
  
                          GOTO GTKYINFO;
                          END 
  
                      ELSE
                      IF KEYTYPENAME NQ " " THEN
                          GOTO GTKYINFO;    # INVALID REPLY HERE #
  
                      END    # REC CONSIST ONLY OF CHAR # 
  
# QUERY WHETHER CHAR KEY FIELDS TO BE INTERPRETED NUMERICALLY          #
  
                  QUERY$LINE[1] = 
         "KEY FIELDS CONSISTING ONLY OF CHARACTERS MAY BE ORDERED     ";
                  QUERY$LLINE[1] = 60;
                  QUERY$LINE[2] = 
         "ACCORDING TO A CHARACTER COLLATING SEQUENCE OR ACCORDING TO ";
                  QUERY$LLINE[2] = 60;
                  QUERY$LINE[3] = 
                          "A NUMERIC INTERPRETATION OF THE CHARACTERS.";
                  QUERY$LLINE[3] = 43;
                  QUERY$LINE[4] = " ";
                  QUERY$LLINE[4] = 1; 
                  QUERY$LINE[5] = 
         "DO YOU WANT ANY OF YOUR CHARACTER KEY FIELDS TO BE          ";
                  QUERY$LLINE[5] = 66;
                  QUERY$LINE[6] = "INTERPRETED NUMERICALLY";
                  QUERY$LLINE[6] = 23;
                  QUERY$NLINES = 6; 
                  S$HLP = 315;
                  S$ANSYN(QUERY$, YES); 
                  IF YES THEN 
  
# EXPLAIN ABOUT THE NUMERIC CHARACTER KEY TYPES                        #
  
                      BEGIN    # KEYFIELD NUMERICALLY INTERPRETED # 
                      QUERY$LINE[1] = 
         "THE KEY TYPE FOR NUMERIC CHARACTER KEYS IS 'NUMERIC_XX'     ";
                      QUERY$LLINE[1] = 60;
                      QUERY$LINE[2] = 
         "WHERE XX INDICATES HOW THE SIGN (IF ANY) IS TO BE EXTRACTED ";
                      QUERY$LLINE[2] = 60;
                      QUERY$LINE[3] = 
         "AND WHETHER LEADING BLANKS ARE ALLOWED.  THE LEGAL NUMERIC  ";
                      QUERY$LLINE[3] = 60;
                      QUERY$LINE[4] = "CHARACTER KEY TYPES ARE:"; 
                      QUERY$LLINE[4] = 24;
                      QUERY$LINE[5] ="NUMERIC_NS   ALL DIGITS, NO SIGN";
                      QUERY$LLINE[5] = 32;
                      QUERY$LINE[6] = 
         "NUMERIC_FS   LEADING BLANKS, THEN OPTIONAL SIGN, THEN DIGITS";
                      QUERY$LLINE[6] = 60;
                      QUERY$LINE[7] = 
         "NUMERIC_LS   REQUIRED SIGN IS FIRST, THEN DIGITS            ";
                      QUERY$LLINE[7] = 60;
                      QUERY$LINE[8] = 
         "NUMERIC_TS   DIGITS FOLLOWED BY REQUIRED SIGN               ";
                      QUERY$LLINE[8] = 60;
                      QUERY$LINE[9] = 
         "NUMERIC_LO   LEADING OVERPUNCHED DIGIT, THEN DIGITS         ";
                      QUERY$LLINE[9] = 60;
                      QUERY$LINE[10] =
         "NUMERIC_TO   DIGITS FOLLOWED BY TRAILING OVERPUNCHED DIGITS ";
                      QUERY$LLINE[10] = 60; 
                      QUERY$NLINES = 10;
                      S$PTQUE(QUERY$);
  
# QUERY AS TO WHETHER USER WANTS MORE INFO ON NUMERIC CHARACTER KEYS   #
  
NUMCHARINFO:  
                      QUERY$LINE[1] = " ";
                      QUERY$LLINE[1] = 1; 
                      QUERY$LINE[2] = 
         "IF YOU WANT MORE INFORMATION ABOUT ONE OF THE NUMERIC       ";
                      QUERY$LLINE[2] = 60;
                      QUERY$LINE[3] = 
         "CHARACTER KEY TYPES, INCLUDING HOW TO SPECIFY IT, TYPE THE  ";
                      QUERY$LLINE[3] = 60;
                      QUERY$LINE[4] = 
         "NAME OF THE KEY TYPE. (OTHERWISE, TYPE A SPACE.)            ";
                      QUERY$LLINE[4] = 60;
                      QUERY$NLINES = 4; 
                      S$HLP = 300;
                      S$ANSKS(QUERY$, KEYTYPENAME, KTSW); 
  
                      IF KEYTYPENAME EQ "NUMERIC_NS"  THEN
                          BEGIN 
                          QUERY$LINE[1] = 
         "ALL NUMERIC_NS KEY FIELDS MUST CONTAIN ALL DECIMAL DIGITS   ";
                          QUERY$LLINE[1] = 60;
                          QUERY$LINE[2] = 
         "CHARACTERS WITHOUT A SIGN. THE FIELD IS SPECIFIED BY NAMING ";
                          QUERY$LLINE[2] = 60;
                          QUERY$LINE[3] = 
         "THE FIRST AND THE LAST CHARACTER POSITION OF THE FIELD      ";
                          QUERY$LLINE[3] = 60;
                          QUERY$NLINES = 3; 
                          S$PTQUE(QUERY$);
  
                          GOTO NUMCHARINFO; 
                          END 
  
                      ELSE
                      IF KEYTYPENAME EQ "NUMERIC_FS"  THEN
                          BEGIN 
                          QUERY$LINE[1] = 
         "NUMERIC_FS KEY FIELDS MUST BE NUMERIC CHARACTERS IN A       ";
                          QUERY$LLINE[1] = 59;
                          QUERY$LINE[2] = 
          "FLOATING SIGN FORMAT. LEADING BLANKS ARE ALLOWED, FOLLOWED ";
                          QUERY$LLINE[2] = 59;
                          QUERY$LINE[3] = 
          "BY AN OPTIONAL SIGN CONSISTING OF '+' OR '-', FOLLOWED BY  ";
                          QUERY$LLINE[3] = 59;
                          QUERY$LINE[4] = 
          "DECIMAL DIGIT CHARACTERS. THE FIELD IS SPECIFIED BY NAMING ";
                          QUERY$LLINE[4] = 59;
                          QUERY$LINE[5] = 
          "THE FIRST AND THE LAST CHARACTER POSITIONS OF THE FIELD.   ";
                          QUERY$LLINE[5] = 59;
                          QUERY$NLINES = 5; 
                          S$PTQUE(QUERY$);
  
                          GOTO NUMCHARINFO; 
                          END 
  
                      ELSE
                      IF KEYTYPENAME EQ "NUMERIC_LS"  THEN
                          BEGIN 
                          QUERY$LINE[1] = 
         "THE FIRST CHARACTER OF A NUMERIC_LS KEY FIELD MUST BE A  '+'";
                          QUERY$LLINE[1] = 60;
                          QUERY$LINE[2] = 
         "OR '-'  CHARACTER.  THE REMAINING POSITIONS MUST CONSIST OF ";
                          QUERY$LLINE[2] = 59;
                          QUERY$LINE[3] = 
          "DECIMAL DIGIT CHARACTERS. THE FIELD IS SPECIFIED BY NAMING ";
                          QUERY$LLINE[3] = 59;
                          QUERY$LINE[4] = 
          "THE FIRST AND THE LAST CHARACTER POSITIONS OF THE FIELD.   ";
                          QUERY$LLINE[4] = 59;
                          QUERY$NLINES = 4; 
                          S$PTQUE(QUERY$);
  
                          GOTO NUMCHARINFO; 
                          END 
  
                      ELSE
                      IF KEYTYPENAME EQ "NUMERIC_TS"  THEN
                          BEGIN 
                          QUERY$LINE[1] = 
         "THE TRAILING (RIGHT-MOST) CHARACTER OF A NUMERIC-TS KEY     ";
                          QUERY$LLINE[1] = 59;
                          QUERY$LINE[2] = 
          "FIELD MUST BE A '+' OR '-' CHARACTER. THE REMAINING        ";
                          QUERY$LLINE[2] = 59;
                          QUERY$LINE[3] = 
          "POSITIONS MUST CONSIST OF DECIMAL DIGIT CHARACTERS.  THE   ";
                          QUERY$LLINE[3] = 59;
                          QUERY$LINE[4] = 
          "FIELD IS SPECIFIED BY NAMING THR FIRST AND LAST CHARACTER  ";
                          QUERY$LLINE[4] = 59;
                          QUERY$LINE[5] = "POSITIONS OF THE FIELD.";
                          QUERY$LLINE[5] = 23;
                          QUERY$NLINES = 5; 
                          S$PTQUE(QUERY$);
  
                          GOTO NUMCHARINFO; 
                          END 
  
                      ELSE
                      IF KEYTYPENAME EQ "NUMERIC_LO"  THEN
                          BEGIN 
                          QUERY$LINE[1] = 
         "THE LEADING (LEFT-MOST) CHARACTER OF A NUMERIC_LO KEY FIELD"; 
                          QUERY$LLINE[1] = 59;
                          QUERY$LINE[2] = 
          "MUST BE AN OVERPUNCHED DIGIT. THE OVERPUNCHED DIGIT        ";
                          QUERY$LLINE[2] = 59;
                          QUERY$LINE[3] = 
          "DETERMINES BOTH THE SIGN OF THE ENTIRE NUMBER AND THE VALUE";
                          QUERY$LLINE[3] = 59;
                          QUERY$LINE[4] = 
          "OF THE LEADING DIGIT. CHARACTERS FROM '0' TO '9' MEAN THE  ";
                          QUERY$LLINE[4] = 59;
                          QUERY$LINE[5] = 
          "SIGN IS POSITIVE AND THE LEADING DIGIT IS 0 TO 9.          ";
                          QUERY$LLINE[5] = 59;
                          QUERY$LINE[6] = 
          "CHARACTERS FROM 'A' TO 'I' MEAN THE SIGN IS POSITIVE AND   ";
                          QUERY$LLINE[6] = 59;
                          QUERY$LINE[7] = 
          "THE LEADING DIGIT IS 1 TO 9.  CHARACTERS FROM 'J' TO 'R'   ";
                          QUERY$LLINE[7] = 59;
                          QUERY$LINE[8] = 
          "MEAN THE SIGN IS NEGATIVE AND THE LEADING DIGIT IS 1 TO 9. ";
                          QUERY$LLINE[8] = 59;
                          QUERY$LINE[9] = 
         "THE CHARACTER '<' MEANS THE SIGN IS POSITIVE AND THE LEADING";
                          QUERY$LLINE[9] = 60;
                          QUERY$LINE[10] =
         "DIGIT IS 0. THE CHARACTER 'V' MEANS THE SIGN IS NEGATIVE AND";
                          QUERY$LLINE[10] = 60; 
                          QUERY$LINE[11] =
          "THE LEADING DIGIT IS 0. THE REMAINING POSITIONS OF THE     ";
                          QUERY$LLINE[11] = 59; 
                          QUERY$LINE[12] =
          "FIELD MUST CONTAIN DECIMAL DIGIT CHARACTERS. THE FIELD IS  ";
                          QUERY$LLINE[12] = 59; 
                          QUERY$LINE[13] =
          "SPECIFIED BY NAMING THE FIRST AND LAST CHARACTER POSITIONS ";
                          QUERY$LLINE[13] = 59; 
                          QUERY$LINE[14] = "OF THE FIELD."; 
                          QUERY$LLINE[14] = 13; 
                          QUERY$NLINES = 14;
                          S$PTQUE(QUERY$);
  
                          GOTO NUMCHARINFO; 
                          END 
  
                      ELSE
                      IF KEYTYPENAME EQ "NUMERIC_TO"  THEN
                          BEGIN 
                          QUERY$LINE[1] = 
         "THE TRAILING (RIGHT-MOST) CHARACTER OF A NUMERIC_TO KEY     ";
                          QUERY$LLINE[1] = 59;
                          QUERY$LINE[2] = 
          "FIELD MUST BE AN OVERPUNCHED DIGIT. THE OVERPUNCHED DIGIT  ";
                          QUERY$LLINE[2] = 59;
                          QUERY$LINE[3] = 
          "DETERMINES BOTH THE SIGN OF THE ENTIRE NUMBER AND THE VALUE";
                          QUERY$LLINE[3] = 59;
                          QUERY$LINE[4] = 
          "OF THE TRAILING DIGIT. CHARACTERS FROM '0' TO '9' MEAN THE ";
                          QUERY$LLINE[4] = 59;
                          QUERY$LINE[5] = 
          "SIGN IS POSITIVE AND THE TRAILING DIGIT IS 1 TO 9.         ";
                          QUERY$LLINE[5] = 59;
                          QUERY$LINE[6] = 
         "CHARACTERS FROM 'A' TO 'I' MEAN THE SIGN IS POSITIVE AND THE";
                          QUERY$LLINE[6] = 60;
                          QUERY$LINE[7] = 
          "TRAILING DIGIT IS 1 TO 9. CHARACTERS FROM 'J' TO 'R' MEAN  ";
                          QUERY$LLINE[7] = 59;
                          QUERY$LINE[8] = 
         "THE SIGN IS NEGATIVE AND THE TRAILING DIGIT IS 1 TO 9. THE  ";
                          QUERY$LLINE[8] = 59;
                          QUERY$LINE[9] = 
          "CHARACTER '<' MEAN THE SIGN IS POSITIVE AND THE TRAILING   ";
                          QUERY$LLINE[9] = 59;
                          QUERY$LINE[10] =
          "DIGIT IS 0. THE CHARACTTER 'V' MEANS THE SIGN IS NEGATIVE  ";
                          QUERY$LLINE[10] = 59; 
                          QUERY$LINE[11] =
          "AND THE TRAILING DIGIT IS 0. THE REMAINING POSITIONS OF THE";
                          QUERY$LLINE[11] = 59; 
                          QUERY$LINE[12] =
          "FIELD MUST CONTAIN DECIMAL DIGIT CHARACTERS. THE FIELD IS  ";
                          QUERY$LLINE[12] = 59; 
                          QUERY$LINE[13] =
          "SPECIFIED BY NAMING THE FIRST AND LAST CHARACTER POSITIONS ";
                          QUERY$LLINE[13] = 59; 
                          QUERY$LINE[14] = "OF THE FIELD."; 
                          QUERY$LLINE[14] = 13; 
                          QUERY$NLINES = 14;
                          S$PTQUE(QUERY$);
  
                          GOTO NUMCHARINFO; 
                          END 
  
                      ELSE
                          BEGIN 
                          IF KEYTYPENAME NQ " " THEN
                              GOTO NUMCHARINFO;   # INVALID REPLY HERE #
  
                          END 
  
                      END    # KEYFIELD NUMERICALLY INTERPRETED # 
  
  
# ASK USER ABOUT COLLATING SEQUENCE                                    #
  
                      QUERY$LINE[1] = 
          "DO YOU WANT ANY OF YOUR CHARACTER KEY FIELDS TO BE ORDERED ";
                      QUERY$LLINE[1] = 59;
                      QUERY$LINE[2] = 
          "ACCORDING TO A COLLATING SEQUENCE";
                      QUERY$LLINE[2] = 33;
                      QUERY$NLINES = 2; 
                      S$HLP = 305;
                      S$ANSYN(QUERY$, YES); 
                      IF YES THEN 
  
# ASK IF USER WANTS COLLATING SEQUENCE LISTED                          #
  
                          BEGIN 
                          QUERY$LINE[1] = 
          "THE STANDARD COLLATING SEQUENCE IS ASCII6. ";
                          QUERY$LLINE[1] = 43;
                          QUERY$LINE[2] = 
          "HERE IS THE WHOLE ASCII6 COLLATING SEQUENCE LISTED"; 
                          QUERY$LLINE[2] = 50;
  
                          FOR I = 0 STEP 1 UNTIL 63 DO
                              C<I,1>QUERY$LINE[3] = ASCIICS[I]; 
                          QUERY$LLINE[3] = 63;
                          QUERY$LINE[4] = " ";
                          QUERY$LLINE[4] = 1; 
                          QUERY$NLINES = 4; 
                          S$PTQUE(QUERY$);
  
# ASK IF USER WANTS TO DEFINE OWN COLLATING SEQUENCE                   #
  
  
                          QUERY$LINE[1] = 
       "THE KEY TYPE OF A CHARACTER KEY FIELD ORDERED ACCORDING TO A";
              QUERY$LLINE[1] = 59;
              QUERY$LINE[2] = 
          "COLLATING SEQUENCE IS THE NAME OF THE COLLATING SEQUENCE.";
              QUERY$LLINE[2] = 57;
              QUERY$LINE[3] = 
          "THE KEY FIELD IS SPECIFIED BY NAMING THE FIRST AND THE"; 
              QUERY$LLINE[3] = 54;
                          QUERY$LINE[4] = 
          "LAST CHARACTER POSITIONS OF THE FIELD."; 
                          QUERY$LLINE[4] = 38;
                          QUERY$LINE[5] = " ";
                          QUERY$LLINE[5] = 1; 
                          QUERY$LINE[6] = 
          "THERE ARE FIVE PRE-DEFINED COLLATING SEQUENCES"; 
                          QUERY$LLINE[6] = 46;
                          QUERY$LINE[7] = 
          "DISPLAY, COBOL6, ASCII6, EBCDIC6 AND INTBCD."; 
                          QUERY$LLINE[7] = 44;
                          QUERY$LINE[8] = 
         "THERE CAN BE FROM 0 TO 100 USER-DEFINED COLLATING SEQUENCES.";
                          QUERY$LLINE[8] = 60;
                          QUERY$LINE[9] = 
          "DO YOU WANT TO DEFINE YOUR OWN COLLATING SEQUENCE(S)"; 
              QUERY$LLINE[9] = 52;
                          QUERY$NLINES = 9; 
                          S$HLP = 310;
                          S$ANSYN(QUERY$, YES); 
                          IF YES THEN 
                              BEGIN # DEFINE OWN COLLATING SEQUENCE # 
                              QUERY$LINE[1] = 
          "WHEN ASKED TO TYPE IN YOUR COLLATING SEQUENCE,"; 
                              QUERY$LLINE[1] = 56;
                              QUERY$LINE[2] = 
          "PLEASE TYPE IN AS      C,C,C,C,C,C     OR    C,C,C,C,";
                              QUERY$LLINE[2] = 53;
                              QUERY$LINE[3] = 
          "                                             C,C     ";
                              QUERY$LLINE[3] = 53;
                              QUERY$LINE[4] = 
          "WHERE C IS A CHARACTER OR AN OCTAL VALUE.";
                              QUERY$LLINE[4] = 41;
                              QUERY$LINE[5] = 
          "C CAN BE A LETTER, A ONE-DIGIT NUMBER OR A SPECIAL ";
                              QUERY$LLINE[5] = 51;
                              QUERY$LINE[6] = 
          "CHARACTER SUCH AS ( ) + - * .";
                              QUERY$LLINE[6] = 29;
                              QUERY$LINE[7] = 
          "SORT/MERGE ASSUMES A TWO-DIGIT NUMBER AS AN OCTAL VALUE";
                              QUERY$LLINE[7] = 55;
                              QUERY$LINE[8] = 
          "( THE NUMBER SHOULD NOT BE FOLLOWED BY A LETTER ""B"" )."; 
                              QUERY$LLINE[8] = 56;
                              QUERY$LINE[9] = 
          "THE COMMA HAS TO BE SPECIFIED BY ITS OCTAL EQUIVALENT 56 ."; 
                              QUERY$LLINE[9] = 58;
                              QUERY$LINE[10] =
          "HOW MANY COLLATING SEQUENCES DO YOU WANT TO DEFINE"; 
                              QUERY$LLINE[10] = 50; 
                              QUERY$NLINES = 10;
                              S$HLP = 320;
                              S$ANSNM(QUERY$,NUM);
                              FOR I = 1 STEP 1 UNTIL NUM DO 
                                  BEGIN 
          GETNAME:  
                                  QUERY$LINE[1] = 
          "WHAT IS THE NAME OF YOUR COLLATING SEQUENCE";
                                  QUERY$LLINE[1] = 43;
                                  QUERY$NLINES = 1; 
                                  S$ANSEP(QUERY$,CSNAME); 
                                       IF (C<0>CSNAME LS "A") 
                                               OR 
                                          (C<0>CSNAME GR "Z") THEN
                                         BEGIN
                                         LINE$LINE =
              " COLLATING SEQUENCE NAMES MUST BEGIN WITH A CHARACTER";
                                         LINE$LENGTH = 70;
                                         S$PUTLN(LINE$);
                                         GOTO GETNAME;
                                         END; 
  
                                  QUERY$LINE[1] = 
          "PLEASE TYPE IN YOUR COLLATING SEQUENCE"; 
                                  QUERY$LLINE[1] = 38;
                                  QUERY$NLINES = 1; 
                                  S$GTCOL(QUERY$,CSARRAY);
  
#      SAVE RAW PARAMETER OF-                                          #
#         TYPE = RP$T"SEQNAM"                                          #
#         GROUP = <NEW-GROUP>,                                         #
#         VALUE = <COLLATING SEQUENCE NAME>.                           #
  
                                  RP$TYPE = RP$T"SEQNAM"; 
                                  GROUP = S$NEWGR; # GET NEW GROUP NO  #
                                  RP$GROUP = GROUP; 
                                  RP$VALUEC = CSNAME; 
                                  GKSW = 11;
#***#                             RETURN; 
  
GOTCSNAME:  
  
#     FOR EACH VALUE IN CSARRAY UNTIL VALUE IS NEGATIVE,               #
#         SAVE RAW PARAMETER OF-                                       #
#             TYPE = RP$T"SEQVAL",                                     #
#             GROUP = <COLSEQ-GROUP>,                                  #
#             ORDINAL = <INCREMENTED VALUE>,                           #
#             VALUE = VALUE IN CSARRAY                                 #
  
                                  FOR ORD = 0 STEP 1
                                    WHILE CSELMT[ORD] GQ 0 DO 
                                      BEGIN 
                                      RP$TYPE = RP$T"SEQVAL"; 
                                      RP$GROUP = GROUP; 
                                      RP$ORDINAL = ORD + 1; 
                                      RP$VALUE = CSELMT[ORD]; 
                                      GKSW = 12;
#***#                                 RETURN; 
  
GOTCSELMT:  
                                      END 
                                  END 
  
  
                          QUERY$LINE[1] = 
          "DEFINING EQUATE MEANS SPECIFYING TWO OR MORE CHARACTERS";
                          QUERY$LLINE[1] = 60;
                          QUERY$LINE[2] = 
         "ALREADY IN A COLLATING SEQUENCE AS EQUAL FOR COMPARISION";
                          QUERY$LLINE[2] = 62;
                          QUERY$LINE[3] = 
          "PURPOSE. MORE THAN ONE EQUATE SEQUENCE MAY BE SPECIFIED";
                          QUERY$LLINE[3] = 55;
                          QUERY$LINE[4] = "FOR A COLLATING SEQUENCE.";
                          QUERY$LLINE[4] = 25;
                          QUERY$LINE[5] = 
          "DO YOU WANT TO DEFINE EQUATES FOR YOUR COLLATING SEQUENCE";
                          QUERY$LLINE[5] = 57;
                          QUERY$NLINES = 5; 
                          S$HLP = 325;
                          S$ANSYN(QUERY$, YES); 
                          IF YES THEN 
                              BEGIN           # DEFINE EQUATES #
                              QUERY$LINE[1] = 
          "WHEN ASKED TO TYPE IN YOUR EQUATE SEQUENCE(S),"; 
                              QUERY$LLINE[1] = 46;
                              QUERY$LINE[2] = 
          "PLEASE ENTER IN FORM   C,C,C,C,C,C  WHERE C IS"; 
                              QUERY$LLINE[2] = 50;
                              QUERY$LINE[3] = 
          "A CHARACTER OR AN OCTAL VALUE AS EXPLAINED BEFORE."; 
                              QUERY$LLINE[3] = 50;
                              QUERY$LINE[4] = 
          "HOW MANY EQUATE SEQUENCES DO YOU WANT TO DEFINE";
                              QUERY$LLINE[4] = 47;
                              QUERY$NLINES = 4; 
                              S$HLP = 330;
                              S$ANSNM(QUERY$,NUM);
                              FOR I = 1 STEP 1 UNTIL NUM DO 
                                  BEGIN 
                                  QUERY$LINE[1] = 
          "WHAT IS THE NAME OF THE COLLATING SEQUENCE FOR THIS EQUATE"; 
                                  QUERY$LLINE[1] = 58;
                                  QUERY$NLINES = 1; 
                                  S$HLP = 335;
                                  S$ANSEP(QUERY$,CSNAME); 
  
#      SAVE RAW PARAMETER OF-                                          #
#         TYPE = RP$T"EQUNAM"                                          #
#         GROUP = <NEW-GROUP>,                                         #
#         VALUE = <COLLATING SEQUENCE NAME>.                           #
  
                                  RP$TYPE = RP$T"EQUNAM"; 
                                  GROUP = S$NEWGR; # GET NEW GROUP NO  #
                                  RP$GROUP = GROUP; 
                                  RP$VALUEC = CSNAME; 
                                  GKSW = 13;    # GOTEQNAME # 
#***#                             RETURN; 
  
GOTEQNAME:  
  
                                  QUERY$LINE[1] = 
          "PLEASE TYPE IN YOUR EQUATE SEQUENCE";
                                  QUERY$LLINE[1] = 35;
                                  QUERY$NLINES = 1; 
                                  S$GTEQU(QUERY$,CSARRAY);
  
#     FOR EACH VALUE IN CSARRAY UNTIL VALUE IS NEGATIVE,               #
#         SAVE RAW PARAMETER OF-                                       #
#             TYPE = RP$T"EQUVAL",                                     #
#             GROUP = <COLSEQ-GROUP>,                                  #
#             ORDINAL = <INCREMENTED VALUE>,                           #
#             VALUE = VALUE IN CSARRAY                                 #
  
                                  FOR ORD = 0 STEP 1
                                    WHILE CSELMT[ORD] GQ 0 DO 
                                      BEGIN 
                                      RP$TYPE = RP$T"EQUVAL"; 
                                      RP$GROUP = GROUP; 
                                      RP$ORDINAL = ORD + 1; 
                                      RP$VALUE = CSELMT[ORD]; 
                                      GKSW = 14;    # GOTEQELMT # 
#***#                                 RETURN; 
  
GOTEQELMT:  
                                      END 
                                  END 
  
                              END   # DEFINE EQUATE SEQUENCE #
                              END   # DEFINE OWN COLLATING SEQUENCE # 
                          END 
  
                      END    # KEY TYPE NAME NOT KNOWN #
  
  
# QUERY AS TO HOW MANY KEY FIELDS THE USER HAS                         #
  
                  BEGIN 
                  QUERY$LINE[1] = 
          "YOU SHOULD KNOW THE NAME(S) OF ALL KEY TYPES YOU WANT TO   ";
                  QUERY$LLINE[1] = 59;
                  QUERY$LINE[2] = 
          "USE. IF YOU DO NOT KNOW, TYPE 'RESTART' TO START OVER.     ";
                  QUERY$LLINE[2] = 59;
                  QUERY$LINE[3] = " ";
                  QUERY$LLINE[3] = 1; 
                  QUERY$LINE[4] = "HOW MANY KEY FIELDS DO YOU HAVE";
                  QUERY$LLINE[4] = 31;
                  QUERY$NLINES = 4; 
                  S$HLP = 340;
                  S$ANSNM(QUERY$, NKEYFIELDS);
  
# ASK FOR KEY TYPE OF KEY FIELDS IN ORDER OF IMPORTANCE                #
  
                  QUERY$LINE[1] = 
                     "THE LEFT-MOST CHARACTER OF A RECORD IS NUMBER 1.";
                  QUERY$LLINE[1] = 48;
                  QUERY$NLINES = 1; 
                  S$PTQUE(QUERY$);    # SEND QUERY TO USER #
  
                  FOR I = 1 STEP 1 UNTIL NKEYFIELDS DO
                      BEGIN 
  
                      GROUP = S$NEWGR;
                      RP$GROUP = GROUP; 
  
          GETKF:  
                      QUERY$LINE[1] = "WHAT IS THE KEY TYPE OF THE "; 
                      C<28,11>QUERY$LINE[1] = NAMEOFNUM[I]; 
                      L = 28 + LENGTHOFNAME[I]; 
                      C<L,25>QUERY$LINE[1]=" MOST IMPORTANT KEY FIELD"; 
                      QUERY$LLINE[1] = L + 25;
                      QUERY$NLINES = 1; 
                  KTSW = 0; 
                  FOR I = I WHILE KTSW EQ 0 DO
                      BEGIN 
                      S$HLP = 350;
                      S$ANSKS(QUERY$, KEYTYPENAME, KTSW); 
                                       IF (C<0>KEYTYPENAME LS "A")
                                               OR 
                                          (C<0>KEYTYPENAME GR "Z") THEN 
                                         BEGIN
                                         LINE$LINE =
                             " KEY TYPES MUST BEGIN WITH A CHARACTER";
                                         LINE$LENGTH = 70;
                                         S$PUTLN(LINE$);
                                         GOTO GETKF;
                                         END; 
                      END 
  
                      IF KTSW EQ 1 THEN     # DISPLAY KEYTYPE          #
                          BEGIN 
                          IF KEYTYPENAME NQ "DISPLAY" THEN
                              BEGIN 
                              RP$TYPE = RP$T"KEYCOLSEQ";
                              RP$VALUEC = KEYTYPENAME;
                              GKSW = 15;    # GOTKEYCS #
    #***#                     RETURN; 
                              END 
                          ELSE
                              KTSW = KT$T"LOGICAL"; 
                          END 
  
GOTKEYCS: 
                      RP$TYPE = RP$T"KEYTYPE";
                      RP$VALUE = KTSW;
                      GKSW = 2;    # GTKYLOC2 # 
#***#                 RETURN; 
  
# GET NO OF THE LEFT-MOST CHARACTER OR BIT IN THE KEY FIELDS           #
  
GTKYLOC2: 
                      QUERY$LINE[1] = "FOR THE "; 
                      C<8,11>QUERY$LINE[1] = NAMEOFNUM[I];
                      L = 8 + LENGTHOFNAME[I];
                      C<L,45>QUERY$LINE[1] =
                        " MOST IMPORTANT KEY FIELD, WHAT IS THE NUMBER";
                      QUERY$LLINE[1] = L + 45;
                      QUERY$LLINE[2] = 27;
                      QUERY$NLINES = 2; 
                      IF KEYTYPENAME EQ "BINARY_BITS" 
                        OR KEYTYPENAME EQ "INTEGER_BITS" THEN 
                          BEGIN 
                          QUERY$LINE[2] = "OF THE LEFT-MOST BIT       ";
                          RP$TYPE = RP$T"KEYBITPOS";
                          END 
                      ELSE
                          BEGIN 
                          QUERY$LINE[2] = "OF THE LEFT-MOST CHARACTER ";
                          RP$TYPE = RP$T"KEYBYTEPOS"; 
                          END 
  
                      S$ANSNM(QUERY$, NUM2);
                      RP$VALUE = NUM2;
                      GKSW = 3;    # GTKYLOC3 # 
#***#                 RETURN; 
  
# GET THE NUMBER OF THE RIGHT-MOST CHARACTER OR BIT IN THE KEY FIELD   #
  
GTKYLOC3: 
                      QUERY$LINE[1] = "FOR THE "; 
                      C<8,11>QUERY$LINE[1] = NAMEOFNUM[I];
                      L = 8 + LENGTHOFNAME[I];
                      C<L,45>QUERY$LINE[1] =
                        " MOST IMPORTANT KEY FIELD, WHAT IS THE NUMBER";
                      QUERY$LLINE[1] = L + 45;
                      QUERY$LLINE[2] = 27;
                      QUERY$NLINES = 2; 
                      IF KEYTYPENAME EQ "BINARY_BITS" 
                        OR KEYTYPENAME EQ "INTEGER_BITS" THEN 
                          BEGIN 
                          QUERY$LINE[2] = "OF THE RIGHT-MOST BIT      ";
                          RP$TYPE = RP$T"KEYNBITS"; 
                          END 
                      ELSE
                          BEGIN 
                          QUERY$LINE[2] = "OF THE RIGHT-MOST CHARACTER";
                          RP$TYPE = RP$T"KEYNBYTES";
                          END 
  
                      S$ANSNM(QUERY$, NUM); 
                      RP$VALUE = NUM - NUM2 + 1;  # LEN = LAST-FIRST+1 #
                      GKSW = 4;    # GTKYLOC4 # 
#***#                 RETURN; 
  
  
GTKYLOC4: 
                          QUERY$LINE[1] = 
              "DO YOU WANT THIS KEY FIELD SORTED IN ASCENDING ORDER"; 
                          QUERY$LLINE[1] = 52;
                          QUERY$NLINES = 1; 
                          S$HLP = 360;
                          S$ANSYN(QUERY$, YES); 
                          IF NOT YES THEN 
                              RP$TYPE = RP$T"KEYORDER"; 
                          GKSW = 5;    # GTKYLOC5 # 
#***#                     RETURN; 
  
GTKYLOC5:   
                      END    # FOR LOOP # 
                  END 
  
              END    # NOT ALL KEYS CHARACTERS #
  
          ELSE
  
# GET NUMBER OF KEY FIELDS USER HAS.                                   #
  
              BEGIN    # ALL KEYS CHARACTERS #
  
              QUERY$LINE[1] = 
          "ASCENDING ORDER OF THE ASCII6 COLLATING SEQUENCE MEANS THE ";
              QUERY$LLINE[1] = 59;
          QUERY$LINE[2] = "NORMAL ORDER. "; 
          QUERY$LLINE[2] = 14;
          FOR I=0 STEP 1 UNTIL 63 DO
              C<I,1>QUERY$LINE[3] = ASCIICS[I]; 
          QUERY$LLINE[3] = 64;
              QUERY$LINE[4] = 
          "DESCENDING ORDER MEANS THE REVERSE ORDER.";
          QUERY$LLINE[4] = 41;
          FOR I=0 STEP 1 UNTIL 63 DO
              C<I,1>QUERY$LINE[5] = ASCIICS[63-I];
          QUERY$LLINE[5] = 64;
              QUERY$LINE[6] = 
                  "DO YOU WANT ALL YOUR KEYS SORTED IN ASCENDING ORDER";
              QUERY$LLINE[6] = 52;
              QUERY$NLINES = 6; 
              S$HLP = 360;
              S$ANSYN(QUERY$, ALLKEYASC); 
  
              QUERY$LINE[1] = "HOW MANY KEY FIELDS DO YOU HAVE";
              QUERY$LLINE[1] = 31;
              QUERY$NLINES = 1; 
              S$HLP = 350;
              S$ANSNM(QUERY$, NKEYFIELDS);
  
# GET POSITION OF THE KEY FIELDS IN ORDER OF IMPORTANCE                #
  
              QUERY$LINE[1] = 
                    "THE LEFT-MOST CHARACTER OF A RECORD IS NUMBER 1."; 
              QUERY$LLINE[1] = 48;
              QUERY$NLINES = 1; 
              S$PTQUE(QUERY$);    # SEND QUERY TO USER #
  
              FOR I = 1 STEP 1 UNTIL NKEYFIELDS DO
                  BEGIN 
  
                  GROUP = S$NEWGR;
                  RP$GROUP = GROUP; 
                  RP$TYPE = RP$T"KEYCOLSEQ";
                  RP$VALUEC = "ASCII6"; 
                  GKSW = 16;   # GOTASCII6 #
#***#             RETURN; 
  
GOTASCII6:  
                  RP$TYPE = RP$T"KEYTYPE";
                  RP$VALUE = KT$T"DISPLAY"; 
                  GKSW = 6;   # GTKYLOC6 #
#***#             RETURN; 
  
  
GTKYLOC6: 
                  QUERY$LINE[1] = "FOR THE "; 
                  C<8,11>QUERY$LINE[1] = NAMEOFNUM[I];
                  L = 8 + LENGTHOFNAME[I];
                  C<L,45>QUERY$LINE[1] =
                        " MOST IMPORTANT KEY FIELD, WHAT IS THE NUMBER";
                  QUERY$LLINE[1] = L + 45;
                  QUERY$LINE[2] = "OF THE LEFT MOST CHARACTER ";
                  QUERY$LLINE[2] = 27;
                  QUERY$NLINES = 2; 
                  S$ANSNM(QUERY$, NUM); 
                  RP$TYPE = RP$T"KEYBYTEPOS"; 
                  RP$VALUE = NUM; 
                  GKSW = 7;    # GTKYLOC7 # 
#***#             RETURN; 
  
# GET NO OF CHARACTERS IN THE KEY FIELDS IN ORDER OF IMPORTANCE        #
  
GTKYLOC7: 
                  QUERY$LINE[1] = "HOW MANY CHARACTERS ARE IN THE ";
                  C<31,11>QUERY$LINE[1] = NAMEOFNUM[I]; 
                  L = 31 + LENGTHOFNAME[I]; 
                  C<L,25>QUERY$LINE[1] = " MOST IMPORTANT KEY FIELD"; 
                  QUERY$LLINE[1] = L + 25;
                  QUERY$NLINES = 1; 
                  S$ANSNM(QUERY$, NUM); 
                  RP$TYPE = RP$T"KEYNBYTES";
                  RP$VALUE = NUM; 
                  GKSW = 8;    # GTKYLOC8 # 
#***#             RETURN; 
  
GTKYLOC8: 
                  GKSW = 9;    # GTKYLOC9 # 
                  IF NOT ALLKEYASC THEN 
                      BEGIN 
                      QUERY$LINE[1] = 
          "DO YOU WANT THIS KEY FIELD SORTED IN ASCENDING ORDER"; 
                      QUERY$LLINE[1] = 52;
                      QUERY$NLINES = 1; 
                      S$HLP = 360;
                      S$ANSYN(QUERY$, YES); 
                      IF NOT YES THEN 
                          RP$TYPE = RP$T"KEYORDER"; 
#***#                 RETURN; 
                      END 
  
GTKYLOC9: 
                  END    # FOR LOOP # 
  
              END    # ALL KEYS CHARACTERS #
  
  
# SET RP$TYPE TO $END$ TO INDICATE END OF S$GTIKY                      #
  
GTIKYEND:   
          RP$TYPE = RP$T"$END$";
#***#     RETURN; 
  
          END # S$GTIKY # 
          TERM
