(*#T-,C0   
%RANGECHECKS=NO
%CHARCODE=EBCDIC
*)   
  
  
PROGRAM ICL9LPJCLPROCS;
 
 
CONST
 
      (* GENERAL:- *)
 
   NILDESC= ?D FFFFFFFFFFFFFFFF;
   MAXINTFORBYTE=255;
   BLANK=' ';
   OPSYSLETTER='B';
 
      (* OPTIONS PROCESSING:- *)
 
   MAXLITIX=16;
   MAXHOLDIX=63;
   BIGINT=256;
   MAXORDFORLITOPT=63;
   BLANKLIT='                ';
   LITVALALL='ALL             ';
   LITVALNONE='NONE            ';
   RANGECHECKSKW='RANGECHECKS     ';
   CHARCODEKW='CHARCODE        ';
   FLOWANALYSESKW='FLOWANALYSES    ';
   DATAKW='RTINPUT         ';
   RESULTSKW='RTOUTPUT        ';
   HEAPSIZEKW='HEAPSIZE        ';
   RETROSIZEKW='RETROBUFSIZE    ';
   STARTFWDKW='STARTFORWARD    ';
   STOPFWDKW='STOPFORWARD     ';
   FLOWANALYSESJSV='ICL9LPRTFLOWOPTS';
   DATAJSV='ICL9LP98        ';
   RESULTSJSV='ICL9LP99        ';
   HEAPSIZEJSV='ICL9LPRHEAP     ';
   RETROSIZEJSV='ICL9LPRTRETROSZ ';
   STARTFWDJSV='ICL9LPRTMINFWD  ';
   STOPFWDJSV='ICL9LPRTMAXFWD  ';
   CCEBCDIC=0;
   CCISO=1;
   CCICL1900=2;
 
      (* ICL RESPONSE VALUES:- *)
 
   JCLCTPARAMERRRESPONSE=37095;
   JCLRTPARAMERRRESPONSE=37094;
   CECOMPERRRESPONSE=4;
   CECOMPILERFAILRESPONSE=5;
   JCLCOMPERRRESPONSE=43240;
   JCLCOMPILERFAILRESPONSE=43241;
 
      (* CE COMPILE-TIME INTERFACE:- *)
 
   PASCALID='PASCAL *20.1 MAL: **** ';
   PASCALIDLEN=23;
   OPSYSIX=8;
   MALSTARTIX=19;
   MALCHARSMAX=3;
   MAXBYTEINCEOPTLIST=17;
 
 
TYPE
 
      (* GENERAL:- *)
 
   POSINT=0..MAXINT;
   BYTE=0..MAXINTFORBYTE;
   WORD= INTEGER;
   ADDRESS= WORD;
   RESPONSE= WORD;
   DESCPT= @DESC;
   BITVDESC= DESC;    (*BIT-VECTOR*)
   BVDESC= DESC;    (*BYTE-VECTOR*)
   LITDESC= BVDESC;
   DWVDESC= DESC;    (*DOUBLE-WORD-VECTOR*)
   ENTRYDESC= DESC;
   SUPERLITDESC= DWVDESC;
   LONGINTDESC= DWVDESC;
   LONGINT= RECORD UH, LH: INTEGER END;
 
      (* OPTIONS PROCESSING:- *)
 
   BIGCOUNT= 0..BIGINT;
   BIGRANGE= 1..BIGINT;
   BIGDESCVEC= ARRAY [BIGRANGE] OF DESC;
   BIGDESCVECPT= @BIGDESCVEC;
   LITCOUNT= 0..MAXLITIX;
   LITIX= 1..MAXLITIX;
   LITERAL= PACKED ARRAY [LITIX] OF CHAR;
   LITERALPT= @LITERAL;
   HOLDCOUNT= 0..MAXHOLDIX;
   HOLDIX= 1..MAXHOLDIX;
   HOLDVEC= ARRAY [HOLDIX] OF LITERAL;
   ORDFORLITOPT= 0..MAXORDFORLITOPT;
   BASICLITOPTSET= SET OF ORDFORLITOPT;
   LITVALLIST= RECORD PREMINIX, MAXIX: HOLDCOUNT END;
   SUPERLITERAL= LITVALLIST;
   JSVNAME= LITERAL;
   JCLKEYWORD= LITERAL;
   BIGSTRING= PACKED ARRAY [BIGRANGE] OF CHAR;
   BIGSTRINGPT= @BIGSTRING;
   ROWOFLITDESC=
      RECORD MAXSIGIX: BIGCOUNT; PTR: BIGDESCVECPT END;
   ROWOFCHAR=
      RECORD MAXSIGIX: LITCOUNT; PTR: LITERALPT END;
   BIGROWOFCHAR=
      RECORD MAXSIGIX: BIGCOUNT; PTR: BIGSTRINGPT END;
   OPTERRCODE=
      (ECHOLDOFLO,ECLONGSUPERLIT,ECBADLITVAL,ECBADSUPERLITVAL,
       ECINTVALRANGE,ECJSWRITE,ECASSIGNFILE);
   FILEACCESS= (READACCESS,WRITEACCESS);
   CHARCODE= CCEBCDIC..CCICL1900;
   PASCALOPT=
      (RANGECHECKSPO,COMPILERPO,LINEMAPPO,PMDUMPPO,KEYEDENTRYPO,
       SOURCELISTPO,OBJECTLISTPO,PROFILEPO,RETROTRACEPO,FWDTRACEPO,
       NOCODEGENPO);
   SETOFPASCALOPTS= SET OF PASCALOPT;
 
      (* CE COMPILE-TIME INTERFACE:- *)
 
   PRODUCTIDRNG= 1..PASCALIDLEN;
   PRODUCTIDSTRING= PACKED ARRAY [PRODUCTIDRNG] OF CHAR;
   MALCHARSRNG= 0..MALCHARSMAX;
   MALCHARS= ARRAY [MALCHARSRNG] OF CHAR;
   CEOPTLISTBITSRNGB= 0..MAXBYTEINCEOPTLIST;
   CEOPTLISTBITSVEC= PACKED ARRAY [CEOPTLISTBITSRNGB] OF BYTE;
   CECTLINKAREAREC=
      RECORD
         PRODUCTIDRELDESC: LITDESC;
         OPTLISTBITSRELDESC: BITVDESC;
         COMPILERENTRYDESC: ENTRYDESC;
         PRODUCTID: PRODUCTIDSTRING;
         OPTLISTBITS: CEOPTLISTBITSVEC
      END;
 
 
