*DECK CHKRW 
USETEXT CCTTEXT 
USETEXT SSTEXT
          PROC  CHKRW;
  
#**       CHKRW -  CHECK FOR RESERVED WORD                             #
#                                                                      #
#     CALLING FORM-                                                    #
#         CHKRW                                                        #
#                                                                      #
#     GIVEN-                                                           #
#         SAREA = 26-WORD AREA CONTAINING CHARACTERS OF TOKEN,         #
#           LEFT-JUSTIFIED, BLANK-FILLED.                              #
#         SAREALENGTH = NUMBER OF CHARACTERS IN *SAREA*.               #
#         BMARGIN = BEGINNING COLUMN NUMBER OF AREA B.                 #
#         RWINFOV = INFORMATION ABOUT RESERVED WORDS.                  #
#         ILITISPNREF = TRUE IFF ILIT IS A PNREF.                      #
#         AWISPNREF = TRUE IFF AW IS A PNREF.                          #
#         CURRENTDIV = CURRENT SOURCE DIVISION.                        #
#                                                                      #
#     DOES-                                                            #
#         IF RESERVED WORD,                                            #
#           CLATYPE = TKNTYPE"REWD"                                    #
#           CLAVALUE = ORDINAL OF RESERVED WORD.                       #
#         IF FIGURATIVE CONSTANT,                                      #
#           CLATYPE = TKYTYPE"FIGCON",                                 #
#           CLAVALUE = ORDINAL OF RESERVED WORD.                       #
#         IF SPECIAL REGISTER,                                         #
#           CLATYPE = TKNTYPE"SPECREG",                                #
#           CLAVALUE = ORDINAL OF RESERVED WORD.                       #
  
  
          BEGIN 
  
          XREF               # INPUT VARIABLES                         #
              BEGIN 
              ITEM  AWISPNREF    B;    # TRUE IFF AN AW IS A PNREF     #
              ITEM  BMARGIN      U;    # BEGINNING COL. NO. OF AREA B  #
              ITEM  CURRENTDIV   U;    # CURRENT SOURCE DIVISION       #
              ITEM  ILITISPNREF  B;    # TRUE IFF AN ILIT IS A PNREF   #
              END 
  
          XREF               # EXTERNAL PROCEDURES                     #
              BEGIN 
              PROC  INTERCEPTOR;                 # ISSUE DIAGNOSTIC    #
              PROC  RWSRCH1;           # SEARCH FOR RW 1-10 CHARS LONG #
              PROC  RWSRCH2;           # SEARCH FOR RW 11-20 CHARS LONG#
              END 
  
  
  
  
*CALL RW
  
*CALL RWINFOV 
  
  
          DEF  TERR          #5#;      # TRIVIAL ERROR CODE            #
          DEF  DIAGNOS(SEV,NUM,LINE,COL)
                                   #INTERCEPTOR(COL,LINE,NUM-1000,SEV)#;
  
          STATUS  TKNTYPE 
