home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD1.iso / Fax / AVMA&GPFax-V1,33Sources.LHA / simplerexx.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-25  |  16.6 KB  |  646 lines
  1. /* $Header: pd:zvmRCS/simplerexx.c,v 1.2 1993/04/19 18:40:06 rvillari Exp rvillari $ */
  2. /*
  3.  * Simple ARexx interface by Michael Sinz
  4.  *
  5.  * This is a very "Simple" interface to the world of ARexx...
  6.  * For more complex interfaces into ARexx, it is best that you
  7.  * understand the functions that are provided by ARexx.
  8.  * In many cases they are more powerful than what is presented
  9.  * here.
  10.  *
  11.  * This code is fully re-entrant and self-contained other than
  12.  * the use of SysBase/AbsExecBase and the ARexx RVI support
  13.  * library which is also self-contained...
  14.  */
  15.  
  16. #include    <exec/types.h>
  17. #include    <exec/nodes.h>
  18. #include    <exec/lists.h>
  19. #include    <exec/ports.h>
  20. #include    <exec/memory.h>
  21.  
  22. #include    <proto/exec.h>
  23.  
  24. #include    <rexx/storage.h>
  25. #include    <rexx/rxslib.h>
  26.  
  27. #include    <string.h>
  28. #include    <ctype.h>
  29.  
  30. int globalARexxReturnCode;
  31. char globalARexxResult[100];
  32.  
  33. /*
  34.  * The prototypes for the few ARexx functions we will call...
  35.  */
  36. struct RexxMsg *CreateRexxMsg(struct MsgPort *,char *,char *);
  37. void *CreateArgstring(char *,long);
  38. void DeleteRexxMsg(struct RexxMsg *);
  39. void DeleteArgstring(char *);
  40. BOOL IsRexxMsg(struct Message *);
  41.  
  42. /*
  43.  * Pragmas for the above functions...  (To make this all self-contained...)
  44.  * If you use RexxGlue.o, this is not needed...
  45.  *
  46.  * These are for Lattice C 5.x  (Note the use of RexxContext->RexxSysBase)
  47.  */
  48. #pragma libcall RexxContext->RexxSysBase CreateRexxMsg 90 09803
  49. #pragma libcall RexxContext->RexxSysBase CreateArgstring 7E 0802
  50. #pragma libcall RexxContext->RexxSysBase DeleteRexxMsg 96 801
  51. #pragma libcall RexxContext->RexxSysBase DeleteArgstring 84 801
  52. #pragma libcall RexxContext->RexxSysBase IsRexxMsg A8 801
  53.  
  54. /*
  55.  * Prototypes for the RVI ARexx calls...  (link with RexxVars.o)
  56.  */
  57. /*
  58. long __stdargs CheckRexxMsg(struct RexxMsg *);
  59. long __stdargs  GetRexxVar(struct RexxMsg *,char *,char **);
  60. long __stdargs  SetRexxVar(struct RexxMsg *,char *,char *,long);
  61. */
  62.  
  63. /*
  64.  * Now, we have made the pragmas needed, let's get to work...
  65.  */
  66.  
  67. /*
  68.  * A structure for the ARexx handler context
  69.  * This is *VERY* *PRIVATE* and should not be touched...
  70.  */
  71. struct    ARexxContext
  72. {
  73. struct    MsgPort    *ARexxPort;    /* The port messages come in at... */
  74. struct    Library    *RexxSysBase;    /* We will hide the library pointer here... */
  75.     long    Outstanding;    /* The count of outstanding ARexx messages... */
  76.     char    PortName[24];    /* The port name goes here... */
  77.     char    ErrorName[28];    /* The name of the <base>.LASTERROR... */
  78.     char    Extension[8];    /* Default file name extension... */
  79. };
  80.  
  81. #define    AREXXCONTEXT    struct ARexxContext *
  82.  
  83. #include    "SimpleRexx.h"
  84.  
  85. /*
  86.  * This function returns the port name of your ARexx port.
  87.  * It will return NULL if there is no ARexx port...
  88.  *
  89.  * This string is *READ ONLY*  You *MUST NOT* modify it...
  90.  */
  91.  
  92. char* ErrorMsg(int r2) {
  93.   switch (r2) {
  94.   case 0 : return "OK";
  95.   case 1 : return "program not found";
  96.   case 2 : return "execution halted";
  97.   case 3 : return "no memory available";
  98.   case 4 : return "character in program";
  99.   case 5 : return "unmatched quote";
  100.   case 6 : return "unterminated comment";
  101.   case 7 : return "clause too long";
  102.   case 8 : return "unrecognized token";
  103.   case 9 : return "symbol or string too long";
  104.  
  105.   case 10 : return "invalid message packet";
  106.   case 11 : return "command string error";
  107.   case 12 : return "error return from function";
  108.   case 13 : return "host environment not found (check server)";
  109.   case 14 : return "required library not found";
  110.   case 15 : return "function not found";
  111.   case 16 : return "no return value";
  112.   case 17 : return "wrong number of arguments";
  113.   case 18 : return "invalid argument to function";
  114.   case 19 : return "invalid PROCEDURE";
  115.  
  116.   case 20 : return "unexpected THEN/ELSE";
  117.   case 21 : return "unexpected WHEN/OTHERWISE";
  118.   case 22 : return "unexpected LEAVE or ITERATE";
  119.   case 23 : return "invalid statement in SELECT";
  120.   case 24 : return "missing THEN clauses";
  121.   case 25 : return "missing OTHERWISE";
  122.   case 26 : return "missing or unexpected END";
  123.   case 27 : return "symbol mismatch on END";
  124.   case 28 : return "invalid DO syntax";
  125.   case 29 : return "incomplete DO/IF/SELECT";
  126.  
  127.   case 30 : return "label not found";
  128.   case 31 : return "symbol expected";
  129.   case 32 : return "string or symbol expected";
  130.   case 33 : return "invalid sub-keyword";
  131.   case 34 : return "required keyword missing";
  132.   case 35 : return "extraneous characters";
  133.   case 36 : return "sub-keyword conflict";
  134.   case 37 : return "invalid template";
  135.   case 38 : return "invalid TRACE request";
  136.   case 39 : return "uninitialized variable";
  137.  
  138.   case 40 : return "invalid variable name";
  139.   case 41 : return "invalid expression";
  140.   case 42 : return "unbalanced parentheses";
  141.   case 43 : return "nesting level exceeded";
  142.   case 44 : return "invalid expression result";
  143.   case 45 : return "expression required";
  144.   case 46 : return "boolean value not 0 or 1";
  145.   case 47 : return "arithmetic conversion error";
  146.   case 48 : return "invalid operand";
  147.   }
  148. }
  149.  
  150. int OutstandingMsg(AREXXCONTEXT RexxContext) {
  151.   if (RexxContext) return RexxContext->Outstanding;
  152.   return 0;
  153. }
  154.  
  155. char *ARexxName(AREXXCONTEXT RexxContext)
  156. {
  157. register    char    *tmp=NULL;
  158.  
  159.     if (RexxContext) tmp=RexxContext->PortName;
  160.     return(tmp);
  161. }
  162.  
  163. /*
  164.  * This function returns the signal mask that the Rexx port is
  165.  * using.  It returns NULL if there is no signal...
  166.  *
  167.  * Use this signal bit in your Wait() loop...
  168.  */
  169. ULONG ARexxSignal(AREXXCONTEXT RexxContext)
  170. {
  171. register    ULONG    tmp=NULL;
  172.  
  173.     if (RexxContext) tmp=1L << (RexxContext->ARexxPort->mp_SigBit);
  174.     return(tmp);
  175. }
  176.  
  177. /*
  178.  * This function returns a structure that contains the commands sent from
  179.  * ARexx...  You will need to parse it and return the structure back
  180.  * so that the memory can be freed...
  181.  *
  182.  * This returns NULL if there was no message...
  183.  */
  184. struct RexxMsg *GetARexxMsg(AREXXCONTEXT RexxContext)
  185. {
  186. register    struct    RexxMsg    *tmp=NULL;
  187. register        short    flag;
  188.  
  189.     if (RexxContext)
  190.         if (tmp=(struct RexxMsg *)GetMsg(RexxContext->ARexxPort))
  191.     {
  192.         if (tmp->rm_Node.mn_Node.ln_Type==NT_REPLYMSG)
  193.         {
  194.             /*
  195.              * If we had sent a command, it would come this way...
  196.              *
  197.              * Since we don't in this simple example, we just throw
  198.              * away anything that looks "strange"
  199.              */
  200.             flag=FALSE;
  201.             if (tmp->rm_Result1) {
  202.               flag=TRUE;
  203.             }
  204.  
  205.             globalARexxReturnCode = tmp->rm_Result1;
  206.             
  207.             if (!tmp->rm_Result1 && tmp->rm_Result2) {
  208.               strncpy(globalARexxResult, (char*)tmp->rm_Result2, sizeof(globalARexxResult));
  209.               DeleteArgstring((char*)tmp->rm_Result2);
  210.             } else if (tmp->rm_Result1 && tmp->rm_Result2) {
  211.               strncpy(globalARexxResult, ErrorMsg(tmp->rm_Result2), sizeof(globalARexxResult));
  212.             } else {
  213.               strcpy(globalARexxResult, "Done");
  214.             }
  215.             globalARexxResult[sizeof(globalARexxResult) - 1] = '\0'; /* ensure null termination */
  216.             
  217.             /*
  218.              * Free the arguments and the message...
  219.              */
  220.             DeleteArgstring(tmp->rm_Args[0]);
  221.             DeleteRexxMsg(tmp);
  222.             RexxContext->Outstanding-=1;
  223.  
  224.             /*
  225.              * Return the error if there was one...
  226.              */
  227.             tmp=flag ? REXX_RETURN_ERROR : NULL;
  228.             tmp = REXX_RETURN_ERROR; // always return an error
  229.         }
  230.     }
  231.     return(tmp);
  232. }
  233.  
  234. /*
  235.  */
  236.  
  237. void* GetReplyARexxMsg(AREXXCONTEXT RexxContext)
  238. {
  239.   register    struct    RexxMsg    *tmp=NULL;
  240.   
  241.   if (RexxContext)
  242.     if (tmp=(struct RexxMsg *)GetMsg(RexxContext->ARexxPort))
  243.       {
  244.     if (tmp->rm_Node.mn_Node.ln_Type==NT_REPLYMSG)
  245.       {
  246.         /*
  247.          * If we had sent a command, it would come this way...
  248.          */
  249.         /*
  250.          * Free the arguments and the message...
  251.          */
  252.         globalARexxReturnCode = tmp->rm_Result1;
  253.  
  254.         if (!tmp->rm_Result1 && tmp->rm_Result2) {
  255.           strncpy(globalARexxResult, (char*)tmp->rm_Result2, sizeof(globalARexxResult));
  256.           DeleteArgstring((char*)tmp->rm_Result2);
  257.         } else if (tmp->rm_Result1 && tmp->rm_Result2) {
  258.           strncpy(globalARexxResult, ErrorMsg(tmp->rm_Result2), sizeof(globalARexxResult));
  259.         } else {
  260.           strcpy(globalARexxResult, "");
  261.         }
  262.         globalARexxResult[sizeof(globalARexxResult) - 1] = '\0'; /* ensure null termination */
  263.  
  264. //        printf("result1 = %d, result2 = %s\n", globalARexxReturnCode, globalARexxResult);
  265.         DeleteArgstring(tmp->rm_Args[0]);
  266.         DeleteRexxMsg(tmp);
  267.         RexxContext->Outstanding-=1;
  268.         return tmp; // warning:  the return value should just be used as a handle that
  269.           // may be used to check whether an outgoing msg. has come back yet
  270.       } else {
  271.         ReplyARexxMsg(RexxContext, tmp, "This port is not for messages", 20);
  272.         return REXX_RETURN_ERROR;
  273.       }
  274.       }
  275.   return 0;
  276. }
  277.  
  278. /*
  279.  * Use this to return a ARexx message...
  280.  *
  281.  * If you wish to return something, it must be in the RString.
  282.  * If you wish to return an Error, it must be in the Error.
  283.  * If there is an error, the RString is ignored.
  284.  */
  285. void ReplyARexxMsg(AREXXCONTEXT RexxContext,struct RexxMsg *rmsg,
  286.             char *RString,LONG Error)
  287. {
  288.     if (RexxContext) if (rmsg) if (rmsg!=REXX_RETURN_ERROR)
  289.     {
  290.         rmsg->rm_Result2=0;
  291.         if (!(rmsg->rm_Result1=Error))
  292.         {
  293.             /*
  294.              * if you did not have an error we return the string
  295.              */
  296.             if (rmsg->rm_Action & (1L << RXFB_RESULT)) if (RString)
  297.             {
  298.                 rmsg->rm_Result2=(LONG)CreateArgstring(RString,
  299.                             (LONG)strlen(RString));
  300.             }
  301.         }
  302.  
  303.         /*
  304.          * Reply the message to ARexx...
  305.          */
  306.         ReplyMsg((struct Message *)rmsg);
  307.     }
  308. }
  309.  
  310. /*
  311.  * This function will set an error string for the ARexx
  312.  * application in the variable defined as <appname>.LASTERROR
  313.  *
  314.  * Note that this can only happen if there is an ARexx message...
  315.  *
  316.  * This returns TRUE if it worked, FALSE if it did not...
  317.  */
  318. short SetARexxLastError(AREXXCONTEXT RexxContext,struct RexxMsg *rmsg,
  319.             char *ErrorString)
  320. {
  321. register    short    OkFlag=FALSE;
  322.  
  323.     if (RexxContext) if (rmsg) if (CheckRexxMsg((struct Message*)rmsg))
  324.     {
  325.         /*
  326.          * Note that SetRexxVar() has more than just a TRUE/FALSE
  327.          * return code, but for this "basic" case, we just care if
  328.          * it works or not.
  329.          */
  330.         if (!SetRexxVar((struct Message*)rmsg,RexxContext->ErrorName,ErrorString,
  331.                         (long)strlen(ErrorString)))
  332.         {
  333.             OkFlag=TRUE;
  334.         }
  335.     }
  336.     return(OkFlag);
  337. }
  338.  
  339. /*
  340.  * This function will send a string to ARexx...
  341.  *
  342.  * The default host port will be that of your task...
  343.  *
  344.  * If you set StringFile to TRUE, it will set that bit for the message...
  345.  *
  346.  * Returns TRUE if it send the message, FALSE if it did not...
  347.  */
  348. void* SendARexxMsg(AREXXCONTEXT RexxContext,char *RString,
  349.             short StringFile)
  350. {
  351. register    struct    MsgPort    *RexxPort;
  352. register    struct    RexxMsg    *rmsg;
  353. register        void*    flag=0;
  354.  
  355.     if (RexxContext) if (RString)
  356.     {
  357.         if (rmsg=CreateRexxMsg(RexxContext->ARexxPort,
  358.                     RexxContext->Extension,
  359.                     RexxContext->PortName))
  360.         {
  361.             rmsg->rm_Action=RXCOMM | (StringFile ?
  362.                             (1L << RXFB_STRING):0) |
  363.                               (1L << RXFB_RESULT);
  364.             if (rmsg->rm_Args[0]=CreateArgstring(RString,
  365.                             (LONG)strlen(RString)))
  366.             {
  367.                 /*
  368.                  * We need to find the RexxPort and this needs
  369.                  * to be done in a Forbid()
  370.                  */
  371.                 Forbid();
  372.                 if (RexxPort=FindPort(RXSDIR))
  373.                 {
  374.                     /*
  375.                      * We found the port, so put the
  376.                      * message to ARexx...
  377.                      */
  378.                     PutMsg(RexxPort,(struct Message *)rmsg);
  379.                     RexxContext->Outstanding+=1;
  380.                     flag=rmsg;
  381.                 }
  382.                 else
  383.                 {
  384.                     /*
  385.                      * No port, so clean up...
  386.                      */
  387.                     DeleteArgstring(rmsg->rm_Args[0]);
  388.                     DeleteRexxMsg(rmsg);
  389.                 }
  390.                 Permit();
  391.             }
  392.             else DeleteRexxMsg(rmsg);
  393.         }
  394.     }
  395.     return(flag);
  396. }
  397.  
  398. /*
  399.  * This function closes down the ARexx context that was opened
  400.  * with InitARexx...
  401.  */
  402. void FreeARexx(AREXXCONTEXT RexxContext)
  403. {
  404.   struct    RexxMsg    *rmsg;
  405.  
  406.     if (RexxContext)
  407.     {
  408.         /*
  409.          * Clear port name so it can't be found...
  410.          */
  411.         RexxContext->PortName[0]='\0';
  412.  
  413.         /*
  414.          * Clean out any outstanding messages we had sent out...
  415.          */
  416.         while (RexxContext->Outstanding)
  417.         {
  418.             WaitPort(RexxContext->ARexxPort);
  419.             while (rmsg=GetARexxMsg(RexxContext))
  420.             {
  421.               if (rmsg!=REXX_RETURN_ERROR)
  422.                 {
  423.                     /*
  424.                      * Any messages that come now are blown
  425.                      * away...
  426.                      */
  427.                     SetARexxLastError(RexxContext,rmsg,
  428.                                 "99: Port Closed!");
  429.                     ReplyARexxMsg(RexxContext,rmsg,
  430.                             NULL,100);
  431.                 }
  432.             }
  433.         }
  434.  
  435.         /*
  436.          * Clean up the port and delete it...
  437.          */
  438.         if (RexxContext->ARexxPort)
  439.         {
  440.             while (rmsg=GetARexxMsg(RexxContext))
  441.             {
  442.                 /*
  443.                  * Any messages that still are coming in are
  444.                  * "dead"  We just set the LASTERROR and
  445.                  * reply an error of 100...
  446.                  */
  447.                 SetARexxLastError(RexxContext,rmsg,
  448.                             "99: Port Closed!");
  449.                 ReplyARexxMsg(RexxContext,rmsg,NULL,100);
  450.             }
  451.             DeletePort(RexxContext->ARexxPort);
  452.         }
  453.  
  454.         /*
  455.          * Make sure we close the library...
  456.          */
  457.         if (RexxContext->RexxSysBase)
  458.         {
  459.             CloseLibrary(RexxContext->RexxSysBase);
  460.         }
  461.  
  462.         /*
  463.          * Free the memory of the RexxContext
  464.          */
  465.         FreeMem(RexxContext,sizeof(struct ARexxContext));
  466.  
  467.     }
  468. }
  469.  
  470. /*
  471.  * This routine initializes an ARexx port for your process
  472.  * This should only be done once per process.  You must call it
  473.  * with a valid application name and you must use the handle it
  474.  * returns in all other calls...
  475.  *
  476.  * NOTE:  The AppName should not have spaces in it...
  477.  *        Example AppNames:  "MyWord" or "FastCalc" etc...
  478.  *        The name *MUST* be less that 16 characters...
  479.  *        If it is not, it will be trimmed...
  480.  *        The name will also be UPPER-CASED...
  481.  *
  482.  * NOTE:  The Default file name extension, if NULL will be
  483.  *        "rexx"  (the "." is automatic)
  484.  */
  485. AREXXCONTEXT InitARexx(char *AppName,char *Extension)
  486. {
  487. register    AREXXCONTEXT    RexxContext=NULL;
  488. register    short        loop;
  489. register    short        count;
  490. register    char        *tmp;
  491. int hasARexx = 0;
  492.  
  493.     if (RexxContext=AllocMem(sizeof(struct ARexxContext),
  494.                     MEMF_PUBLIC|MEMF_CLEAR))
  495.     {
  496.         if (RexxContext->RexxSysBase=OpenLibrary("rexxsyslib.library",
  497.                                 NULL))
  498.         {
  499.             /*
  500.              * Set up the extension...
  501.              */
  502.             if (!Extension) Extension="rexx";
  503.             tmp=RexxContext->Extension;
  504.             for (loop=0;(loop<7)&&(Extension[loop]);loop++)
  505.             {
  506.                 *tmp++=Extension[loop];
  507.             }
  508.             *tmp='\0';
  509.  
  510.             /*
  511.              * Set up a port name...
  512.              */
  513.             tmp=RexxContext->PortName;
  514.             for (loop=0;(loop<16)&&(AppName[loop]);loop++)
  515.             {
  516.                 *tmp++=toupper(AppName[loop]);
  517.             }
  518.             *tmp='\0';
  519.  
  520.             /*
  521.              * Set up the last error RVI name...
  522.              *
  523.              * This is <appname>.LASTERROR
  524.              */
  525.             strcpy(RexxContext->ErrorName,RexxContext->PortName);
  526.             strcat(RexxContext->ErrorName,".LASTERROR");
  527.  
  528.             /* We need to make a unique port name... */
  529.             Forbid();
  530.             for (count=1,RexxContext->ARexxPort=(VOID *)1;
  531.                         RexxContext->ARexxPort;count++)
  532.             {
  533.                 stci_d(tmp,count);
  534.                 RexxContext->ARexxPort=
  535.                         FindPort(RexxContext->PortName);
  536.             }
  537.  
  538.             RexxContext->ARexxPort=CreatePort(
  539.                         RexxContext->PortName,NULL);
  540.             if (FindPort(RXSDIR)) hasARexx = 1;
  541.             else hasARexx = 0;
  542.             Permit();
  543.         }
  544.  
  545.         if (    (!(RexxContext->RexxSysBase))
  546.              ||    (!(RexxContext->ARexxPort))    
  547.              || (!hasARexx)
  548.             )
  549.         {
  550.             FreeARexx(RexxContext);
  551.             RexxContext=NULL;
  552.         }
  553.     }
  554.     return(RexxContext);
  555. }
  556.  
  557. /*
  558.  * This routine initializes an ARexx port for your process
  559.  * This should only be done once per process.  You must call it
  560.  * with a valid application name and you must use the handle it
  561.  * returns in all other calls...
  562.  *
  563.  * NOTE:  The AppName should not have spaces in it...
  564.  *        Example AppNames:  "MyWord" or "FastCalc" etc...
  565.  *        The name *MUST* be less that 16 characters...
  566.  *        If it is not, it will be trimmed...
  567.  *        The name will also be UPPER-CASED...
  568.  *
  569.  * NOTE:  The Default file name extension, if NULL will be
  570.  *        "rexx"  (the "." is automatic)
  571.  */
  572.  
  573. AREXXCONTEXT InitARexxSingleApp(char *AppName,char *Extension)
  574. {
  575. register    AREXXCONTEXT    RexxContext=NULL;
  576. register    short        loop;
  577. register    short        count;
  578. register    char        *tmp;
  579. int hasARexx = 0;
  580.  
  581.     if (RexxContext=AllocMem(sizeof(struct ARexxContext),
  582.                     MEMF_PUBLIC|MEMF_CLEAR))
  583.     {
  584.         if (RexxContext->RexxSysBase=OpenLibrary("rexxsyslib.library",
  585.                                 NULL))
  586.         {
  587.             /*
  588.              * Set up the extension...
  589.              */
  590.             if (!Extension) Extension="rexx";
  591.             tmp=RexxContext->Extension;
  592.             for (loop=0;(loop<7)&&(Extension[loop]);loop++)
  593.             {
  594.                 *tmp++=Extension[loop];
  595.             }
  596.             *tmp='\0';
  597.  
  598.             /*
  599.              * Set up a port name...
  600.              */
  601.             tmp=RexxContext->PortName;
  602.             for (loop=0;(loop<16)&&(AppName[loop]);loop++)
  603.             {
  604.                 *tmp++=toupper(AppName[loop]);
  605.             }
  606.             *tmp='\0';
  607.  
  608.             /*
  609.              * Set up the last error RVI name...
  610.              *
  611.              * This is <appname>.LASTERROR
  612.              */
  613.             strcpy(RexxContext->ErrorName,RexxContext->PortName);
  614.             strcat(RexxContext->ErrorName,".LASTERROR");
  615.  
  616.             /* We need to make a unique port name... */
  617.             Forbid();
  618.  
  619.             RexxContext->ARexxPort=
  620.               FindPort(RexxContext->PortName);
  621.             
  622.             if (!RexxContext->ARexxPort) {
  623.               RexxContext->ARexxPort=CreatePort(
  624.                                 RexxContext->PortName,NULL);
  625.               if (FindPort(RXSDIR)) hasARexx = 1;
  626.               else hasARexx = 0;
  627.             } else {
  628.               RexxContext->ARexxPort = 0;
  629.             }
  630.  
  631.             Permit();
  632.         }
  633.  
  634.         if (    (!(RexxContext->RexxSysBase))
  635.              ||    (!(RexxContext->ARexxPort))    
  636.              || (!hasARexx)
  637.             )
  638.         {
  639.             FreeARexx(RexxContext);
  640.             RexxContext=NULL;
  641.         }
  642.     }
  643.     return(RexxContext);
  644. }
  645.  
  646.