VAR
 
       (* GENERAL:- *)
 
   STACKBASEAD: ADDRESS;
   JCLCOMPILECALL: BOOLEAN;
   OPSYSFLAG: CHAR;
 
       (* OPTIONS PROCESSING:- *)
 
   CURKEYWORD: JCLKEYWORD;
   CURHOLDIX: HOLDCOUNT;
   HOLDLIT: HOLDVEC;
   NOYESVALLIST,
   ABBREVNOYESVALLIST,
   CHARCODEVALLIST,
   FLOWANALYSESVALLIST: LITVALLIST;
   CHARCODEFORCOMPILER: CHARCODE;
   BOOLOPTSFORCOMPILER: SETOFPASCALOPTS;
 
      (* CE C-T INTERFACE:- *)
 
   CECTLINKAREA: CECTLINKAREAREC;
 
 
(******** LOW LEVEL SUPPORT ROUTINE SPECS. ********)
 
 
PROCEDURE ICL9LPEXITWITHRESPATLNB (RESPVAL: RESPONSE; LNBVAL: ADDRESS);
   EXTERN;
 
FUNCTION ICL9LPCURSTACKBASEAD : ADDRESS;
   EXTERN;
 
FUNCTION ICL9LPCTCONTROLENTRYDESC : DESC;
   EXTERN;
 
 
(******** CTM INTERFACE SUPPORT ROUTINE SPECS. ********)
 
 
PROCEDURE ICL9LPCTMJSBEGIN;
   EXTERN;
 
PROCEDURE ICL9LPCTMJSEND;
   EXTERN;
 
PROCEDURE ICL9LPCTMJSWRITEINT (JSVD: LITDESC; LI: LONGINT; VAR R: RESPONSE);
   EXTERN;
 
PROCEDURE ICL9LPCTMAF (FILENAMED: LITDESC; ACCESSMODE: WORD;
                       VAR ROUTE: LONGINT; VAR R: RESPONSE);
   EXTERN;
 
PROCEDURE ICL9LPCTMLOG (MESSD: LITDESC);
   EXTERN;
 
 
(******** CE SUPPORT ROUTINE SPECS. ********)
 
 
FUNCTION ICL9HNCOMPILESUPPORT (
      FLAGS: LITDESC;                   (* 0*)
      LINKAREAAD: ADDRESS;
      INPUTD: SUPERLITDESC;
      OMFD,
      RUND: LITDESC;
      LISTINGSD,
      MESSAGESD: SUPERLITDESC;
      SAVELISTD: LITDESC;
      DIAGNOSTICSD: LONGINTDESC;
      RTCHECKSD: SUPERLITDESC;
      SHARED: LITDESC;                  (*10*)
      OPTD: LONGINTDESC;
      LIBPROCD: LITDESC;
      LENGTHSD,
      ARGUMENTSD,
      TRACED: SUPERLITDESC;
      CANCELD,
      TESTENVD,
      TPD: LITDESC;
      SEPARATEAREASD: LONGINTDESC;
      ITEMSONSTACKD,                    (*20*)
      ERRORCLASSD,
      IGNORED,
      CATCHD,
      EMESSD,
      ROUTED,
      REPORTD,
      COUNTD: LITDESC;
      DEPTHD,
      RDIAGD,
      ARRAYSIZED: LONGINTDESC;          (*30*)
      CONTINUED: LITDESC;
      TRIESD: LONGINTDESC;
      DFILED,
      DEBUGD: LITDESC;
      RTRACED: SUPERLITDESC;
      TFILED: LITDESC;
      BUFFERD,
      MAXLINESD: LONGINTDESC;
      CDIAGD,
      DUMPD,                            (*40*)
      TEMPD,
      CODED: LITDESC;
      GENSKEPTD: LONGINTDESC;
      PROCEDURED,
      DIRECTIVESD: LITDESC;
      TARRAYSIZED: LONGINTDESC;
      UINDICATORSD: SUPERLITDESC;
      LINESD: LONGINTDESC;
      DISPLAYD: SUPERLITDESC            (*49*)
                              ) : RESPONSE;
   EXTERN;
 
FUNCTION ICL9HNRUNSUPPORT (
      PROCEDURED,                       (* 0*)
      ERRORCLASSD,
      IGNORED,
      CATCHD,
      EMESSD,
      ROUTED,
      REPORTD,
      COUNTD: LITDESC;
      DEPTHD,
      DIAGNOSTICD,
      ARRAYSIZED: LONGINTDESC;          (*10*)
      CONTINUED: LITDESC;
      TRIESD: LONGINTDESC;
      DFILED,
      DEBUGD: LITDESC;
      TRACED: SUPERLITDESC;
      TFILED: LITDESC;
      BUFFERD,
      MAXLINESD: LONGINTDESC;
      DUMPD: LITDESC;
      TARRAYSIZE: LONGINTDESC;          (*20*)
      UINDICATORSD: SUPERLITDESC        (*21*)
                             ) : RESPONSE;
   EXTERN;
 
 
(******** FORWARD DECLARATIONS ********)
 
 
PROCEDURE JSEND;
   FORWARD;
 
PROCEDURE OPTERR (EC: OPTERRCODE) ;
   FORWARD;
 
 
(******** ERROR EXIT TO JCL LEVEL ********)
 
 
PROCEDURE ABANDONJCLENTRYPROC;
   VAR
      RESPONSETOJCL: RESPONSE;
   BEGIN
   JSEND;
   IF JCLCOMPILECALL THEN
      RESPONSETOJCL:=JCLCTPARAMERRRESPONSE
   ELSE
      RESPONSETOJCL:=JCLRTPARAMERRRESPONSE;
   ICL9LPEXITWITHRESPATLNB(RESPONSETOJCL,STACKBASEAD);
   END (* ABANDONJCLENTRYPROC *) ;
 
 
(******** LOW-LEVEL TYPE MANIPULATION ********)
 
 
FUNCTION DESCISNULL (D : DESC) : BOOLEAN ;
   CONST
      NEGNULLBND = ?I 800000 ;
   VAR
      DB : WORD ;
   BEGIN
   DB := DEBOUND(D) ;
   DESCISNULL := (DB=0) OR (DB>=NEGNULLBND) ;
   END (* DESCISNULL *) ;
 