*CALL TKNTYPE 
  
          DEF CNTONEA #24#; 
          ARRAY  RWONEA[1:CNTONEA]; 
              ITEM  RESONEA  C(0,0,10) = [
                    "ACCEPT    ", 
                    "ACCESS    ", 
                    "ACTUAL-KEY", 
                    "ADDRESS   ", 
                    "ADD       ", 
                    "ADVANCING ", 
                    "AFTER     ", 
                    "ALL       ", 
                    "ALPHABETIC", 
                    "ALPHABET  ", 
                    "ALSO      ", 
                    "ALTERNATE ", 
                    "ALTER     ", 
                    "AND       ", 
                    "ANY       ", 
                    "APOSTROPHE", 
                    "APPLY     ", 
                    "AREAS     ", 
                    "AREA      ", 
                    "ARE       ", 
                    "ASCENDING ", 
                    "ASSIGN    ", 
                    "AT        ", 
                    "AUTHOR    " ]; 
          ARRAY  [1:CNTONEA]; 
              ITEM  RWCODEONEA  = [ 
                    RWACCEPT, 
                    RWACCESS, 
                    RWACTUALKEY,
                    RWADDRESS,
                    RWADD,
                    RWADVANCING,
                    RWAFTER,
                    RWALL,
                    RWALPHABETIC, 
                    RWALPHABET, 
                    RWALSO, 
                    RWALTERNATE,
                    RWALTER,
                    RWAND,
                    RWANY,
                    RWAPOSTROPHE, 
                    RWAPPLY,
                    RWAREAS,
                    RWAREA, 
                    RWARE,
                    RWASCENDING,
                    RWASSIGN, 
                    RWAT, 
                    RWAUTHOR ]; 
  
          DEF  CNTTWOA  #2#;
          ARRAY  RWTWOA[1:CNTTWOA] S(2);
              ITEM  RESTWOA  C(0,0,20) = [
                    "ALPHANUMERIC-EDITED ", 
                    "ALPHANUMERIC        " ]; 
          ARRAY  [1:CNTTWOA]; 
              ITEM  RWCODETWOA = [
                    RWALPHANUMED, 
                    RWALPHANUMER ]; 
  
          DEF  CNTONEB #8#; 
          ARRAY  RWONEB[1:CNTONEB]; 
              ITEM  RESONEB  C(0,0,10) = [
                    "BEFORE    ", 
                    "BEGINNING ", 
                    "BLANK     ", 
                    "BLOCK     ", 
                    "BOOLEAN-OR", 
                    "BOOLEAN   ", 
                    "BOTTOM    ", 
                    "BY        " ]; 
          ARRAY  [1:CNTONEB]; 
              ITEM  RWCODEONEB = [
                    RWBEFORE, 
                    RWBEGINNING,
                    RWBLANK,
                    RWBLOCK,
                    RWBOOLEANOR,
                    RWBOOLEAN,
                    RWBOTTOM, 
                    RWBY ]; 
  
          DEF CNTTWOB #3#;
          ARRAY RWTWOB [1:CNTTWOB] S(2);
          ITEM RESTWOB C(0,0,20) = [
                    "BOOLEAN-AND         ", 
                    "BOOLEAN-EXOR        ", 
                    "BOOLEAN-NOT         " ]; 
          ARRAY [1:CNTTWOB];
          ITEM RWCODETWOB = [ 
                    RWBOOLEANAND, 
                    RWBOOLEANXOR, 
                    RWBOOLEANNOT ]; 
  
          DEF CNTONEC #28#; 
          ARRAY  RWONEC[1:CNTONEC]; 
              ITEM  RESONEC  C(0,0,10) = [
                    "CALL      ", 
                    "CANCEL    ", 
                    "CD        ", 
                    "CF        ", 
                    "CHARACTERS", 
                    "CHARACTER ", 
                    "CH        ", 
                    "CLOSE     ", 
                    "COBOL     ", 
                    "CODE-SET  ", 
                    "CODE      ", 
                    "COLLATING ", 
                    "COLUMN    ", 
                    "COMMA     ", 
                    "COMPUTE   ", 
                    "COMP-1    ", 
                    "COMP-2    ", 
                    "COMP-4    ", 
                    "COMP      ", 
                    "CONTAINS  ", 
                    "CONTINUE  ", 
                    "CONTROLS  ", 
                    "CONTROL   ", 
                    "CONVERSION", 
                    "COPY      ", 
                    "CORR      ", 
                    "COUNT     ", 
                    "CURRENCY  " ]; 
          ARRAY  [1:CNTONEC]; 
              ITEM  RWCODEONEC = [
                    RWCALL, 
                    RWCANCEL, 
                    RWCD, 
                    RWCF, 
                    RWCHARACTERS, 
                    RWCHARACTER,
                    RWCH, 
                    RWCLOSE,
                    RWCOBOL,
                    RWCODESET,
                    RWCODE, 
                    RWCOLLATING,
                    RWCOLUMN, 
                    RWCOMMA,
                    RWCOMPUTE,
                    RWCOMP1,
                    RWCOMP2,
                    RWCOMP4,
                    RWCOMP, 
                    RWCONTAINS, 
                    RWCONTINUE, 
                    RWCONTROLS, 
                    RWCONTROL,
                    RWCONVERSION, 
                    RWCOPY, 
                    RWCORR, 
                    RWCOUNT,
                    RWCURRENCY ]; 
  
          DEF  CNTTWOC  #9#;
          ARRAY  RWTWOC[1:CNTTWOC] S(2);
              ITEM  RESTWOC  C(0,0,20) = [
                    "CLOCK-UNITS         ", 
                    "COMMON-STORAGE      ", 
                    "COMMUNICATION       ", 
                    "COMPUTATIONAL-1     ", 
                    "COMPUTATIONAL-2     ", 
                    "COMPUTATIONAL-4     ", 
                    "COMPUTATIONAL       ", 
                    "CONFIGURATION       ", 
                    "CORRESPONDING       "];
          ARRAY [1:CNTTWOC];
              ITEM  RWCODETWOC = [
                    RWCLOCKUNITS, 
                    RWCOMMONSTOR, 
                    RWCOMMUNICAT, 
                    RWCOMP1,
                    RWCOMP2,
                    RWCOMP4,
                    RWCOMP, 
                    RWCONFIGURAT, 
                    RWCORR ]; 
  
         DEF  CNTONED  #23#;
          ARRAY  RWONED[1:CNTONED]; 
              ITEM  RESONED  C(0,0,10) = [
                    "DATA      ", 
                    "DATE      ", 
                    "DAY       ", 
                   "DEADLOCK  ",
                    "DEBUGGING ", 
                    "DEBUG-ITEM", 
                    "DEBUG-LINE", 
                    "DEBUG-NAME", 
                    "DELETE    ", 
                    "DELIMITED ", 
                    "DELIMITER ", 
                    "DEPENDING ", 
                    "DESCENDING", 
                    "DETAIL    ", 
                    "DE        ", 
                    "DIRECT    ", 
                    "DISABLE   ", 
                    "DISPLAY   ", 
                    "DIVIDE    ", 
                    "DIVISION  ", 
                    "DOWN      ", 
                    "DUPLICATES", 
                    "DYNAMIC   " ]; 
          ARRAY  [1:CNTONED]; 
              ITEM  RWCODEONED = [
                    RWDATA, 
                    RWDATE, 
                    RWDAY,
                   RWDEADLOCK,
                    RWDEBUGGING,
                    RWDEBUGITEM,
                    RWDEBUGLINE,
                    RWDEBUGNAME,
                    RWDELETE, 
                    RWDELIMITED,
                    RWDELIMITER,
                    RWDEPENDING,
                    RWDESCENDING, 
                    RWDETAIL, 
                    RWDE, 
                    RWDIRECT, 
                    RWDISABLE,
                    RWDISPLAY,
                    RWDIVIDE, 
                    RWDIVISION, 
                    RWDOWN, 
                    RWDUPLICATES, 
                    RWDYNAMIC]; 
  
          DEF  CNTTWOD  #10#; 
          ARRAY  RWTWOD[1:CNTTWOD] S(2);
              ITEM  RESTWOD  C(0,0,20) = [
                    "DATE-COMPILED       ", 
                    "DATE-WRITTEN        ", 
                    "DAY-OF-WEEK         ", 
                    "DEBUG-CONTENTS      ", 
                    "DEBUG-SUB-1         ", 
                    "DEBUG-SUB-2         ", 
                    "DEBUG-SUB-3         ", 
                    "DECIMAL-POINT       ", 
                    "DECLARATIVES        ", 
                    "DESTINATION         " ]; 
  
          ARRAY  [1:CNTTWOD]; 
              ITEM  RWCODETWOD = [
                    RWDATECOMPIL, 
                    RWDATEWRITTE, 
                    RWDAYOFWEEK,
                    RWDEBUGCONTE, 
                    RWDEBUGSUB1,
                    RWDEBUGSUB2,
                    RWDEBUGSUB3,
                    RWDECIMALPOI, 
                    RWDECLARATIV, 
                    RWDESTINATIO ]; 
  
          DEF  CNTONEE #21#;
          ARRAY  RWONEE[1:CNTONEE]; 
              ITEM  RESONEE  C(0,0,10) = [
                    "EGI       ", 
                    "ELSE      ", 
                    "EMI       ", 
                    "ENABLE    ", 
                    "ENDING    ", 
                    "END-IF    ", 
                    "END-SEARCH", 
                    "END       ", 
                    "ENTER     ", 
                    "EOP       ", 
                    "EQUALS    ", 
                    "EQUAL     ", 
                    "ERROR     ", 
                    "ESI       ", 
                    "EVERY     ", 
                    "EXCEEDS   ", 
                    "EXCEPTION ", 
                    "EXIT      ", 
                    "EXOR      ", 
                    "EXTEND    ", 
                    "EXTERNAL  "];
          ARRAY  [1:CNTONEE]; 
              ITEM  RWCODEONEE = [
                    RWEGI,
                    RWELSE, 
                    RWEMI,
                    RWENABLE, 
                    RWENDING, 
                    RWENDIF,
                    RWENDSEARCH,
                    RWEND,
                    RWENTER,
                    RWEOP,
                    RWEQUALS, 
                    RWEQUAL,
                    RWERROR,
                    RWESI,
                    RWEVERY,
                    RWEXCEEDS,
                    RWEXCEPTION,
                    RWEXIT, 
                    RWEXOR, 
                    RWEXTEND, 
                   RWEXTERNAL]; 
  
          DEF  CNTTWOE #3#; 
          ARRAY  RWTWOE[1:CNTTWOE] S(2);
              ITEM  RESTWOE  C(0,0,20) = [
                    "END-OF-PAGE         ", 
                    "END-PERFORM         ", 
                    "ENVIRONMENT         " ]; 
          ARRAY  [1:CNTTWOE]; 
              ITEM  RWCODETWOE = [
                    RWEOP,
                    RWENDPERFORM, 
                    RWENVIRONMEN ]; 
  
          DEF CNTONEF #10#; 
          ARRAY  RWONEF[1:CNTONEF]; 
              ITEM  RESONEF  C(0,0,10) = [
                    "FALSE     ", 
                    "FD        ", 
                    "FILES     ", 
                    "FILE      ", 
                    "FILLER    ", 
                    "FINAL     ", 
                    "FIRST     ", 
                    "FOOTING   ", 
                    "FOR       ", 
                    "FROM      " ]; 
          ARRAY  [1:CNTONEF]; 
              ITEM  RWCODEONEF = [
                    RWFALSE,
                    RWFD, 
                    RWFILES,
                    RWFILE, 
                    RWFILLER, 
                    RWFINAL,
                    RWFIRST,
                    RWFOOTING,
                    RWFOR,
                    RWFROM ]; 
  
          DEF  CNTTWOF  #1#;
          ARRAY  RWTWOF[1:CNTTWOF] S(2);
              ITEM  RESTWOF  C(0,0,20) = [
                    "FILE-CONTROL        " ]; 
          ARRAY  [1:CNTTWOF]; 
              ITEM  RWCODETWOF = [
                    RWFILECONTRO ]; 
  
          DEF  CNTONEG  #5#;
          ARRAY  RWONEG[1:CNTONEG]; 
              ITEM  RESONEG  C(0,0,10) = [
                    "GENERATE  ", 
                    "GIVING    ", 
                    "GO        ", 
                    "GREATER   ", 
                    "GROUP     " ]; 
          ARRAY  [1:CNTONEG]; 
              ITEM  RWCODEONEG = [
                    RWGENERATE, 
                    RWGIVING, 
                    RWGO, 
                    RWGREATER,
                    RWGROUP]; 
  
  
          DEF CNTONEH #3#;
          ARRAY  RWONEH[1:CNTONEH]; 
              ITEM  RESONEH  C(0,0,10) = [
                    "HASHING   ", 
                    "HEADING   ", 
                    "HIGH-VALUE"];
          ARRAY  [1:CNTONEH]; 
              ITEM  RWCODEONEH = [
                    RWHASHING,
                    RWHEADING,
                    RWHIGHVALUE]; 
  
          DEF  CNTTWOH  #2#;
          ARRAY  RWTWOH[1:CNTTWOH] S(2);
              ITEM  RESTWOH  C(0,0,20) = [
                    "HASHED-VALUE        ", 
                    "HIGH-VALUES         "];
          ARRAY  [1:CNTTWOH]; 
              ITEM  RWCODETWOH = [
                    RWHASHEDVALU, 
                    RWHIGHVALUE ];
          DEF  CNTONEI  #14#; 
          ARRAY  RWONEI[1:CNTONEI]; 
              ITEM  RESONEI  C(0,0,10) = [
                    "IF        ", 
                    "INDEXED   ", 
                    "INDEX     ", 
                    "INDICATE  ", 
                    "INITIALIZE", 
                    "INITIAL   ", 
                    "INITIATE  ", 
                    "INPUT     ", 
                    "INSPECT   ", 
                    "INTO      ", 
                    "INVALID   ", 
                    "IN        ", 
                    "IS        ", 
                    "I-O       " ]; 
          ARRAY  [1:CNTONEI]; 
              ITEM  RWCODEONEI = [
                    RWIF, 
                    RWINDEXED,
                    RWINDEX,
                    RWINDICATE, 
                    RWINITIALIZE, 
                    RWINITIAL,
                    RWINITIATE, 
                    RWINPUT,
                    RWINSPECT,
                    RWINTO, 
                    RWINVALID,
                    RWIN, 
                    RWIS, 
                    RWIO ]; 
  
          DEF  CNTTWOI  #4#;
          ARRAY  RWTWOI[1:CNTTWOI] S(2);
              ITEM  RESTWOI  C(0,0,20) = [
                    "IDENTIFICATION      ", 
                    "INPUT-OUTPUT        ", 
                    "INSTALLATION        ", 
                    "I-O-CONTROL         " ]; 
          ARRAY  [1:CNTTWOI]; 
              ITEM  RWCODETWOI = [
                    RWIDENTIFICA, 
                    RWINPUTOUTPU, 
                    RWINSTALLATI, 
                    RWIOCONTROL ];
  
          DEF  CNTONEJ  #2#;
          ARRAY  RWONEJ[1:CNTONEJ]; 
              ITEM  RESONEJ  C(0,0,10) = [
                    "JUSTIFIED ", 
                    "JUST      " ]; 
          ARRAY  [1:CNTONEJ]; 
              ITEM  RWCODEONEJ = [
                    RWJUSTIFIED,
                    RWJUST, ];
  
  
          DEF  CNTONEK  #1#;
          ARRAY  RWONEK[1:CNTONEK]; 
              ITEM  RESONEK  C(0,0,10) = [
                    "KEY       " ]; 
          ARRAY  [1:CNTONEK]; 
              ITEM  RWCODEONEK = [
                    RWKEY ];
  
  
          DEF  CNTONEL  #15#; 
          ARRAY  RWONEL[1:CNTONEL]; 
              ITEM  RESONEL  C(0,0,10) = [
                    "LABEL     ", 
                    "LAST      ", 
                    "LEADING   ", 
                    "LEFT      ", 
                    "LENGTH    ", 
                    "LESS      ", 
                    "LIMITS    ", 
                    "LIMIT     ", 
                    "LINAGE    ", 
                    "LINES     ", 
                    "LINE      ", 
                    "LINKAGE   ", 
                    "LOCK      ", 
                    "LOW-VALUES", 
                    "LOW-VALUE " ]; 
          ARRAY  [1:CNTONEL]; 
              ITEM  RWCODEONEL = [
                    RWLABEL,
                    RWLAST, 
                    RWLEADING,
                    RWLEFT, 
                    RWLENGTH, 
                    RWLESS, 
                    RWLIMITS, 
                    RWLIMIT,
                    RWLINAGE, 
                    RWLINES,
                    RWLINE, 
                    RWLINKAGE,
                    RWLOCK, 
                    RWLOWVALUES,
                    RWLOWVALUE ]; 
  
          DEF  CNTTWOL  #2#;
          ARRAY  RWTWOL[1:CNTTWOL] S(2);
              ITEM  RESTWOL  C(0,0,20) = [
                    "LINAGE-COUNTER      ", 
                    "LINE-COUNTER        " ]; 
          ARRAY  [1:CNTTWOL]; 
              ITEM  RWCODETWOL = [
                    RWLINAGECOUN, 
                    RWLINECOUNTE ]; 
  
          DEF  CNTONEM  #8#;
          ARRAY  RWONEM[1:CNTONEM]; 
              ITEM  RESONEM  C(0,0,10) = [
                    "MEMORY    ", 
                    "MERGE     ", 
                    "MESSAGE   ", 
                    "MODE      ", 
                    "MODULES   ", 
                    "MOVE      ", 
                    "MULTIPLE  ", 
                    "MULTIPLY  " ]; 
          ARRAY  [1:CNTONEM]; 
              ITEM  RWCODEONEM = [
                    RWMEMORY, 
                    RWMERGE,
                    RWMESSAGE,
                    RWMODE, 
                    RWMODULES,
                    RWMOVE, 
                    RWMULTIPLE, 
                    RWMULTIPLY ]; 
  
  
          DEF  CNTONEN  #7#;
          ARRAY  RWONEN[1:CNTONEN]; 
              ITEM  RESONEN  C(0,0,10) = [
                    "NATIVE    ", 
                    "NEGATIVE  ", 
                    "NEXT      ", 
                    "NOT       ", 
                    "NO        ", 
                    "NUMBER    ", 
                    "NUMERIC   " ]; 
          ARRAY  [1:CNTONEN]; 
              ITEM  RWCODEONEN = [
                    RWNATIVE, 
                    RWNEGATIVE, 
                    RWNEXT, 
                    RWNOT,
                    RWNO, 
                    RWNUMBER, 
                    RWNUMERIC ];
  
          DEF  CNTTWON  #1#;
          ARRAY  RWTWON[1:CNTTWON] S(2);
              ITEM  RESTWON  C(0,0,20) = [
                    "NUMERIC-EDITED      " ]; 
          ARRAY  [1:CNTTWON]; 
              ITEM  RWCODETWON = [
                    RWNUMERICEDI ]; 
  
          DEF  CNTONEO  #11#; 
          ARRAY  RWONEO[1:CNTONEO]; 
              ITEM  RESONEO  C(0,0,10) = [
                    "OCCURS    ", 
                    "OFF       ", 
                    "OF        ", 
                    "OMITTED   ", 
                    "ON        ", 
                    "OPEN      ", 
                    "OPTIONAL  ", 
                    "ORDER     ", 
                    "OR        ", 
                    "OUTPUT    ", 
                    "OVERFLOW  " ]; 
          ARRAY  [1:CNTONEO]; 
              ITEM  RWCODEONEO = [
                    RWOCCURS, 
                    RWOFF,
                    RWOF, 
                    RWOMITTED,
                    RWON, 
                    RWOPEN, 
                    RWOPTIONAL, 
                    RWORDER,
                    RWOR, 
                    RWOUTPUT, 
                    RWOVERFLOW ]; 
  
          DEF  CNTTWOO  #3#;
          ARRAY  RWTWOO[1:CNTTWOO] S(2);
              ITEM  RESTWOO  C(0,0,20) =  [ 
                    "OBJECT-COMPUTER     ", 
                    "OBJECT-PROGRAM      ", 
                    "ORGANIZATION        " ]; 
          ARRAY  [1:CNTTWOO]; 
              ITEM  RWCODETWOO = [
                    RWOBJECTCOMP, 
                    RWOBJECTPROG, 
                    RWORGANIZATI ]; 
  
         DEF CNTONEP #17#;
          ARRAY  RWONEP[1:CNTONEP]; 
              ITEM  RESONEP  C(0,0,10) = [
                    "PAGE      ", 
                    "PERFORM   ", 
                    "PF        ", 
                    "PH        ", 
                    "PICTURE   ", 
                    "PIC       ", 
                    "PLUS      ", 
                    "POINTER   ", 
                    "POSITION  ", 
                    "POSITIVE  ", 
                    "PRINTING  ", 
                    "PROCEDURES", 
                    "PROCEDURE ", 
                    "PROCEED   ", 
                    "PROGRAM-ID", 
                   "PROGRAM   ",
                   "PURGE     "]; 
          ARRAY  [1:CNTONEP]; 
              ITEM  RWCODEONEP = [
                    RWPAGE, 
                    RWPERFORM,
                    RWPF, 
                    RWPH, 
                    RWPICTURE,
                    RWPIC,
                    RWPLUS, 
                    RWPOINTER,
                    RWPOSITION, 
                    RWPOSITIVE, 
                    RWPRINTING, 
                    RWPROCEDURES, 
                    RWPROCEDURE,
                    RWPROCEED,
                    RWPROGRAMID,
                   RWPROGRAM, 
                   RWPURGE ]; 
  
          DEF  CNTTWOP  #1#;
          ARRAY  RWTWOP[1:CNTTWOP] S(2);
              ITEM  RESTWOP  C(0,0,20) = [
                    "PAGE-COUNTER        " ]; 
          ARRAY  [1:CNTTWOP]; 
              ITEM  RWCODETWOP = [
                    RWPAGECOUNTE ]; 
  
          DEF  CNTONEQ  #3#;
          ARRAY  RWONEQ[1:CNTONEQ]; 
              ITEM  RESONEQ = [ 
                    "QUEUE     ", 
                    "QUOTES    ", 
                    "QUOTE     " ]; 
          ARRAY  [1:CNTONEQ]; 
              ITEM  RWCODEONEQ = [
                    RWQUEUE,
                    RWQUOTES, 
                    RWQUOTE ];
  
  
          DEF CNTONER #33#; 
          ARRAY  RWONER[1:CNTONER]; 
              ITEM  RESONER  C(0,0,10) = [
                    "RANDOM    ", 
                    "RD        ", 
                    "READ      ", 
                   "REALMS    ",
                    "RECEIVE   ", 
                    "RECORDING ", 
                    "RECORDS   ", 
                    "RECORD    ", 
                    "REDEFINES ", 
                    "REEL      ", 
                    "REFERENCES", 
                    "RELATIVE  ", 
                    "RELEASE   ", 
                    "REMAINDER ", 
                    "REMOVAL   ", 
                    "RENAMES   ", 
                    "REPLACE   ", 
                    "REPLACING ", 
                    "REPORTING ", 
                    "REPORTS   ", 
                    "REPORT    ", 
                    "RERUN     ", 
                    "RESERVE   ", 
                    "RESET     ", 
                    "RETURN    ", 
                    "REVERSED  ", 
                    "REWIND    ", 
                    "REWRITE   ", 
                    "RF        ", 
                    "RH        ", 
                    "RIGHT     ", 
                    "ROUNDED   ", 
                    "RUN       " ]; 
          ARRAY  [1:CNTONER]; 
              ITEM  RWCODEONER = [
                    RWRANDOM, 
                    RWRD, 
                    RWREAD, 
                   RWREALMS,
                    RWRECEIVE,
                    RWRECORDING,
                    RWRECORDS,
                    RWRECORD, 
                    RWREDEFINES,
                    RWREEL, 
                    RWREFERENCES, 
                    RWRELATIVE, 
                    RWRELEASE,
                    RWREMAINDER,
                    RWREMOVAL,
                    RWRENAMES,
                    RWREPLACE,
                    RWREPLACING,
                    RWREPORTING,
                    RWREPORTS,
                    RWREPORT, 
                    RWRERUN,
                    RWRESERVE,
                    RWRESET,
                    RWRETURN, 
                    RWREVERSED, 
                    RWREWIND, 
                    RWREWRITE,
                    RWRF, 
                    RWRH, 
                    RWRIGHT,
                    RWROUNDED,
                    RWRUN ];
  
  
          DEF  CNTONES  #34#; 
          ARRAY  RWONES[1:CNTONES]; 
              ITEM  RESONES  C(0,0,10) = [
                    "SAME      ", 
                    "SD        ", 
                    "SEARCH    ", 
                    "SECTION   ", 
                    "SECURITY  ", 
                    "SEGMENT   ", 
                    "SELECT    ", 
                    "SEND      ", 
                    "SENTENCE  ", 
                    "SEPARATE  ", 
                    "SEQUENCE  ", 
                    "SEQUENTIAL", 
                    "SET       ", 
                    "SIGN      ", 
                    "SIZE      ", 
                    "SORT-MERGE", 
                    "SORT      ", 
                    "SOURCE    ", 
                    "SPACES    ", 
                    "SPACE     ", 
                    "STANDARD-1", 
                    "STANDARD  ", 
                    "START     ", 
                    "STATUS    ", 
                    "STOP      ", 
                    "STRING    ", 
                    "SUBTRACT  ", 
                    "SUB-SCHEMA", 
                    "SUM       ", 
                    "SUPERVISOR", 
                    "SUPPRESS  ", 
                    "SUSPEND   ", 
                    "SYMBOLIC  ", 
                    "SYNC      " ]; 
          ARRAY  [1:CNTONES]; 
              ITEM  RWCODEONES = [
                    RWSAME, 
                    RWSD, 
                    RWSEARCH, 
                    RWSECTION,
                    RWSECURITY, 
                    RWSEGMENT,
                    RWSELECT, 
                    RWSEND, 
                    RWSENTENCE, 
                    RWSEPARATE, 
                    RWSEQUENCE, 
                    RWSEQUENTIAL, 
                    RWSET,
                    RWSIGN, 
                    RWSIZE, 
                    RWSORTMERGE,
                    RWSORT, 
                    RWSOURCE, 
                    RWSPACES, 
                    RWSPACE,
                    RWSTANDARD1,
                    RWSTANDARD, 
                    RWSTART,
                    RWSTATUS, 
                    RWSTOP, 
                    RWSTRING, 
                    RWSUBTRACT, 
                    RWSUBSCHEMA,
                    RWSUM,
                    RWSUPERVISOR, 
                    RWSUPPRESS, 
                    RWSUSPEND,
                    RWSYMBOLIC, 
                    RWSYNC ]; 
  
          DEF  CNTTWOS  #8#;
          ARRAY  RWTWOS[1:CNTTWOS] S(2);
              ITEM  RESTWOS  C(0,0,20) = [
                    "SECONDARY-STORAGE   ", 
                    "SEGMENT-LIMIT       ", 
                    "SOURCE-COMPUTER     ", 
                    "SPECIAL-NAMES       ", 
                    "SUB-QUEUE-1         ", 
                    "SUB-QUEUE-2         ", 
                    "SUB-QUEUE-3         ", 
                    "SYNCHRONIZED        " ]; 
          ARRAY  [1:CNTTWOS]; 
              ITEM  RWCODETWOS = [
                    RWSECONDARYS, 
                    RWSEGMENTLIM, 
                    RWSOURCECOMP, 
                    RWSPECIALNAM, 
                    RWSUBQUEUE1,
                    RWSUBQUEUE2,
                    RWSUBQUEUE3,
                    RWSYNC ]; 
  
          DEF CNTONET #20#; 
          ARRAY  RWONET[1:CNTONET]; 
              ITEM  RESONET  C(0,0,10) = [
                    "TABLE     ", 
                    "TALLYING  ", 
                    "TAPE      ", 
                    "TERMINAL  ", 
                    "TERMINATE ", 
                    "TEST      ", 
                    "TEXT      ", 
                    "THAN      ", 
                    "THEN      ", 
                    "THROUGH   ", 
                    "THRU      ", 
                    "TIMES     ", 
                    "TIME      ", 
                    "TOP       ", 
                    "TO        ", 
                    "TRACE--OFF", 
                    "TRACE--ON ", 
                    "TRAILING  ", 
                    "TRUE      ", 
                    "TYPE      " ]; 
          ARRAY  [1:CNTONET]; 
              ITEM  RWCODEONET = [
                    RWTABLE,
                    RWTALLYING, 
                    RWTAPE, 
                    RWTERMINAL, 
                    RWTERMINATE,
                    RWTEST, 
                    RWTEXT, 
                    RWTHAN, 
                    RWTHEN, 
                    RWTHROUGH,
                    RWTHRU, 
                    RWTIMES,
                    RWTIME, 
                    RWTOP,
                    RWTO, 
                    RWTRACEOFF, 
                    RWTRACEON,
                    RWTRAILING, 
                    RWTRUE, 
                    RWTYPE ]; 
  
  
          DEF  CNTONEU  #9#;
          ARRAY  RWONEU[1:CNTONEU]; 
              ITEM  RESONEU  C(0,0,10) = [
                    "UNEQUAL   ", 
                    "UNIT      ", 
                    "UNSTRING  ", 
                    "UNTIL     ", 
                    "UPON      ", 
                    "UP        ", 
                    "USAGE     ", 
                    "USE       ", 
                    "USING     " ]; 
          ARRAY  [1:CNTONEU]; 
              ITEM  RWCODEONEU = [
                    RWUNEQUAL,
                    RWUNIT, 
                    RWUNSTRING, 
                    RWUNTIL,
                    RWUPON, 
                    RWUP, 
                    RWUSAGE,
                    RWUSE,
                    RWUSING ];
  
  
          DEF  CNTONEV  #3#;
          ARRAY  RWONEV[1:CNTONEV]; 
              ITEM  RESONEV  C(0,0,10) = [
                    "VALUES    ", 
                    "VALUE     ", 
                    "VARYING   " ]; 
          ARRAY  [1:CNTONEV]; 
              ITEM  RWCODEONEV = [
                    RWVALUES, 
                    RWVALUE,
                    RWVARYING ];
  
          DEF  CNTONEW #4#; 
          ARRAY  RWONEW[1:CNTONEW]; 
              ITEM  RESONEW  C(0,0,10) = [
                    "WHEN      ", 
                    "WITH      ", 
                    "WORDS     ", 
                    "WRITE     " ]; 
          ARRAY  [1:CNTONEW]; 
              ITEM  RWCODEONEW = [
                    RWWHEN, 
                    RWWITH, 
                    RWWORDS,
                    RWWRITE ];
  
          DEF  CNTTWOW  #2#;
          ARRAY  RWTWOW[1:CNTTWOW] S(2);
              ITEM  RESTWOW  C(0,0,20) = [
                    "WORD-ADDRESS        ", 
                    "WORKING-STORAGE     " ]; 
          ARRAY  [1:CNTTWOW]; 
              ITEM  RWCODETWOW = [
                    RWWORDADDRES, 
                    RWWORKINGSTO ]; 
  
          DEF  CNTONEZ  #3#;
          ARRAY  RWONEZ[1:CNTONEZ]; 
              ITEM  RESONEZ  C(0,0,10) = [
                    "ZEROES    ", 
                    "ZEROS     ", 
                    "ZERO      " ]; 
          ARRAY  [1:CNTONEZ]; 
              ITEM  RWCODEONEZ = [
                    RWZEROES, 
                    RWZEROS,
                    RWZERO ]; 
  
  
          ITEM  FOUND        I;        # INDEX TO FOUND RESERVED WORD  #
          DEF  RWLOOKUP(SEARCH,RWLIST,CNT,RWCODELIST) 
              #BEGIN SEARCH(STRINGAREA,RWLIST,CNT,FOUND); 
               IF  FOUND NQ 0  THEN  BEGIN  CLAVALUE=RWCODELIST[FOUND]; 
               GOTO RWFOUND; END  ELSE  GOTO CASEEND; END #;
          SWITCH  LETTER  NULL, A$, B$, C$, D$, E$, F$, G$, H$, I$, J$, 
                                K$, L$, M$, N$, O$, P$, Q$, R$, S$, T$, 
                                U$, V$, W$, X$, Y$, Z$, $0, $1, $2, $3, 
                                $4, $5, $6, $7, $8, $9; 
  
          GOTO  LETTER[C<0,1>SAREA[0]]; 
 A$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEA,CNTONEA,RWCODEONEA) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWOA,CNTTWOA,RWCODETWOA) 
  
 B$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEB,CNTONEB,RWCODEONEB) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWOB,CNTTWOB,RWCODETWOB) 
  
 C$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEC,CNTONEC,RWCODEONEC) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWOC,CNTTWOC,RWCODETWOC) 
  
 D$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONED,CNTONED,RWCODEONED) 
          ELSE
          IF  SAREALENGTH LQ 20 
          THEN
              RWLOOKUP(RWSRCH2,RWTWOD,CNTTWOD,RWCODETWOD) 
          ELSE
              IF  C<0,10>SAREA[0] EQ "DEBUG-NUME" AND 
                  C<0,10>SAREA[1] EQ "RIC-CONTEN" AND 
                  C<0,3>SAREA[2] EQ "TS " 
              THEN
                  BEGIN 
                  CLAVALUE = RWDEBUGNUMER;
                  #DEBUG-NUMERIC-CONTENTS IS NON-STANDARD COBOL#
                  DIAGNOS(TERR,1406,CLALINE,CLACOLUMN); 
                  GOTO  RWFOUND;
                  END 
          GOTO  CASEEND;
  
 E$:  
          IF  SAREALENGTH  LQ 10
          THEN
              RWLOOKUP(RWSRCH1,RWONEE,CNTONEE,RWCODEONEE) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWOE,CNTTWOE,RWCODETWOE) 
  
 F$:  
          IF  SAREALENGTH  LQ 10
          THEN
              RWLOOKUP(RWSRCH1,RWONEF,CNTONEF,RWCODEONEF) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWOF,CNTTWOF,RWCODETWOF) 
  
 G$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEG,CNTONEG,RWCODEONEG) 
          ELSE
              GOTO  CASEEND;
  
 H$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEH,CNTONEH,RWCODEONEH) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWOH,CNTTWOH,RWCODETWOH) 
  
 I$:  
          IF  SAREALENGTH  LQ 10
          THEN
              RWLOOKUP(RWSRCH1,RWONEI,CNTONEI,RWCODEONEI) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWOI,CNTTWOI,RWCODETWOI) 
  
 J$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEJ,CNTONEJ,RWCODEONEJ) 
          ELSE
              GOTO  CASEEND;
  
 K$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEK,CNTONEK,RWCODEONEK) 
          ELSE
              GOTO  CASEEND;
  
 L$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEL,CNTONEL,RWCODEONEL) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWOL,CNTTWOL,RWCODETWOL) 
  
 M$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEM,CNTONEM,RWCODEONEM) 
          ELSE
              GOTO  CASEEND;
  
 N$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEN,CNTONEN,RWCODEONEN) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWON,CNTTWON,RWCODETWON) 
  
 O$:  
          IF  SAREALENGTH  LQ 10
          THEN
              RWLOOKUP(RWSRCH1,RWONEO,CNTONEO,RWCODEONEO) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWOO,CNTTWOO,RWCODETWOO) 
  
 P$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEP,CNTONEP,RWCODEONEP) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWOP,CNTTWOP,RWCODETWOP) 
  
 Q$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEQ,CNTONEQ,RWCODEONEQ) 
          ELSE
              GOTO  CASEEND;
  
 R$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONER,CNTONER,RWCODEONER) 
          ELSE
              GOTO  CASEEND;
  
 S$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONES,CNTONES,RWCODEONES) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWOS,CNTTWOS,RWCODETWOS) 
  
 T$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONET,CNTONET,RWCODEONET) 
          ELSE
              GOTO  CASEEND;
  
 U$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEU,CNTONEU,RWCODEONEU) 
          ELSE
              GOTO  CASEEND;
  
 V$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEV,CNTONEV,RWCODEONEV) 
          ELSE
              GOTO  CASEEND;
  
 W$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEW,CNTONEW,RWCODEONEW) 
          ELSE
              RWLOOKUP(RWSRCH2,RWTWOW,CNTTWOW,RWCODETWOW) 
  
 X$:  
          GOTO   CASEEND; 
  
 Y$:  
          GOTO   CASEEND; 
  
 Z$:  
          IF  SAREALENGTH LQ 10 
          THEN
              RWLOOKUP(RWSRCH1,RWONEZ,CNTONEZ,RWCODEONEZ) 
          ELSE
              GOTO  CASEEND;
 RWFOUND: 
 #   CHECK FOR NON-ANSI WORD HERE # 
          IF RWNONANSI[CLAVALUE] AND CCTAUDIT 
          THEN  GOTO CASEEND; 
          IF RWFIGCON[CLAVALUE]  THEN 
              BEGIN                    # TOKEN IS FIGURATIVE CONSTANT  #
              CLATYPE = TKNTYPE"FIGCON";
              IF CCTFIPSLEVEL LS 3  THEN
                  BEGIN                # SOME FIGCONS ARE ILLEGAL      #
                  IF C<0,12>SAREA[0] EQ "HIGH-VALUES "
                   OR C<0,11>SAREA[0] EQ "LOW-VALUES "
                   OR C<0,7>SAREA[0] EQ "QUOTES " 
                   OR C<0,7>SAREA[0] EQ "SPACES " 
                   OR C<0,7>SAREA[0] EQ "ZEROES " 
                   OR C<0,6>SAREA[0] EQ "ZEROS "  THEN
                      DIAGNOS(TERR, 1403, CLALINE, CLACOLUMN);
                  END 
              END 
          ELSE
              BEGIN                    # NOT A FIGURATIVE CONSTANT     #
              IF RWSPECREG[CLAVALUE]  THEN
                  CLATYPE = TKNTYPE"SPECREG";    # SPECIAL REGISTER    #
              ELSE
                  CLATYPE = TKNTYPE"REWD";       # RESERVED WORD       #
              END 
          RETURN; 
 NULL:  
 $0:  
 $1:  
 $2:  
 $3:  
 $4:  
 $5:  
 $6:  
 $7:  
 $8:  
$9: 
  
          CASEEND:  
  
#     IF IN PROCEDURE DIVISION, DISTINGUISH DNREFS, PNREFS AND PNDEFS  #
  
          IF CURRENTDIV EQ 5  THEN
              BEGIN 
              IF CLACOLUMN LQ BMARGIN  THEN 
                  CLATYPE = TKNTYPE"PNDEF"; 
              ELSE
                  BEGIN 
                  IF AWISPNREF  THEN
                      CLATYPE = TKNTYPE"PNREF"; 
                  END 
              END 
  
          END  #CHKRW#
          TERM
