home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 18 REXX / 18-REXX.zip / rxcp290.zip / testcp.cmd < prev    next >
OS/2 REXX Batch file  |  1996-01-30  |  35KB  |  497 lines
  1. /*****************************************************************************/
  2. /*    TestCP.CMD A REXX Program to test all of the RxCP290 Functions         */
  3. /*****************************************************************************/
  4. /* This program demonstrates the proper use of all of the RxCP290 functions. */
  5. /* Each Function has it's input and output parameters described here, along  */
  6. /* with usage guidelines. Output from each function is printed to the screen */
  7. /*****************************************************************************/
  8.  
  9. /*****************************************************************************/
  10. /* Return Codes:                                                             */
  11. /*                                                                           */
  12. /* All RxCP290 functions return a value indicating success or failure. This  */
  13. /* return code is returned via the normal REXX Function return procedure     */
  14. /* (ie - rc = RxFunc() ).  The return code from an RxCP290 function is also  */
  15. /* placed in the special variable CP290rc.  In all cases the returned value  */
  16. /* will be the same in these two locations.                                  */
  17. /*****************************************************************************/
  18.  
  19. /*****************************************************************************/
  20. /*          RxLoadFuncsCP290 - Load the RxCP290 Functions into REXX          */
  21. /*****************************************************************************/
  22. /* Description:                                                              */
  23. /*                                                                           */
  24. /* This function loads the RxCP290 X-10 communications functions, so that    */
  25. /* they are available to REXX programs.  Execution of this command makes     */
  26. /* these functions available to all REXX programs in alll sessions under     */
  27. /* OS/2.  These functions will remain available until explicitly dropped by  */
  28. /* The RxDropFuncsCP290 function.                                            */
  29. /*****************************************************************************/
  30. /* Parameters:                                                               */
  31. /*                                                                           */
  32. /* None                                                                      */
  33. /*****************************************************************************/
  34. /* Returns:                                                                  */
  35. /*                                                                           */
  36. /* 0 if successful                                                           */
  37. /* Non- zero returns indicate that none of the RxCP290 functions have been   */
  38. /* loaded.                                                                   */
  39. /*****************************************************************************/
  40. /* Example:                                                                  */
  41.  
  42.                                                /* Load RxLoadFuncsCP290      */
  43. call RxFuncAdd 'RxLoadFuncsCP290', 'RxCP290', 'RxLoadFuncsCP290'
  44. call RxLoadFuncsCP290                          /* Call the RxCP290 function  */
  45. say 'RxLoadFuncsCP290, CP290rc:   'CP290rc     /* Show results               */
  46.  
  47. /*****************************************************************************/
  48. /*                RxInitCP290 - Initialize Communication Port                */
  49. /*****************************************************************************/
  50. /* Description:                                                              */
  51. /*                                                                           */
  52. /* RxInitCP290 initializes the serial port for communications with the CP290.*/
  53. /* It initializes a Com Port Handle, which is used by all of the RxCP290     */
  54. /* functions to determine which serial port to communicate with.  This Comm  */
  55. /* Handle variable should be initialized in the REXX environment before      */
  56. /* using this function.                                                      */
  57. /*****************************************************************************/
  58. /* Parameters:                                                               */
  59. /*                                                                           */
  60. /* This function takes two parameters. The first parameter is a string with  */
  61. /* the name of the serial port the CP290 is connected to.  For this example, */
  62. /* the CP290 is connected to COM2, so the parameter is 'COM2'. Note that     */
  63. /* This parameter must be in all caps.                                       */
  64. /*                                                                           */
  65. /* The second parameter is the name of a REXX variable to store the Com Port */
  66. /* Handle in.  This variable should have been initialized prior to calling   */
  67. /* function.                                                                 */
  68. /*****************************************************************************/
  69. /* Returns:                                                                  */
  70. /*                                                                           */
  71. /* This function returns 0 when successful. Non-zero results indicate the    */
  72. /* was not opened.                                                           */
  73. /*****************************************************************************/
  74. /* Example:                                                                  */
  75.  
  76. CP290 = ''                                    /* Init Com Port Handle var    */
  77. rc = RxInitCP290('COM2', 'CP290')             /* Call the function           */
  78. say 'RxInitCP290:   'rc', CP290rc:   'CP290rc /* print the results           */
  79.  
  80. /*****************************************************************************/
  81. /*                   RxDiagCP290 - Perform CP290 Self-Test                   */
  82. /*****************************************************************************/
  83. /* Description:                                                              */
  84. /*                                                                           */
  85. /* This function commands the CP290 to perform it's internal diagnostic      */
  86. /* routines.  Execution of these routines will take about 10 seconds.   All  */
  87. /* information in the CP290 will be erased as a result of the execution of   */
  88. /* this function.                                                            */
  89. /*****************************************************************************/
  90. /* Parameters:                                                               */
  91. /*                                                                           */
  92. /* This function takes a single parameter, the Com Port Handle produced by   */
  93. /* the RxInitCP290 function.                                                 */
  94. /*****************************************************************************/
  95. /* Returns:                                                                  */
  96. /*                                                                           */
  97. /* This function returns zero if successful.  A return code of 1 indicates   */
  98. /* a CP290 diagnostics failure not related to the serial communications.  A  */
  99. /* return code of less than zero indicates a communications failure, which   */
  100. /* may or may not be due to CP290 failure.                                   */
  101. /*****************************************************************************/
  102. /* Example:                                                                  */
  103.  
  104. rc = RxDiagCP290(CP290)                        /* Call Function              */
  105. say 'RxDiagCP290:   'rc', CP290rc:   'CP290rc  /* Print return code          */
  106.  
  107. /*****************************************************************************/
  108. /*                RxSetHCodeCP290 - Set CP290 Base House Code                */
  109. /*****************************************************************************/
  110. /* Description:                                                              */
  111. /*                                                                           */
  112. /* RxSetHcodeCP290 sets the CP290's Base Housecode.  All information in the  */
  113. /* CP290 will be erased as a result of this function's execution.            */
  114. /*****************************************************************************/
  115. /* Parameters:                                                               */
  116. /*                                                                           */
  117. /* This function takes two parameters. The first parameter is the Comm Port  */
  118. /* handle.                                                                   */
  119. /*                                                                           */
  120. /* The second parameter is a REXX string containing the new Housecode letter.*/
  121. /* Valid housecodes are in the range "A" to "P".                             */
  122. /*****************************************************************************/
  123. /* Returns:                                                                  */
  124. /*                                                                           */
  125. /* RxSetHcode returns the CP290 ack status after execution. This value will  */
  126. /* be zero if no information has been downloaded to the CP290. It will be a  */
  127. /* 1 after download of any command.  This can be used to determine if the    */
  128. /* CP290 has been powered off. A return code of -1 indicates a communication */
  129. /* error with the CP290.                                                     */
  130. /*****************************************************************************/
  131. /* Example:                                                                  */
  132.  
  133. rc = RxSetHCodeCP290(CP290, "D")               /* Set Housecode "D"          */
  134. say 'RxSetHCodeCP290: 'rc                      /* Print the results          */
  135.  
  136. /*****************************************************************************/
  137. /*                 RxSetTimeCP290 - Set CP290 Base House Code                */
  138. /*****************************************************************************/
  139. /* Description:                                                              */
  140. /*                                                                           */
  141. /* RxSetTimeCP290 sets the CP290's internal clock from the host computer's   */
  142. /* internal clock.                                                           */
  143. /*****************************************************************************/
  144. /* Parameters:                                                               */
  145. /*                                                                           */
  146. /* This function takes one parameter, the Comm Port handle                   */
  147. /*****************************************************************************/
  148. /* Returns:                                                                  */
  149. /*                                                                           */
  150. /* RxSetTime returns the CP290 ack status after execution. This value will   */
  151. /* be zero if no information has been downloaded to the CP290. It will be a  */
  152. /* 1 after download of any command.  This can be used to determine if the    */
  153. /* CP290 has been powered off. A return code of -1 indicates a communication */
  154. /* error with the CP290.                                                     */
  155. /*****************************************************************************/
  156. /* Example:                                                                  */
  157.  
  158. rc = RxSetTimeCP290(CP290)                     /* Set current Computer Time  */
  159. say 'RxSetTimeCP290: ' rc                      /* Print the results          */
  160.  
  161. /*****************************************************************************/
  162. /*                RxGetTimeCP290 - Get CP290 Time and House Code             */
  163. /*****************************************************************************/
  164. /* Description:                                                              */
  165. /*                                                                           */
  166. /* RxGetTimeCP290 returns the CP290's internal clock time and House Code.    */
  167. /*****************************************************************************/
  168. /* Parameters:                                                               */
  169. /*                                                                           */
  170. /* This function takes two parameters. The first parameter is the Comm Port  */
  171. /* handle.                                                                   */
  172. /*                                                                           */
  173. /* The second parameter is the stem name of a REXX compound variable to      */
  174. /* receive the results. The format of this stem variable is shown below, in  */
  175. /* section that prints the results.                                          */
  176. /*****************************************************************************/
  177. /* Returns:                                                                  */
  178. /*                                                                           */
  179. /* RxGetTimeCP290 returns the number of characters received.  This should be */
  180. /* equal to 12 for a normal call.                                            */
  181. /*****************************************************************************/
  182. /* Example:                                                                  */
  183.  
  184. rc = RxGetTimeCP290(CP290, 'result')    /* Get CP290 time                    */
  185. say 'RxGetTimeCP290: ' rc               /* Print return code                 */
  186.  
  187. say 'Status   - Result.0: 'result.0     /* CP290 Ack Status                  */
  188. say 'Minutes  - Result.1: 'result.1     /* Minutes:  valid 00 - 59           */
  189. say 'Hours    - Result.2: 'result.2     /* Hours:    valid 00 - 23           */
  190. say 'Day Week - Result.3: 'result.3     /* Day of Week: in "MON","TUE","WED" */
  191.                                         /* "THU","FRI","SAT","SUN"           */
  192. say 'Base     - Result.4: 'result.4     /* Base Housecode: valid "A" - "P"   */
  193.  
  194. /*****************************************************************************/
  195. /*                 RxDirCmdCP290 - Send CP290 direct command                 */
  196. /*****************************************************************************/
  197. /* Description:                                                              */
  198. /*                                                                           */
  199. /* RxDirCmdCP290 sends a direct command to a single X-10 module              */
  200. /*****************************************************************************/
  201. /* Parameters:                                                               */
  202. /*                                                                           */
  203. /* This function takes five parameters. The first parameter is the Comm Port */
  204. /* handle.                                                                   */
  205. /*                                                                           */
  206. /* The second parameter is the dim level, for the DIM function. Valid Values */
  207. /* range from 00(dimmest) to 15(brightest).                                  */
  208. /*                                                                           */
  209. /* The third parameter is the function code. This can be one of "ON", "OFF", */
  210. /* or "DIM".                                                                 */
  211. /*                                                                           */
  212. /* The fourth parameter is a REXX string containing the new Housecode letter.*/
  213. /* Valid housecodes are in the range "A" to "P".                             */
  214. /*                                                                           */
  215. /* Finally, the last parameter is the module number to affect. Valid values  */
  216. /* are in the range 1 through 16.                                            */
  217. /*****************************************************************************/
  218. /* Returns:                                                                  */
  219. /*                                                                           */
  220. /* RxDirCmd returns the CP290 ack status after execution. This value will    */
  221. /* be zero if no information has been downloaded to the CP290. It will be a  */
  222. /* 1 after download of any command.  This can be used to determine if the    */
  223. /* CP290 has been powered off. A return code of -1 indicates a communication */
  224. /* error with the CP290.                                                     */
  225. /*****************************************************************************/
  226. /* Example:                                                                  */
  227.  
  228. rc = RxDirCmdCP290(CP290, 8, "ON" ,"D", 4)     /* Turn on Module D4          */
  229. say 'RxDirCmdCP290: 'rc', CP290rc:   'CP290rc
  230.  
  231. /*****************************************************************************/
  232. /*                RxCmdUploadCP290 - Get CP290 execution report              */
  233. /*****************************************************************************/
  234. /* Description:                                                              */
  235. /*                                                                           */
  236. /* Every time the CP290 executes a command to an X-10 module, it sends a     */
  237. /* Command Upload to the host computer. This is true whether the action was  */
  238. /* caused by a RxDirCmdCP290 REXX Function, an event execution in the CP290, */
  239. /* or manual control from the CP290 keypad.  This function receives this     */
  240. /* report, and formats the uploaded information in a REXX compound variable. */
  241. /*****************************************************************************/
  242. /* Parameters:                                                               */
  243. /*                                                                           */
  244. /* This function takes two parameters. The first parameter is the Comm Port  */
  245. /* handle.                                                                   */
  246. /*                                                                           */
  247. /* The second parameter is the stem name of a REXX compound variable to      */
  248. /* receive the results. The format of this stem variable is shown below, in  */
  249. /* section that prints the results.                                          */
  250. /*****************************************************************************/
  251. /* Usage Notes:                                                              */
  252. /*                                                                           */
  253. /* In this example, the call to RxCmdUploadCP290 is contained within a do    */
  254. /* while loop. This waits until the command is received by the REXX program  */
  255. /* before continuing.  If the com  port is left open for any period of time, */
  256. /* this function should be called periodically to check to see if any events */
  257. /* that would cause a report (such as manual key presses, or timer events).  */
  258. /* This will keep the serial input and output buffers synchronized.          */
  259. /*****************************************************************************/
  260. /* Returns:                                                                  */
  261. /*                                                                           */
  262. /* RxCmd UploadCP290 returns the number of characters received.  This should */
  263. /* be equal to 12 for a normal call. If no command upload has been received, */
  264. /* this function will return 0.                                              */
  265. /*****************************************************************************/
  266. /* Example:                                                                  */
  267.  
  268. do while rc < 5
  269.    rc = RxCmdUploadCP290(CP290, 'result')
  270. end
  271.  
  272. say 'Status       - Result.0:   'result.0     /* CP290 ack status           */
  273. say 'Hcode        - Result.1:   'result.1     /* House code: "A"-"P"        */
  274. say 'Function     - Result.2:   'result.2     /* Function: "ON","OFF","DIM" */
  275. say '# of Modules - Result.3.0: 'result.3.0   /* Number of modules affected */
  276. do i = 1 to result.3.0
  277.    say 'Module 'i'     - Result.3.'i': 'result.3.i /* Module number         */
  278. end    
  279. say 'Base          - Result.4:   'result.4     /* CP290 Base Housecode       */
  280.  
  281. /*****************************************************************************/
  282. /*       RxDirCmdManyCP290 - Send Direct Command to Many X-10 Modules        */
  283. /*****************************************************************************/
  284. /* Description:                                                              */
  285. /*                                                                           */
  286. /* RxDirCmdManyCP290 sends a direct command to a series of X-10 modules      */
  287. /*****************************************************************************/
  288. /* Parameters:                                                               */
  289. /*                                                                           */
  290. /* This function takes five parameters. The first parameter is the Comm Port */
  291. /* handle.                                                                   */
  292. /*                                                                           */
  293. /* The second parameter is the dim level, for the DIM function. Valid Values */
  294. /* range from 00(dimmest) to 15(brightest).                                  */
  295. /*                                                                           */
  296. /* The third parameter is the function code. This can be one of "ON", "OFF", */
  297. /* or "DIM".                                                                 */
  298. /*                                                                           */
  299. /* The fourth parameter is a REXX string containing the new Housecode letter.*/
  300. /* Valid housecodes are in the range "A" to "P".                             */
  301. /*                                                                           */
  302. /* Finally, the last parameter is the stem name of a REXX compound variable  */
  303. /* that contains a list of the modules to command. The format of this        */
  304. /* variable is demonstrated in the example below.                            */
  305. /*****************************************************************************/
  306. /* Returns:                                                                  */
  307. /*                                                                           */
  308. /* RxDirCmdMany returns the CP290 ack status after execution. This value will*/
  309. /* be zero if no information has been downloaded to the CP290. It will be a  */
  310. /* 1 after download of any command.  This can be used to determine if the    */
  311. /* CP290 has been powered off. A return code of -1 indicates a communication */
  312. /* error with the CP290.                                                     */
  313. /*****************************************************************************/
  314. /* Example:                                                                  */
  315.  
  316. dcom.0 = 5                             /* 5 modules to command               */
  317. dcom.1 = 4                             /* 1st module - Module  4             */
  318. dcom.2 = 5                             /* 2nd module - Module  5             */
  319. dcom.3 = 16                            /* 3rd module - Module 16             */
  320. dcom.4 = 10                            /* 4th module - Module 10             */
  321. dcom.5 = 7                             /* 5th module - Module  7             */
  322.  
  323. rc = RxDirCmdManyCP290(CP290, 8, "OFF" ,"D", "dcom")  /* call the function   */
  324. say 'RxDirCmdManyCP290: 'rc', CP290rc:   'CP290rc
  325.  
  326. do while rc < 5
  327.    rc = RxCmdUploadCP290(CP290, 'result')
  328. end
  329.  
  330. say 'Status        - Result.0:   'result.0
  331. say 'Hcode         - Result.1:   'result.1
  332. say 'Function      - Result.2:   'result.2
  333. say '# of Modules  - Result.3.0: 'result.3.0
  334. do i = 1 to result.3.0
  335.    say 'Module 'i'      - Result.3.'i': 'result.3.i
  336. end    
  337. say 'Base          - Result.4:   'result.4
  338.  
  339. /*****************************************************************************/
  340. /*            RxDwnLdEvtCP290 - Download a Timer Event to the CP290          */
  341. /*****************************************************************************/
  342. /* Description:                                                              */
  343. /*                                                                           */
  344. /* RxDwnLdEvtCP290 downloads a Timer event to the CP290 for later execution. */
  345. /*****************************************************************************/
  346. /* Parameters:                                                               */
  347. /*                                                                           */
  348. /* This function takes three parameters.  The first parameter is the Comm    */
  349. /* Port handle.                                                              */
  350. /*                                                                           */
  351. /* The second parameter is the event number.  Valid Values range from 0 to   */
  352. /* 127.                                                                      */
  353. /*                                                                           */
  354. /* Finally, the last parameter is the stem name of a REXX compound variable  */
  355. /* that contains the timer event information. The format of this variable is */
  356. /* demonstrated in the example below. Note the similarity of this variable   */
  357. /* format to the one used by RxGetEventsCP290.                               */
  358. /*****************************************************************************/
  359. /* Returns:                                                                  */
  360. /*                                                                           */
  361. /* RxDwnLdEvt returns the CP290 ack status after execution. This value will  */
  362. /* be zero if no information has been downloaded to the CP290. It will be a  */
  363. /* 1 after download of any command.  This can be used to determine if the    */
  364. /* CP290 has been powered off. A return code of -1 indicates a communication */
  365. /* error with the CP290.                                                     */
  366. /*****************************************************************************/
  367. /* Example:                                                                  */
  368.  
  369. event.0   = 0                /* Not used - here for compatibility with       */
  370.                              /* RxGetEventsCP290 Compound Variable.          */
  371.  
  372. event.1   = "NORMAL"         /* Timer Mode - valid entries are "NORMAL",     */
  373.                              /* "SECURITY","TODAY","TOMORROW", and "CLEAR"   */
  374.  
  375. event.2.0 = 4                /* Number of Days for Event: range 1-7          */
  376.  
  377. event.2.1 = "WED"            /* First Day - one of "MON","TUE","WED","THU",  */
  378. event.2.2 = "THU"            /* "SAT", or "SUN".                             */
  379. event.2.3 = "FRI"
  380. event.2.4 = "MON"
  381.  
  382. event.3   = 15               /* Event Time - Hours:   Range  0-23            */
  383.  
  384. event.4   = 25               /* Event Time - Minutes: Range  0-59            */
  385.  
  386. event.5.0 = 4                /* Number of Modules for Event: Range 1-16      */
  387. event.5.1 = 4                /* First Module: Range 1-16                     */
  388. event.5.2 = 3                /* 2nd Module                                   */
  389. event.5.3 = 16               /* 3rd Module                                   */
  390. event.5.4 = 10               /* 4th Module                                   */
  391.  
  392. event.6   = "D"              /* Housecode: Range "A"-"P"                     */
  393.  
  394. event.7   = 7                /* Dim Level: Range 0(dimmest)-15(brightest)    */
  395.  
  396. event.8   = "DIM"            /* Function - One of "ON","OFF","DIM            */
  397.  
  398. rc = RxDwnldEvtCP290(CP290, 1,event)  /* call the function                   */
  399. say 'RxDwnldEvtCP290:  'rc
  400.  
  401. /*****************************************************************************/
  402. /*                RxGetEventsCP290 - Get CP290 Timer Events                  */
  403. /*****************************************************************************/
  404. /* Description:                                                              */
  405. /*                                                                           */
  406. /* This function gets all the Timer Event information from the CP290, and    */
  407. /* makes it available to the calling REXX program in the form of a large     */
  408. /* compound variable.                                                        */
  409. /*****************************************************************************/
  410. /* Parameters:                                                               */
  411. /*                                                                           */
  412. /* This function takes two parameters. The first parameter is the Comm Port  */
  413. /* handle.                                                                   */
  414. /*                                                                           */
  415. /* The second parameter is the stem name of a REXX compound variable to      */
  416. /* receive the results. The format of this compound variable is shown below, */
  417. /* in the section that prints the results. This compound variable consists   */
  418. /* of several structures in the same format as the compound variable used by */
  419. /* RxDwnLdEvtCP290, for convenience.                                         */
  420. /*****************************************************************************/
  421. /* Returns:                                                                  */
  422. /*                                                                           */
  423. /* RxGetEventsCP290 returns the number of characters received.               */
  424. /*****************************************************************************/
  425. /* Example:                                                                  */
  426.  
  427. rc = RxGetEventsCP290(CP290, 'bigevt')    /* Call the function               */
  428. say 'RxGetEventsCP290:  'rc
  429.  
  430. do i=0 to 127
  431.  if BigEvt.i.0 = 1 then Do                /* If this value = 1, there is a   */
  432.                                           /* corresponding event number.     */
  433.                                           /* Otherwise, value is 0           */ 
  434.   say 'BigEvt.'i'.0  :  'BigEvt.i.0       /* 1 = event, 0 = no event         */
  435.   say 'BigEvt.'i'.1  :  'BigEvt.i.1       /* Timer Mode Sel - as RxDwnLdEvt  */
  436.   say 'BigEvt.'i'.2.0:  'BigEvt.i.2.0     /* Number of Days - as RxDwnLdEvt  */
  437.   Do j = 1 to BigEvt.i.2.0
  438.    say 'BigEvt.'i'.2.'j':  'BigEvt.i.2.j  /* Day info - as RxDwnLdEvt        */
  439.   end
  440.   say 'BigEvt.'i'.3  :  'BigEvt.i.3       /* Hours:                          */
  441.   say 'BigEvt.'i'.4  :  'BigEvt.i.4       /* Minutes:                        */
  442.   say 'BigEvt.'i'.5.0:  'BigEvt.i.5.0     /* Number of Modules               */
  443.   Do j = 1 to BigEvt.i.5.0
  444.    say 'BigEvt.'i'.5.'j':  'BigEvt.i.5.j  /* Module number                   */
  445.   end
  446.   say 'BigEvt.'i'.6  :  'BigEvt.i.6       /* Housecode                       */
  447.   say 'BigEvt.'i'.7  :  'BigEvt.i.7       /* Dim Level                       */
  448.   say 'BigEvt.'i'.8  :  'Bigevt.i.8       /* Function                        */
  449.   end
  450. end
  451.  
  452. /*****************************************************************************/
  453. /*                   RxCloseCP290 - Close CP290 Serial Port                  */
  454. /*****************************************************************************/
  455. /* Description:                                                              */
  456. /*                                                                           */
  457. /* RxCloseCP290 closes the serial port specified by the Com Port Handle,     */
  458. /* freeing the port for use by other OS/2 applications.                      */
  459. /*****************************************************************************/
  460. /* Parameters:                                                               */
  461. /*                                                                           */
  462. /* This function takes one parameter, the Comm Port handle                   */
  463. /*****************************************************************************/
  464. /* Returns:                                                                  */
  465. /*                                                                           */
  466. /* Returns 0 if successful                                                   */
  467. /*****************************************************************************/
  468. /* Example:                                                                  */
  469.  
  470. rc = RxCloseCP290(CP290)
  471. say 'RxCloseCP290:  'rc', CP290rc:   'CP290rc
  472.  
  473. /*****************************************************************************/
  474. /*          RxDropFuncsCP290 - Drop the RxCP290 Functions from REXX          */
  475. /*****************************************************************************/
  476. /* Description:                                                              */
  477. /*                                                                           */
  478. /* This function drops the RxCP290 X-10 communications functions, so that    */
  479. /* they are no longer available to REXX programs.  Execution of this command */
  480. /* makes these functions unavailable to all REXX programs in all sessions    */
  481. /* in OS/2.  These functions will remain unavailable until explicitly loaded */
  482. /* by the RxLoadFuncsCP290 function.                                         */
  483. /*****************************************************************************/
  484. /* Parameters:                                                               */
  485. /*                                                                           */
  486. /* None                                                                      */
  487. /*****************************************************************************/
  488. /* Returns:                                                                  */
  489. /*                                                                           */
  490. /* 0 if successful                                                           */
  491. /*****************************************************************************/
  492. /* Example:                                                                  */
  493.  
  494. call RxDropFuncsCP290
  495. say 'RxDropFuncsCP290, CP290rc:  'CP290rc
  496.  
  497.