FUNCTION SUPERLITDESCISNULL (SLD : DWVDESC) : BOOLEAN ;
   VAR
      BVDESCP : DESCPT ;
   BEGIN
   IF DESCISNULL(SLD) THEN
      SUPERLITDESCISNULL:=TRUE
   ELSE
      BEGIN
      BVDESCP := TYPECONV(DESCPT,DEADDR(SLD)) ;
      SUPERLITDESCISNULL := (DEBOUND(SLD)=1) AND (DEBOUND(BVDESCP@)=0) ;
      END ;
   END (* SUPERLITDESCISNULL *) ;
 
PROCEDURE LITDESCTOROW (LITD : LITDESC; VAR ROW : ROWOFCHAR);
   VAR
      DB : WORD ;
   BEGIN
   WITH ROW DO
      IF DESCISNULL(LITD) THEN
         BEGIN MAXSIGIX:=0; PTR:=NIL END
      ELSE
         BEGIN
         DB := DEBOUND(LITD) ;
         IF DB>MAXLITIX THEN MAXSIGIX:=MAXLITIX ELSE MAXSIGIX:=DB ;
         PTR := TYPECONV(LITERALPT, DEADDR(LITD)) ;
         END ;
   END (* LITDESCTOROW *) ;
 
PROCEDURE SUPERLITDESCTOROW (SUPERLITDESC : DWVDESC; VAR ROW : ROWOFLITDESC) ;
   VAR
      DB : WORD ;
   BEGIN
   WITH ROW DO
      IF SUPERLITDESCISNULL(SUPERLITDESC) THEN
         BEGIN MAXSIGIX:=0; PTR:=NIL END
      ELSE
         BEGIN
         DB := DEBOUND(SUPERLITDESC) ;
         IF DB>BIGINT THEN MAXSIGIX:=BIGINT ELSE MAXSIGIX:=DB ;
         PTR := TYPECONV(BIGDESCVECPT,DEADDR(SUPERLITDESC)) ;
         END
   END (* SUPERLITDESCTOROW *) ;
 
PROCEDURE DESCTOLIT (D: LITDESC; VAR LIT: LITERAL) ;
   VAR
      ROW: ROWOFCHAR;
      I: LITIX;
   BEGIN
   LIT:=BLANKLIT;
   LITDESCTOROW(D,ROW);
   WITH ROW DO
      FOR I:=1 TO MAXSIGIX DO LIT[I]:=PTR@[I];
   END (* DESCTOLIT *) ;
 
FUNCTION SIGLITLEN (LIT : LITERAL) : LITCOUNT;
   VAR
      I : LITCOUNT;
   BEGIN
   IF LIT[1]=BLANK THEN
      I:=0
   ELSE
      BEGIN
      I:=MAXLITIX;
      WHILE LIT[I]=BLANK DO I:=I-1;
      END ;
   SIGLITLEN:=I
   END (* SIGLITLEN *) ;
 
FUNCTION LITDESCFORLIT (VAR LIT : LITERAL) : LITDESC ;
   CONST
      DETPBV = ?I 18000000;
   VAR
      D : DESC;
   BEGIN
   DEVARSETUP(D, DETPBV, SIGLITLEN(LIT), ADDRESSOF(LIT));
   LITDESCFORLIT:=D;
   END (* LITDESCFORLIT *) ;
 
FUNCTION LITDESCFORJSV (VAR JSV : JSVNAME) : LITDESC ;
   BEGIN
   LITDESCFORJSV:=LITDESCFORLIT(JSV);
   END (* LITDESCFORJSV *) ;
 
PROCEDURE BIGSTRINGTOEMPTYROW (VAR S: BIGSTRING; VAR ROW: BIGROWOFCHAR) ;
   BEGIN
   WITH ROW DO
      BEGIN
      MAXSIGIX:=0;
      PTR:=TYPECONV(BIGSTRINGPT,ADDRESSOF(S));
      END;
   END (* BIGSTRINGTOEMPTYROW *) ;
 
PROCEDURE LITDESCTOBIGROW (LITD: LITDESC; VAR ROW: BIGROWOFCHAR) ;
   VAR
      DB: WORD;
   BEGIN
   WITH ROW DO
      IF DESCISNULL(LITD) THEN
         BEGIN MAXSIGIX:=0; PTR:=NIL END
      ELSE
         BEGIN
         DB:=DEBOUND(LITD);
         IF DB>BIGINT THEN MAXSIGIX:=BIGINT ELSE MAXSIGIX:=DB ;
         PTR:=TYPECONV(BIGSTRINGPT,DEADDR(LITD));
         END;
   END (* LITDESCTOBIGROW *) ;
 
FUNCTION LITDESCFORBIGROW (ROW: BIGROWOFCHAR) : LITDESC;
   CONST
      DETPBV=?I 18000000;
   VAR
      D: DESC;
      AD: ADDRESS;
   BEGIN
   WITH ROW DO
      BEGIN
      AD:=TYPECONV(ADDRESS,PTR);
      DEVARSETUP(D,DETPBV,MAXSIGIX,AD);
      END;
   LITDESCFORBIGROW:=D;
   END (* LITDESCFORBIGROW *) ;
 
PROCEDURE APPENDBIGROWS (NEW: BIGROWOFCHAR; VAR OLD: BIGROWOFCHAR) ;
   VAR
      OLDIX, NEWIX: BIGCOUNT;
   BEGIN
   OLDIX:=OLD.MAXSIGIX;  NEWIX:=0;
   WHILE (NEWIX<NEW.MAXSIGIX) AND (OLDIX<BIGINT) DO
      BEGIN
      OLDIX:=OLDIX+1;  NEWIX:=NEWIX+1;
      OLD.PTR@[OLDIX]:=NEW.PTR@[NEWIX];
      END;
   OLD.MAXSIGIX:=OLDIX;
   END (* APPENDBIGROWS *) ;
 
FUNCTION LIDESCFORLI (VAR LI: LONGINT) : LONGINTDESC ;
   CONST
      DETPDWV=?I 30000000;
   VAR
      D: DESC;
   BEGIN
   DEVARSETUP(D,DETPDWV,1,ADDRESSOF(LI));
   LIDESCFORLI:=D;
   END (* LIDESCFORLI *) ;
  
 
(******** CTM INTERFACE ********)
 
 
PROCEDURE JSBEGIN;
   BEGIN
   ICL9LPCTMJSBEGIN;
   END (* JSBEGIN *) ;
 
PROCEDURE JSEND;   (*FORWARD-DECLARED*)
   BEGIN
   ICL9LPCTMJSEND;
   END (* JSEND *) ;
 
PROCEDURE WRITEINTJSV (JSV : JSVNAME; JSVVAL : LONGINT) ;
   VAR
      RESULT : RESPONSE;
   BEGIN
   ICL9LPCTMJSWRITEINT(LITDESCFORJSV(JSV), JSVVAL, RESULT);
   IF RESULT>0 THEN OPTERR(ECJSWRITE)
   END (* WRITEINTJSV *) ;
 
PROCEDURE WRITEOPTSETJSV (JSV : JSVNAME; VAL : SETOFPASCALOPTS) ;
   VAR
      LIVAL : LONGINT ;
   BEGIN
   LIVAL:=TYPECONV(LONGINT,VAL);
   WRITEINTJSV(JSV,LIVAL);
   END (* WRITEOPTSETJSV *) ;
 
PROCEDURE ASSIGNFILE (NAMED: LITDESC; ACCESS: FILEACCESS; VAR ROUTE: LONGINT) ;
   CONST
      READMASK=1;  (* CTM "READ" ACCESS *)
      WRITEMASK=2;  (* CTM "OVERWRITE" ACCESS *)
   VAR
      CTMACCESS: WORD;
      RESULT: RESPONSE;
   BEGIN
   IF ACCESS=READACCESS THEN CTMACCESS:=READMASK ELSE CTMACCESS:=WRITEMASK;
   ICL9LPCTMAF(NAMED,CTMACCESS,ROUTE,RESULT);
   IF RESULT>0 THEN OPTERR(ECASSIGNFILE);
   END (* ASSIGNFILE *) ;
 
PROCEDURE LOG (MESSD: LITDESC) ;
   BEGIN
   ICL9LPCTMLOG(MESSD);
   END (* LOG *) ;
     
 
(******** ERRORS IN OPTIONS ********)
 
 
PROCEDURE OPTERR;   (*FORWARD-DECLARED*)
   (*PARAM. LIST IS :-
                   (EC: OPTERRCODE)
   *)
   CONST
      STARERROR='*ERROR : ';
      KEYWORDIS=' - KEYWORD IS ';
   VAR
      SASBR,
      STARERRORBR,
      ECDETAILSBR,
      KEYWORDISBR,
      CURKEYWORDBR: BIGROWOFCHAR;
      ECDETAILSD: LITDESC;
      S: BIGSTRING;
   BEGIN
   LITDESCTOBIGROW(DEREFWITHBND(STARERROR),STARERRORBR);
   CASE EC OF
      ECHOLDOFLO:
      ECDETAILSD:=DEREFWITHBND('PARAMETER LIST TOO BIG');
      ECLONGSUPERLIT:
      ECDETAILSD:=DEREFWITHBND('TOO MANY VALUES');
      ECBADLITVAL, ECBADSUPERLITVAL:
      ECDETAILSD:=DEREFWITHBND('UNRECOGNISED VALUE');
      ECINTVALRANGE:
      ECDETAILSD:=DEREFWITHBND('VALUE OUT OF RANGE');
      ECJSWRITE:
      ECDETAILSD:=DEREFWITHBND('JSV WRITE FAIL');
      ECASSIGNFILE:
      ECDETAILSD:=DEREFWITHBND('ASSIGN FILE FAIL');
      END;
   LITDESCTOBIGROW(ECDETAILSD,ECDETAILSBR);
   LITDESCTOBIGROW(DEREFWITHBND(KEYWORDIS),KEYWORDISBR);
   LITDESCTOBIGROW(LITDESCFORLIT(CURKEYWORD),CURKEYWORDBR);
   BIGSTRINGTOEMPTYROW(S,SASBR);
   APPENDBIGROWS(STARERRORBR,SASBR);
   APPENDBIGROWS(ECDETAILSBR,SASBR);
   APPENDBIGROWS(KEYWORDISBR,SASBR);
   APPENDBIGROWS(CURKEYWORDBR,SASBR);
   LOG(LITDESCFORBIGROW(SASBR));
   ABANDONJCLENTRYPROC;
   END (* OPTERR *) ;
 
(******** LONG INT PROCESSING ********)
 
 
PROCEDURE LONGINTRANGECHECK (LIVAL: LONGINT; LOLIM, HILIM: POSINT) ;
   BEGIN
   WITH LIVAL DO
      IF (UH<>0) OR (LH<LOLIM) OR (LH>HILIM) THEN OPTERR(ECINTVALRANGE);
   END (* LONGINTRANGECHECK *) ;
 
 
(******** LITERAL & SUPERLITERAL PROCESSING ********)
 
 
PROCEDURE STARTLITVALLIST (VAR LIST: LITVALLIST) ;
   BEGIN
   LIST.PREMINIX:=CURHOLDIX;
   END (* STARTLITVALLIST *) ;
 
PROCEDURE ENDLITVALLIST (VAR LIST: LITVALLIST) ;
   BEGIN
   LIST.MAXIX:=CURHOLDIX;
   END (* ENDLITVALLIST *) ;
 
PROCEDURE HOLDNEWLIT (VAL: LITERAL; VAR IX: HOLDIX) ;
   BEGIN
   IF CURHOLDIX<MAXHOLDIX THEN
      BEGIN
      CURHOLDIX:=CURHOLDIX+1;
      HOLDLIT[CURHOLDIX]:=VAL;
      IX:=CURHOLDIX;
      END
   ELSE
      OPTERR(ECHOLDOFLO);
   END (* HOLDNEWLIT *) ;
 
PROCEDURE DISCARDLATESTLITERAL;
   BEGIN
   CURHOLDIX:=CURHOLDIX-1;
   END (* DISCARDLATESTLITERAL *) ;
 
PROCEDURE DISCARDLATESTSUPERLIT (SUPERLIT : SUPERLITERAL) ;
   BEGIN
   CURHOLDIX:=SUPERLIT.PREMINIX;
   END (* DISCARDLATESTSUPERLIT *) ;
 
PROCEDURE LITCONVERTANDHOLD (LITD: LITDESC; VAR LITIX: HOLDIX) ;
   VAR
      LIT: LITERAL;
   BEGIN
   DESCTOLIT(LITD,LIT);
   HOLDNEWLIT(LIT,LITIX);
   END (* LITCONVERTANDHOLD *) ;
 
PROCEDURE SUPERLITCONVERTANDHOLD (SLD: DWVDESC; VAR NEWSL: SUPERLITERAL) ;
   VAR
      JUNKIX: HOLDIX;
      ROW: ROWOFLITDESC;
      I: BIGRANGE;
 
   BEGIN
   STARTLITVALLIST(NEWSL);
   SUPERLITDESCTOROW(SLD,ROW);
   WITH ROW DO
      FOR I:=1 TO MAXSIGIX DO LITCONVERTANDHOLD(PTR@[I],JUNKIX);
   ENDLITVALLIST(NEWSL);
   END (* SUPERLITCONVERTANDHOLD *) ;
 
PROCEDURE CHECKFORPREFIXNO (VAL: LITERAL; VAR NONOVAL: LITERAL;
                            VAR HADPREFIXNO: BOOLEAN) ;
   VAR
      I: LITIX;
   BEGIN
   HADPREFIXNO:=(VAL[1]='N') AND (VAL[2]='O');
   IF HADPREFIXNO THEN
      BEGIN
      FOR I:=3 TO MAXLITIX DO NONOVAL[I-2]:=VAL[I];
      NONOVAL[MAXLITIX-1]:=BLANK;
      NONOVAL[MAXLITIX]:=BLANK;
      END
   ELSE
      NONOVAL:=VAL;
   END (* CHECKFORPREFIXNO *) ;
 
PROCEDURE SEARCHLITLIST (VAL: LITERAL; LIST: LITVALLIST;
                         VAR FOUND: BOOLEAN; VAR ORDFORTHISVAL: ORDFORLITOPT) ;
   VAR
      I: HOLDCOUNT;
      LIM: HOLDIX;
   BEGIN
   FOUND:=FALSE; I:=LIST.PREMINIX;  LIM:=LIST.MAXIX;
   WHILE (I<LIM) AND NOT FOUND DO
      BEGIN
      I:=I+1;
      IF HOLDLIT[I]=VAL THEN
         BEGIN
         FOUND:=TRUE;
         ORDFORTHISVAL:=I-LIST.PREMINIX-1;
         END;
      END
   END (* SEARCHLITLIST *) ;
 
PROCEDURE GETSETFORSUPERLIT (VAL: SUPERLITERAL; VALIDVALUES: LITVALLIST;
                             ALLANDNONEVALSOK, PREFIXNOOK: BOOLEAN;
                             VAR RESULTS: BASICLITOPTSET) ;
   VAR
      BUILDSET: BASICLITOPTSET;
      I: HOLDIX;
      THISVAL: LITERAL;
      HADPREFIXNO, FOUNDVAL: BOOLEAN;
      ORDFORVAL: ORDFORLITOPT;
 
   BEGIN
   BUILDSET:=[];
   FOR I:=VAL.PREMINIX+1 TO VAL.MAXIX DO
      BEGIN
      THISVAL:=HOLDLIT[I];
      IF ALLANDNONEVALSOK AND (THISVAL=LITVALALL) THEN
         BUILDSET:=[0..(VALIDVALUES.MAXIX-VALIDVALUES.PREMINIX-1)]
      ELSE IF ALLANDNONEVALSOK AND (THISVAL=LITVALNONE) THEN
         BUILDSET:=[]
      ELSE
         BEGIN
         IF PREFIXNOOK THEN
            CHECKFORPREFIXNO(THISVAL,THISVAL,HADPREFIXNO)
         ELSE
            HADPREFIXNO:=FALSE;
         SEARCHLITLIST(THISVAL,VALIDVALUES,FOUNDVAL,ORDFORVAL);
         IF NOT FOUNDVAL THEN OPTERR(ECBADSUPERLITVAL);
         IF HADPREFIXNO THEN
            BUILDSET:=BUILDSET-[ORDFORVAL]
         ELSE
            BUILDSET:=BUILDSET+[ORDFORVAL];
         END;
      END;
   RESULTS:=BUILDSET;
   END (* GETSETFORSUPERLIT *) ;
 
PROCEDURE CONVERTTOPASCALOPTS (BASICOPTS: BASICLITOPTSET;
                               BASEPASCALOPT: PASCALOPT;
                               VAR RESULTS: SETOFPASCALOPTS) ;
   CONST
      LASTPASCALOPT=NOCODEGENPO;
   VAR
      I: PASCALOPT;
      BUILDSET: SETOFPASCALOPTS;
 
   BEGIN
   BUILDSET:=[];
   FOR I:=BASEPASCALOPT TO LASTPASCALOPT DO
      IF (ORD(I)-ORD(BASEPASCALOPT)) IN BASICOPTS THEN
         BUILDSET:=BUILDSET+[I];
   RESULTS:=BUILDSET;
   END (* CONVERTTOPASCALOPTS *) ;
 
FUNCTION NOYESVALISSET (VALIX: HOLDIX) : BOOLEAN ;
   VAR
      FOUND: BOOLEAN;
      ORDFORVAL: ORDFORLITOPT;  (*-SHOULD BE JUST 0 OR 1*)
   BEGIN
   SEARCHLITLIST(HOLDLIT[VALIX],NOYESVALLIST,FOUND,ORDFORVAL);
   IF NOT FOUND THEN
      SEARCHLITLIST(HOLDLIT[VALIX],ABBREVNOYESVALLIST,FOUND,ORDFORVAL);
   IF NOT FOUND THEN
      OPTERR(ECBADLITVAL);
   NOYESVALISSET:=(ORDFORVAL>0);
   END (* NOYESVALISSET *) ;
 
FUNCTION ORDFORLITVALIX (IX: HOLDIX; VALIDVALUES: LITVALLIST) : ORDFORLITOPT ;
   VAR
      FOUND: BOOLEAN;
      TEMPORD: ORDFORLITOPT;
   BEGIN
   SEARCHLITLIST(HOLDLIT[IX],VALIDVALUES,FOUND,TEMPORD);
   IF NOT FOUND THEN
      OPTERR(ECBADLITVAL);
   ORDFORLITVALIX:=TEMPORD;
   END (* ORDFORLITVALIX *) ;
 
 
(******** INITIALISATION FOR OPTIONS PROCESSING ********)
 
 
PROCEDURE OPTINITGENERAL;
   VAR
      JUNKIX: HOLDIX;
   BEGIN
   CURHOLDIX:=0;
   CURKEYWORD:=BLANKLIT;
   STARTLITVALLIST(NOYESVALLIST);
   HOLDNEWLIT('NO              ',JUNKIX);
   HOLDNEWLIT('YES             ',JUNKIX);
   ENDLITVALLIST(NOYESVALLIST);
   STARTLITVALLIST(ABBREVNOYESVALLIST);
   HOLDNEWLIT('N               ',JUNKIX);
   HOLDNEWLIT('Y               ',JUNKIX);
   ENDLITVALLIST(ABBREVNOYESVALLIST);
   END (* OPTINITGENERAL *) ;
 
 
PROCEDURE OPTINITFORRANGECHECKS;
   BEGIN
   END (* OPTINITFORRANGECHECKS *) ;
 
PROCEDURE OPTINITFORCHARCODE;
   VAR
      JUNKIX: HOLDIX;
   BEGIN
   STARTLITVALLIST(CHARCODEVALLIST);
   HOLDNEWLIT('EBCDIC          ',JUNKIX);
   HOLDNEWLIT('ISO             ',JUNKIX);
   HOLDNEWLIT('ICL1900         ',JUNKIX);
   ENDLITVALLIST(CHARCODEVALLIST);
   END (* OPTINITFORCHARCODE *) ;
 
PROCEDURE OPTINITFORFLOWANALYSES;
   VAR
      JUNKIX: HOLDIX;
   BEGIN
   STARTLITVALLIST(FLOWANALYSESVALLIST);
   HOLDNEWLIT('PROFILE         ',JUNKIX);
   HOLDNEWLIT('RETROTRACE      ',JUNKIX);
   HOLDNEWLIT('FORWARDTRACE    ',JUNKIX);
   ENDLITVALLIST(FLOWANALYSESVALLIST);
   END (* OPTINITFORFLOWANALYSES *) ;
 
PROCEDURE OPTINITFORCOMPILE;
   BEGIN
   OPTINITGENERAL;
   OPTINITFORRANGECHECKS;
   OPTINITFORCHARCODE;
   OPTINITFORFLOWANALYSES;
   END (* OPTINITFORCOMPILE *) ;
 
PROCEDURE OPTINITFORRUN;
   BEGIN
   OPTINITGENERAL;
   OPTINITFORFLOWANALYSES;
   END (* OPTINITFORRUN *) ;
 
 
(******** MAIN OPTIONS PROCESSING CONTROL ********)
 
 
PROCEDURE PROCESSFLOWANALYSESOPT (JCLPARAM: SUPERLITDESC;
                                  VAR REQUESTEDANALYSES: SETOFPASCALOPTS) ;
   VAR
      SUPERLITVAL: SUPERLITERAL;
      BASICSET: BASICLITOPTSET;
   BEGIN
   CURKEYWORD:=FLOWANALYSESKW;
   SUPERLITCONVERTANDHOLD(JCLPARAM,SUPERLITVAL);
   GETSETFORSUPERLIT(SUPERLITVAL,FLOWANALYSESVALLIST,TRUE,TRUE,BASICSET);
   CONVERTTOPASCALOPTS(BASICSET,PROFILEPO,REQUESTEDANALYSES);
   DISCARDLATESTSUPERLIT(SUPERLITVAL);
   END (* PROCESSFLOWANALYSESOPT *) ;
 
PROCEDURE PROCESSOPTSFORCOMPILE (RANGECHECKSPARAM, CHARCODEPARAM: LITDESC;
                                 FLOWANALYSESPARAM: SUPERLITDESC) ;
   VAR
      THISVALIX: HOLDIX;
      FLOWOPTS: SETOFPASCALOPTS;
   BEGIN
   BOOLOPTSFORCOMPILER:=[];
 
      (* RANGECHECKS:- *)
   CURKEYWORD:=RANGECHECKSKW;
   LITCONVERTANDHOLD(RANGECHECKSPARAM,THISVALIX);
   IF NOYESVALISSET(THISVALIX) THEN
      BOOLOPTSFORCOMPILER:=BOOLOPTSFORCOMPILER+[RANGECHECKSPO];
   DISCARDLATESTLITERAL;
 
      (* CHARCODE:- *);
   CURKEYWORD:=CHARCODEKW;
   LITCONVERTANDHOLD(CHARCODEPARAM,THISVALIX);
   CHARCODEFORCOMPILER:=ORDFORLITVALIX(THISVALIX,CHARCODEVALLIST);
   DISCARDLATESTLITERAL;
 
      (* FLOWANALYSIS:- *)
   PROCESSFLOWANALYSESOPT(FLOWANALYSESPARAM,FLOWOPTS);
   BOOLOPTSFORCOMPILER:=BOOLOPTSFORCOMPILER+FLOWOPTS;
   END (* PROCESSOPTSFORCOMPILE *) ;
 
PROCEDURE PROCESSOPTSFORRUN (FLOWANALYSESPARAM: SUPERLITDESC;
                             DATAPARAM, RESULTSPARAM: LITDESC;
                             HEAPSIZEPARAM, RETROSIZEPARAM,
                             STARTFWDPARAM, STOPFWDPARAM: LONGINT) ;
   CONST
      HEAPSIZELO=1;
      HEAPSIZEHI=256;
      RETROSIZELO=1;
      RETROSIZEHI=?I 2000;
      STARTFWDLO=1;
      STARTFWDHI=MAXINT;
      STOPFWDLO=1;
      STOPFWDHI=MAXINT;
   VAR
      FLOWOPTS: SETOFPASCALOPTS;
      LIVAL: LONGINT;
      FILEROUTE: LONGINT;
   BEGIN
 
      (* FLOWANALYSES:- *)
   PROCESSFLOWANALYSESOPT(FLOWANALYSESPARAM,FLOWOPTS);
   WRITEOPTSETJSV(FLOWANALYSESJSV,FLOWOPTS);
 
      (* RTINPUT:- *)
   CURKEYWORD:=DATAKW;
   ASSIGNFILE(DATAPARAM,READACCESS,FILEROUTE);
   WRITEINTJSV(DATAJSV,FILEROUTE);
 
      (* RTOUTPUT:- *)
   CURKEYWORD:=RESULTSKW;
   ASSIGNFILE(RESULTSPARAM,WRITEACCESS,FILEROUTE);
   WRITEINTJSV(RESULTSJSV,FILEROUTE);
 
      (* HEAPSIZE:- *)
   CURKEYWORD:=HEAPSIZEKW;
   LONGINTRANGECHECK(HEAPSIZEPARAM,HEAPSIZELO,HEAPSIZEHI);
   WRITEINTJSV(HEAPSIZEJSV,HEAPSIZEPARAM);
 
      (* RETROSIZE:- *)
   CURKEYWORD:=RETROSIZEKW;
   LONGINTRANGECHECK(RETROSIZEPARAM,RETROSIZELO,RETROSIZEHI);
   WRITEINTJSV(RETROSIZEJSV,RETROSIZEPARAM);
 
      (* STARTFORWARD:- *)
   CURKEYWORD:=STARTFWDKW;
   LONGINTRANGECHECK(STARTFWDPARAM,STARTFWDLO,STARTFWDHI);
   WRITEINTJSV(STARTFWDJSV,STARTFWDPARAM);
 
      (* STOPFORWARD:- *)
   CURKEYWORD:=STOPFWDKW;
   LONGINTRANGECHECK(STOPFWDPARAM,STOPFWDLO,STOPFWDHI);
   WRITEINTJSV(STOPFWDJSV,STOPFWDPARAM);
   END (* PROCESSOPTSFORRUN *) ;
 
 
(******** CE COMPILE-TIME INTERFACE SUPPORT ********)
 
PROCEDURE SETUPCECTLINKAREA;
   CONST
      BITSINBYTE=8;
      DETPBV=?I 18000000;
      DETPBITV=0;
      OPTLISTBYTE0=?I C6;  (*OMF,=(),CODE,=YES,*)
      OPTLISTBYTE1=?I 79;  (*=NO,GENSKEPT,=(),LISTINGS,=SOURCE,*)
      OPTLISTBYTE2=?I 99;  (*=NOSOURCE,=DIRECTIVES,=NODIRECTIVES,=OBJECT,*)
      OPTLISTBYTE3=?I 80;  (*=NOOBJECT,*)
      OPTLISTBYTE5=?I 1E;  (*SAVELIST,=(),DIAGNOSTICS,=(),*)
      OPTLISTBYTE7=?I 03;  (*LIBPROC,=YES,*)
      OPTLISTBYTE8=?I 80;  (*=NO,*)
      OPTLISTBYTE12=?I 30; (*DIRECTIVES,=()*)
   VAR
      I: CEOPTLISTBITSRNGB;
      MALIX: MALCHARSRNG;
      HOLDMALCHARS: MALCHARS;
 
   PROCEDURE GETMODAMENDLEVEL (VAR MALREP: MALCHARS);
      CONST
         HEXBASE=16;
         HEXMAX=15;
         BITSFORHEXDIG=4;
         MAXHEXDIGBIT=3;
         MAXMACOUNT=16;  (* = BITSFORHEXDIG*(MALCHARSMAX+1) *)
         AMENDABLEBYTES=?X '00000000000000000000000000000000';
      TYPE
         HEXDIG= 0..HEXMAX;
         MALMASK= ARRAY [MALCHARSRNG] OF HEXDIG;
         MANUMBER= 1..MAXMACOUNT;
         MAFLAGSTRING= PACKED ARRAY [MANUMBER] OF BYTE;
         HEXBITRNG= 0..MAXHEXDIGBIT;
      VAR
         COPYFLAGS: MAFLAGSTRING;
         MASK: MALMASK;
         IX: MALCHARSRNG;
         MANUM: MANUMBER;
         BITPOS: HEXBITRNG;
         MASKBIT, DIG: HEXDIG;
         DIGREP: BYTE;
      BEGIN
      COPYFLAGS:=AMENDABLEBYTES;
      FOR IX:=0 TO MALCHARSMAX DO MASK[IX]:=0;
      FOR MANUM:=1 TO MAXMACOUNT DO
         IF COPYFLAGS[MANUM]<>0 THEN
            BEGIN
            IX:=(MANUM-1) DIV BITSFORHEXDIG;
            BITPOS:=(MANUM-1) MOD BITSFORHEXDIG;
            MASKBIT:=1;
            WHILE BITPOS>0 DO
               BEGIN  MASKBIT:=MASKBIT*2;  BITPOS:=BITPOS-1  END;
            MASK[IX]:=MASK[IX]+MASKBIT;
            END;
      FOR IX:=0 TO MALCHARSMAX DO
         BEGIN
         DIG:=MASK[IX];
         IF DIG<10 THEN
            DIGREP:=ORD('0')+DIG
         ELSE
            DIGREP:=ORD('A')+DIG-10;
         MALREP[MALCHARSMAX-IX]:=CHR(DIGREP);
         END;
      END (*GETMODAMENDLEVEL*);
 
   BEGIN
   WITH CECTLINKAREA DO
      BEGIN
 
         (*PRODUCT TITLE:-*)
      PRODUCTID:=PASCALID;
      PRODUCTID[OPSYSIX]:=OPSYSFLAG;
      GETMODAMENDLEVEL(HOLDMALCHARS);
      FOR MALIX:=0 TO MALCHARSMAX DO
         PRODUCTID[MALSTARTIX+MALIX]:=HOLDMALCHARS[MALIX];
      DEVARSETUP(PRODUCTIDRELDESC,DETPBV,PASCALIDLEN,
                 ADDRESSOF(PRODUCTID)-ADDRESSOF(PRODUCTIDRELDESC));
 
         (*OPTIONS LISTING BIT-STRING:-*)
      FOR I:=0 TO MAXBYTEINCEOPTLIST DO
         OPTLISTBITS[I]:=0;
      OPTLISTBITS[0]:=OPTLISTBYTE0;
      OPTLISTBITS[1]:=OPTLISTBYTE1;
      OPTLISTBITS[2]:=OPTLISTBYTE2;
      OPTLISTBITS[3]:=OPTLISTBYTE3;
      OPTLISTBITS[5]:=OPTLISTBYTE5;
      OPTLISTBITS[7]:=OPTLISTBYTE7;
      OPTLISTBITS[8]:=OPTLISTBYTE8;
      OPTLISTBITS[12]:=OPTLISTBYTE12;
      DEVARSETUP(OPTLISTBITSRELDESC,DETPBITV,(MAXBYTEINCEOPTLIST+1)*BITSINBYTE,
                 ADDRESSOF(OPTLISTBITS)-ADDRESSOF(OPTLISTBITSRELDESC));
  
         (*"COMPILER" ENTRY DESCRIPTOR:-*)
      COMPILERENTRYDESC:=ICL9LPCTCONTROLENTRYDESC;
      END;
   END (* SETUPCECTLINKAREA *) ;
 
 
(******** SUPPORT FOR COMPILATION CONTROL MODULE ********)
 
 
(*#E+
%KEYEDENTRY ON
*)
 
PROCEDURE ICL9LPCTGETPASCALJCLOPTS (VAR BOOLOPTS: SETOFPASCALOPTS;
                                    VAR CHARCODEOPT: CHARCODE);
   BEGIN
   BOOLOPTS:=BOOLOPTSFORCOMPILER;
   CHARCODEOPT:=CHARCODEFORCOMPILER;
   END (* ICL9LPCTGETPASCALJCLOPTS *);
 
 
(******** JCL DIRECT ENTRY ROUTINES ********)
 
 
(*#E+
%KEYEDENTRY ON
*)
 
FUNCTION PASCALCOMPILE (
      INPUTPAR: SUPERLITDESC;           (* 0*)
      OUTPUTPAR,
      RUNPAR: LITDESC;
      LISTINGSPAR: SUPERLITDESC;
      SAVELISTPAR,
      RANGECHECKSPAR,
      CHARCODEPAR,
      CODEPAR,
      LIBPROCPAR: LITDESC;
      GENSKEPTPAR,                      
      HEAPSIZEPAR: LONGINT;             (*10*)
      DATAPAR,
      RESULTSPAR: LITDESC;
      FLOWANALYSESPAR: SUPERLITDESC;
      RETROSIZEPAR,
      STARTFWDPAR,
      STOPFWDPAR,
      DIAGNOSTICSPAR: LONGINT;
      DFILEPAR,
      PROCEDUREPAR,                     
      DIRECTIVESPAR,                    (*20*)
      CDIAGPAR: LITDESC                 (*21*)
                       ) : RESPONSE;
   CONST
      PASCALFLAGS='P               ';
   VAR
      HOLDFLAGSLIT: LITERAL;
      CECOMPILERESULT: RESPONSE;
   BEGIN
   JCLCOMPILECALL:=TRUE;
   OPSYSFLAG:=OPSYSLETTER;
   STACKBASEAD:=ICL9LPCURSTACKBASEAD;
   JSBEGIN;
   OPTINITFORCOMPILE;
   PROCESSOPTSFORCOMPILE(RANGECHECKSPAR,CHARCODEPAR,FLOWANALYSESPAR);
   PROCESSOPTSFORRUN(FLOWANALYSESPAR,DATAPAR,RESULTSPAR,HEAPSIZEPAR,
                     RETROSIZEPAR,STARTFWDPAR,STOPFWDPAR);
   SETUPCECTLINKAREA;
   HOLDFLAGSLIT:=PASCALFLAGS;
   CECOMPILERESULT:=
      ICL9HNCOMPILESUPPORT(
                  LITDESCFORLIT(HOLDFLAGSLIT),    (* 0*)
                  ADDRESSOF(CECTLINKAREA),
                  INPUTPAR,
                  OUTPUTPAR,
                  RUNPAR,
                  LISTINGSPAR,
                  NILDESC,
                  SAVELISTPAR,
                  LIDESCFORLI(DIAGNOSTICSPAR),
                  NILDESC,
                  NILDESC,                        (*10*)
                  NILDESC,
                  LIBPROCPAR,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,                        (*20*)
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  LIDESCFORLI(DIAGNOSTICSPAR),    (*30*)
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  DFILEPAR,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  CDIAGPAR,
                  NILDESC,                        (*40*)
                  NILDESC,
                  CODEPAR,
                  LIDESCFORLI(GENSKEPTPAR),
                  PROCEDUREPAR,
                  DIRECTIVESPAR,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC);                       (*49*)
   JSEND;
   IF CECOMPILERESULT=CECOMPERRRESPONSE THEN
      PASCALCOMPILE:=JCLCOMPERRRESPONSE
   ELSE IF CECOMPILERESULT=CECOMPILERFAILRESPONSE THEN
      PASCALCOMPILE:=JCLCOMPILERFAILRESPONSE
   ELSE
      PASCALCOMPILE:=CECOMPILERESULT;
   END (* PASCALCOMPILE *) ;
 
FUNCTION PASCALRUN (
      PROCEDUREPAR: LITDESC;            (* 0*)
      HEAPSIZEPAR: LONGINT;
      DATAPAR,
      RESULTSPAR: LITDESC;
      FLOWANALYSESPAR: SUPERLITDESC;
      RETROSIZEPAR,
      STARTFWDPAR,
      STOPFWDPAR: LONGINT;
      ERRORCLASSPAR,
      IGNOREPAR,
      CATCHPAR,                         (*10*)
      EMESSPAR,
      ROUTEPAR,
      REPORTPAR,
      COUNTPAR: LITDESC;
      DEPTHPAR,
      DIAGNOSTICSPAR,
      ARRAYSIZEPAR: LONGINT;
      CONTINUEPAR: LITDESC;
      TRIESPAR: LONGINT;
      DFILEPAR,                         (*20*)
      DUMPPAR: LITDESC
                   ) : RESPONSE ;
   VAR
      CERUNRESULT: RESPONSE;
   BEGIN
   JCLCOMPILECALL:=FALSE;
   OPSYSFLAG:=OPSYSLETTER;
   STACKBASEAD:=ICL9LPCURSTACKBASEAD;
   JSBEGIN;
   OPTINITFORRUN;
   PROCESSOPTSFORRUN(FLOWANALYSESPAR,DATAPAR,RESULTSPAR,HEAPSIZEPAR,
                     RETROSIZEPAR,STARTFWDPAR,STOPFWDPAR);
   CERUNRESULT:=
      ICL9HNRUNSUPPORT(
                  PROCEDUREPAR,                   (* 0*)
                  ERRORCLASSPAR,
                  IGNOREPAR,
                  CATCHPAR,
                  EMESSPAR,
                  ROUTEPAR,
                  REPORTPAR,
                  COUNTPAR,
                  LIDESCFORLI(DEPTHPAR),
                  LIDESCFORLI(DIAGNOSTICSPAR),
                  LIDESCFORLI(ARRAYSIZEPAR),      (*10*)
                  CONTINUEPAR,
                  LIDESCFORLI(TRIESPAR),
                  DFILEPAR,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  NILDESC,
                  DUMPPAR,
                  NILDESC,                        (*20*)
                  NILDESC);                       (*21*)
   JSEND;
   PASCALRUN:=CERUNRESULT;
   END (* PASCALRUN *) ;
 
 
(******** DUMMY MAIN PROGRAM ********)
 
 
BEGIN
END.