home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 200-299 / ff299.lzh / Rxil / Functions.doc < prev    next >
Text File  |  1989-12-30  |  22KB  |  1,032 lines
  1.  
  2.     ARexx Interface Library (Rxil) Function Documentation
  3.             Release X1.0
  4.  
  5.  
  6.  
  7. Copyright © 1989 by Donald T. Meyer, Stormgate Software
  8. All Rights Reserved
  9.  
  10.  
  11. The following is an alphabetical listing of the function documentation
  12. which has been extracted from the .c source files.
  13.  
  14.  
  15.  
  16. ----------------------------------------------------------------------
  17.  
  18.  NAME
  19.         RxilCancel
  20.  
  21.  SYNOPSIS
  22.         RxilCancel();
  23.  
  24.  FUNCTION
  25.         Sets the abort condition for ARexx macros.  This is accomplished
  26.         by setting the Abort flag in the RxilDef structure.
  27.         All ARexx messages received at the ARexx ports while this flag
  28.         is set will be returned with an error code.
  29.         Unless the RXIL_NO_CLEAR_ABORT flag is set, the Abort flag will
  30.         be cleared automaticly when the last ARexx program launched by
  31.         this application has finished.
  32.  
  33.  
  34.  INPUTS
  35.         None
  36.  
  37.  RESULT
  38.         None
  39.  
  40.  SIDES
  41.  
  42.  HISTORY
  43.         01-Aug-89   Creation.
  44.  
  45.  BUGS
  46.  
  47.  SEE ALSO
  48.  
  49.  
  50.  
  51. ----------------------------------------------------------------------
  52.  
  53.  
  54.  
  55.  NAME
  56.         RxilCheckCancel
  57.  
  58.  SYNOPSIS
  59.         flag = RxilCheckCancel();
  60.  
  61.         BOOL flag;
  62.  
  63.  FUNCTION
  64.         Checks to see if the button on the cancel macro requester has
  65.         been clicked by the user or not.
  66.         This will return FALSE if the cancel requester is not posted.
  67.  
  68.  INPUTS
  69.         None
  70.  
  71.  RESULT
  72.         A boolean TRUE if the cancel requester has been clicked.
  73.  
  74.  SIDES
  75.  
  76.  HISTORY
  77.         01-Aug-89   Creation.
  78.  
  79.  BUGS
  80.  
  81.  SEE ALSO
  82.         RxilPostCancel(), RxilEndCancel()
  83.  
  84.  
  85. ----------------------------------------------------------------------
  86.  
  87.  
  88.  
  89.  NAME
  90.         RxilCheckPort
  91.  
  92.  SYNOPSIS
  93.         RxilCheckPort();
  94.  
  95.  FUNCTION
  96.         Called by the client program's eventloop upon recieving a message
  97.         at one of the ports.
  98.         This handles the dispatching ( via RxilDispatch() ) of ARexx
  99.         commands, the launching of "looped back" macros, and receiving
  100.         the replys to macro invocation messages which we have sent to
  101.         Rexxmaster.
  102.  
  103.         This is a "safe" call in that if the ARexx library was unopened
  104.         or the port opening failed, nothing will go boom!
  105.  
  106.  INPUTS
  107.         None
  108.  
  109.  RESULT
  110.         None
  111.  
  112.  SIDES
  113.  
  114.  HISTORY
  115.         01-Aug-89   Creation.
  116.  
  117.  BUGS
  118.  
  119.  SEE ALSO
  120.         RxilInit(), RxilDispatch()
  121.  
  122.  
  123. ----------------------------------------------------------------------
  124.  
  125.  
  126.  
  127.  NAME
  128.         RxilCheckResult
  129.  
  130.  SYNOPSIS
  131.         RxilCheckResult( rexxmsg );
  132.  
  133.         struct RexxMsg *rexxmsg;
  134.  
  135.  FUNCTION
  136.         Verify that the secondary result field in a RexxMsg is
  137.         appropriatly set.
  138.         This should be called for a RexxMsg just prior to replying
  139.         it.  This will deal with the case of a result string being
  140.         set when the calling program did not request it.
  141.         It will be freed, and an error code
  142.         set to indicate to the calling program that it should be
  143.         requesting a result for this command.
  144.  
  145.  INPUTS
  146.         rexxmsg = pointer to the RexxMsg structure to be checked.
  147.  
  148.  RESULT
  149.         None
  150.  
  151.  SIDES
  152.  
  153.  HISTORY
  154.         01-Aug-89   Creation.
  155.  
  156.  BUGS
  157.  
  158.  SEE ALSO
  159.  
  160.  
  161.  
  162. ----------------------------------------------------------------------
  163.  
  164.  
  165.  
  166.  NAME
  167.         RxilCleanup
  168.  
  169.  SYNOPSIS
  170.         RxilCleanup( rdef )
  171.  
  172.         struct RxilDef *rdef;
  173.  
  174.  FUNCTION
  175.         Cleanup the entire ARexx port.
  176.         This will set the Abort flag, then wait till all ARexx program
  177.         invocations which we have made are completed.
  178.         At this time, all ARexx message ports will be closed.
  179.         Any remaining RxilInvocation structures which were allocated
  180.         via RxilCreateRxi() and not yet deleted via RxilDeleteRxi()
  181.         will be cleaned up and freed.
  182.         The ARexx library will be closed.
  183.         Finally, the RexxDef structure itself will be freed.
  184.  
  185.  INPUTS
  186.         rdef = pointer to the RxilDef structure returned by a call to
  187.             RxilInit().
  188.  
  189.  RESULT
  190.         None
  191.  
  192.  SIDES
  193.  
  194.  HISTORY
  195.         01-Aug-89   Creation.
  196.  
  197.  BUGS
  198.  
  199.  SEE ALSO
  200.         RxilInit(), RxilPending()
  201.  
  202.  
  203. ----------------------------------------------------------------------
  204.  
  205.  
  206.  
  207.  NAME
  208.         RxilCleanupReturn
  209.  
  210.  SYNOPSIS
  211.         RxilCleanupReturn( rxi );
  212.  
  213.         struct RxilInvovcation *rxi;
  214.  
  215.  FUNCTION
  216.         This will take a pointer to a RxilInvocation structure and
  217.         free what needs to be freed.
  218.         The RexxMsg pointer is then NULL'ed and the structure's state
  219.         set to AVAILABLE.
  220.  
  221.         This should be called by the main program to cleanup after
  222.         a function or command has returned and after the main program
  223.         has done whatever it wanted to with the result.
  224.         This will close the extension filehandles for Stdin and Stdout.
  225.  
  226.  INPUTS
  227.         rxi = pointer to the RxilInvocation structure to be cleaned up.
  228.  
  229.  RESULT
  230.         None
  231.  
  232.  SIDES
  233.  
  234.  HISTORY
  235.         01-Aug-89   Creation.
  236.  
  237.  BUGS
  238.  
  239.  SEE ALSO
  240.         RxilCreateRxi(), RxilDeleteRxi(), RxilGetReturn()
  241.  
  242.  
  243. ----------------------------------------------------------------------
  244.  
  245.  
  246.  
  247.  NAME
  248.         RxilCloseConsole
  249.  
  250.  SYNOPSIS
  251.         RxilCloseConsole( rexxmsg )
  252.  
  253.         struct RexxMsg *rexxmsg;
  254.  
  255.  FUNCTION
  256.         This will close the AmigaDOS file handles contained in the
  257.         rm_Stdin and rm_Stdout fields of the RexxMsg.  If the handles
  258.         are the same, only one close is performed.
  259.         This clears the fields.  If the fields are NULL, then no action
  260.         is taken.
  261.         This function supports the rm_Stdin and rm_Stdout being seperate
  262.         handles, even though it's complimentary function,
  263.         RxilOpenConsole() does not do this.
  264.  
  265.  INPUTS
  266.         rexxmsg = pointer to the RexxMsg whose IO streams are to be
  267.             closed.
  268.  
  269.  RESULT
  270.         None
  271.  
  272.  SIDES
  273.  
  274.  HISTORY
  275.         01-Aug-89   Creation.
  276.  
  277.  BUGS
  278.  
  279.  SEE ALSO
  280.         RxilOpenConsole()
  281.  
  282.  
  283. ----------------------------------------------------------------------
  284.  
  285.  
  286.  
  287.  NAME
  288.         RxilCmdLock
  289.  
  290.  SYNOPSIS
  291.         RxilCmdLock( rexxmsg );
  292.  
  293.         struct RexxMsg *rexxmsg;
  294.  
  295.  FUNCTION
  296.         This is a "command" which would be called from the dispatch
  297.         function.  This would handle the "LOCK" command that an ARexx
  298.         program could send to the application requesting access to
  299.         the private port.
  300.  
  301.  INPUTS
  302.         rexxmsg     A pointer to a RexxMsg structure.
  303.  
  304.  RESULT
  305.         None
  306.  
  307.  SIDES
  308.  
  309.  HISTORY
  310.         01-Aug-89   Creation.
  311.  
  312.  BUGS
  313.  
  314.  SEE ALSO
  315.         RxilCmdUnlock()
  316.  
  317.  
  318. ----------------------------------------------------------------------
  319.  
  320.  
  321.  
  322.  NAME
  323.         RxilCmdPending
  324.  
  325.  SYNOPSIS
  326.         flag = RxilCmdPending();
  327.  
  328.  FUNCTION
  329.         If any ARexx commands have been launched via
  330.         a call to RxilLaunch(), and have not yet terminated, this will
  331.         return TRUE.
  332.  
  333.  INPUTS
  334.         None
  335.  
  336.  RESULT
  337.         A boolean flag which indicates if any launches are in progress.
  338.  
  339.  SIDES
  340.  
  341.  HISTORY
  342.         01-Aug-89   Creation.
  343.  
  344.  BUGS
  345.  
  346.  SEE ALSO
  347.         RxilLaunch(), RxilPending(), RxilFuncPending()
  348.  
  349.  
  350. ----------------------------------------------------------------------
  351.  
  352.  
  353.  
  354.  NAME
  355.         RxilCmdUnlock
  356.  
  357.  SYNOPSIS
  358.         RxilCmdUnlock( rexxmsg );
  359.  
  360.         struct RexxMsg *rexxmsg;
  361.  
  362.  FUNCTION
  363.         This is a "command" which would be called from the dispatch
  364.         function.  This would handle the "UNLOCK" command that an
  365.         ARexx program could send to the application requesting
  366.         access to the private port.
  367.  
  368.          Note: The privilege level for this command should be "secret",
  369.          since anyone who locked us will be able to meet that level,
  370.          and those who have not locked us can't slip the lock out
  371.          from under those who did (so to speak).
  372.  
  373.  INPUTS
  374.         rexxmsg     A pointer to a RexxMsg structure.
  375.  
  376.  RESULT
  377.         None
  378.  
  379.  SIDES
  380.  
  381.  HISTORY
  382.         01-Aug-89   Creation.
  383.  
  384.  BUGS
  385.  
  386.  SEE ALSO
  387.         RxilCmdLock()
  388.  
  389.  
  390. ----------------------------------------------------------------------
  391.  
  392.  
  393.  
  394.  NAME
  395.         RxilCreateRxi
  396.  
  397.  SYNOPSIS
  398.         rxi = RxilCreateRxi( name, type );
  399.  
  400.         struct RxilInvocation *rxi;
  401.  
  402.         char *name;
  403.         ULONG type;
  404.  
  405.  FUNCTION
  406.         Allocate a RxilInvocation structure and initialize it to
  407.         the defaults which are contained in the global RxilDef
  408.         structure.
  409.  
  410.  INPUTS
  411.         name = character string containing the name of the ARexx
  412.             program that will be launched with the structure.
  413.         type = determines wether this will be used to launch commands
  414.             or functions.  Must be set to either RXCOMM or RXFUNC.
  415.  
  416.  RESULT
  417.         A pointer to a newly allocated and initialized RxilInvocation
  418.         structure, or NULL if one could not be allocated.
  419.  
  420.  SIDES
  421.  
  422.  HISTORY
  423.         01-Aug-89   Creation.
  424.  
  425.  BUGS
  426.  
  427.  SEE ALSO
  428.         RxilDeleteRxi()
  429.  
  430.  
  431. ----------------------------------------------------------------------
  432.  
  433.  
  434.  
  435.  NAME
  436.         RxilDeletePort
  437.  
  438.  SYNOPSIS
  439.         RxilDeletePort( port );
  440.  
  441.         struct MsgPort *port;
  442.  
  443.  FUNCTION
  444.         This will safely delete a message port used to receive commands
  445.         from ARexx.
  446.         This is acomplished by setting a failure return code and
  447.         replying the message if it is from ARexx.
  448.         If the message is not from ARexx, it is merely replied.
  449.  
  450.         WARNING: If the port was/is used to receive replys, there must
  451.         be no chance of a reply being pending when this function is
  452.         called!
  453.  
  454.  INPUTS
  455.         port = pointer to a MsgPort.  Normally one that was opened
  456.             for receiving ARexx commands.
  457.  
  458.  RESULT
  459.         None
  460.  
  461.  SIDES
  462.  
  463.  HISTORY
  464.         01-Aug-89   Creation.
  465.  
  466.  BUGS
  467.  
  468.  SEE ALSO
  469.  
  470.  
  471.  
  472. ----------------------------------------------------------------------
  473.  
  474.  
  475.  
  476.  NAME
  477.         RxilDeleteRxi
  478.  
  479.  SYNOPSIS
  480.         RxilDeleteRxi( rxi );
  481.  
  482.         struct RxilInvocation *rxi;
  483.  
  484.  FUNCTION
  485.         Remove the structure allocated by a call to RxilCreateRxi() from
  486.         the linked list, and then frees it's memory.
  487.  
  488.  INPUTS
  489.         rxi = a pointer to the RxilInvocation structure to delete.
  490.             This must have been allocated by a call to RxilCreateRxi().
  491.  
  492.  RESULT
  493.         None
  494.  
  495.  SIDES
  496.  
  497.  HISTORY
  498.         01-Aug-89   Creation.
  499.  
  500.  BUGS
  501.  
  502.  SEE ALSO
  503.         RxilCreateRxi()
  504.  
  505.  
  506. ----------------------------------------------------------------------
  507.  
  508.  
  509.  
  510.  NAME
  511.         RxilDispatch
  512.  
  513.  SYNOPSIS
  514.         RxilDispatch( rexxmsg, cmd );
  515.  
  516.         struct RexxMsg *rexxmsg;
  517.         char *cmd;
  518.  
  519.  FUNCTION
  520.         This is really an "internal" function which is used by
  521.         the RxilCheckPort() function to dispatch commands.
  522.  
  523.         It is not static, since it may be usefull by itself, or
  524.         it may desireable to replace it with a custom version
  525.         in some applications.  This can be done simply by overriding
  526.         it, rather than editing the library itself.
  527.  
  528.         This is NOT a "safe" call, since it should never be called
  529.         directly from client code.
  530.         It is however safe if the client fails to initialize the command
  531.         table pointer.
  532.  
  533.  
  534.  INPUTS
  535.         rexxmsg = pointer to the RexxMsg structure for the command we
  536.             are dispatching.
  537.         cmd = the command name string.
  538.  
  539.  RESULT
  540.         None
  541.  
  542.  SIDES
  543.  
  544.  HISTORY
  545.         01-Aug-89   Creation.
  546.         26-Sep-89   Changed to use maximum and minimum argcounts.
  547.  
  548.  BUGS
  549.  
  550.  SEE ALSO
  551.         RxilCheckPort()
  552.  
  553.  
  554. ----------------------------------------------------------------------
  555.  
  556.  
  557.  
  558.  NAME
  559.         RxilDumpRdef
  560.  
  561.  SYNOPSIS
  562.         RxilDumpRdef( rdef, flags );
  563.  
  564.         struct RxilDef *rdef;
  565.         ULONG flags;
  566.  
  567.  FUNCTION
  568.         This function is for debug and testing purposes.  It will
  569.         dump information about the current ARexx environment to the
  570.         CLI.
  571.  
  572.  INPUTS
  573.         rdef = pointer to the global RxilDef structure.
  574.         flags = an unsigned long whose bits control just what information
  575.             about the RxilDef structure is displayed.
  576.  
  577.  RESULT
  578.         None
  579.  
  580.  SIDES
  581.  
  582.  HISTORY
  583.         01-Aug-89   Creation.
  584.         25-Sep-89   Added display of library version string.
  585.         01-Oct-89   Added "flags" argument to control just what is
  586.                     displayed, and ability to display the commands.
  587.         10-Nov-89   Changed format of command info display slightly.
  588.  
  589.  BUGS
  590.  
  591.  SEE ALSO
  592.  
  593.  
  594.  
  595. ----------------------------------------------------------------------
  596.  
  597.  
  598.  
  599.  NAME
  600.         RxilEndCancel
  601.  
  602.  SYNOPSIS
  603.         RxilEndCancel();
  604.  
  605.  FUNCTION
  606.         Removes the cancel requester.
  607.  
  608.  INPUTS
  609.         None
  610.  
  611.  RESULT
  612.         None
  613.  
  614.  SIDES
  615.  
  616.  HISTORY
  617.         01-Aug-89   Creation.
  618.  
  619.  BUGS
  620.  
  621.  SEE ALSO
  622.         RxilPostCancel(), RxilCheckCancel()
  623.  
  624.  
  625. ----------------------------------------------------------------------
  626.  
  627.  
  628.  
  629.  NAME
  630.         RxilFuncPending
  631.  
  632.  SYNOPSIS
  633.         flag = RxilFuncPending();
  634.  
  635.  FUNCTION
  636.         If any ARexx functions have been launched via
  637.         a call to RxilLaunch(), and have not yet terminated, this will
  638.         return TRUE.
  639.  
  640.  INPUTS
  641.         None
  642.  
  643.  RESULT
  644.         A boolean flag which indicates if any launches are in progress.
  645.  
  646.  SIDES
  647.  
  648.  HISTORY
  649.         01-Aug-89   Creation.
  650.  
  651.  BUGS
  652.  
  653.  SEE ALSO
  654.         RxilLaunch(), RxilPending(), RxilCmdPending()
  655.  
  656.  
  657. ----------------------------------------------------------------------
  658.  
  659.  
  660.  
  661.  NAME
  662.         RxilGetReturn
  663.  
  664.  SYNOPSIS
  665.         rxi = RxilGetReturn();
  666.  
  667.         struct RxilInvocation *rxi;
  668.  
  669.  FUNCTION
  670.         This will return a pointer to any RxilInvocation message
  671.         that has been replyed (but not yet cleaned up and available).
  672.         NULL will be returned if all RxilInvocation structures which have
  673.         been allocated are available or pending.
  674.  
  675.  INPUTS
  676.         None
  677.  
  678.  RESULT
  679.         A pointer to a RxilInvocation structure.  If none have been
  680.         replied and are available to be handled, this will return a NULL.
  681.  
  682.  SIDES
  683.  
  684.  HISTORY
  685.         01-Aug-89   Creation.
  686.  
  687.  BUGS
  688.  
  689.  SEE ALSO
  690.  
  691.  
  692.  
  693. ----------------------------------------------------------------------
  694.  
  695.  
  696.  
  697.  NAME
  698.         RxilHandleReturn
  699.  
  700.  SYNOPSIS
  701.         RxilHandleReturn( rxi );
  702.  
  703.         struct RxilInvocation *rxi;
  704.  
  705.  FUNCTION
  706.         Take appropriate action (i.e., notify user) for the return
  707.         from an ARexx macro program.
  708.  
  709.         The method of notification will be an Intuition Autorequester
  710.         if the Intuition library has been opened.
  711.         If it is not, the message will be sent to the CLI (if possible)
  712.         by opening "*".  If this fails, no action is taken.
  713.  
  714.         Output is via AmigaDOS functions such as Write(), as opposed
  715.         to using 'C' standard I/O such as printf().
  716.  
  717.  INPUTS
  718.         rxi = pointer to a RxilInvocation structure that has been
  719.             replyed by the RexxMaster.
  720.  
  721.  RESULT
  722.         None
  723.  
  724.  SIDES
  725.  
  726.  HISTORY
  727.         01-Aug-89   Creation.
  728.         10-Nov-89   Added Autorequester feature.
  729.                     Changed to use AmigaDOS I/O rather than 'C' stdio.
  730.  
  731.  BUGS
  732.  
  733.  SEE ALSO
  734.  
  735.  
  736.  
  737. ----------------------------------------------------------------------
  738.  
  739.  
  740.  
  741.  NAME
  742.         RxilInit
  743.  
  744.  SYNOPSIS
  745.         rdef = RxilInit( flags, portname );
  746.  
  747.         struct RxilDef *rdef;
  748.  
  749.         ULONG flags;
  750.         char *portname;
  751.  
  752.  FUNCTION
  753.         Open the ARexx library and setup our message ports.  Then
  754.         allocate a RxilDef structure and do some default initialization
  755.         of it.
  756.         The portname will have a unique "instance" number appended
  757.         to it in the format "<name>_#<n>" where <name> is the string as
  758.         specified in the portname argument, and <n> is a decimal number
  759.         from 1-99 inclusive.  This feature may be inhibited by setting
  760.         the RXIL_AS_IS flag.
  761.  
  762.         Even though this may fail, that should probably not be fatal
  763.         since the ARexx functionality is optional.  The RxilCheckPort()
  764.         function is smart enough to just return if the rexx initialization
  765.         was not successsfull.  Not to mention that RxilCheckPort() should
  766.         never get called since the rexx_sig_bit mask should be zero.
  767.  
  768.  INPUTS
  769.         flags       These are various defined constants which control
  770.                     which ports get opened and other various aspects
  771.                     of port initialization.
  772.  
  773.         portname    This is the name to use for the public ARexx port
  774.                     that commands will be received at.  It is suggested
  775.                     that this be in uppercase and contain no spaces.
  776.                     Maximum length is 40 characters, as set by the
  777.                     defined constant RXIL_MAX_PORTNAME_LEN.
  778.                     See discussion above about instance numbers.
  779.  
  780.  RESULT
  781.         A pointer to a RxilDef structure.  Return is NULL for failure
  782.         to initialize the ARexx ports.
  783.  
  784.  SIDES
  785.  
  786.  HISTORY
  787.         01-Aug-89   Creation.
  788.         23-Sep-89   Changed "flags" arg from int to ULONG
  789.         26-Sep-89   Sets the (new) version string pointer.
  790.         01-Oct-89   Changed PublicPort name storage from a pointer to
  791.                     a character array.  Added "instance" numbering.
  792.                     Added check on portname length.
  793.  
  794.  BUGS
  795.         This should probably share one signal bit between both ports
  796.         to avoid "hogging" signal bits.
  797.  
  798.  SEE ALSO
  799.         RxilCleanup(), RXIL_AS_IS, RXIL_MAX_PORTNAME_LEN
  800.  
  801.  
  802. ----------------------------------------------------------------------
  803.  
  804.  
  805.  
  806.  NAME
  807.         RxilLaunch
  808.  
  809.  SYNOPSIS
  810.         result = RxilLaunch( rxi )
  811.  
  812.         LONG result;
  813.  
  814.         struct RxilInvocation *rxi;
  815.  
  816.  FUNCTION
  817.         Launch an ARexx program by sending an invocation message
  818.         to the RexxMaster process.  The RxilInvocation structure
  819.         which is allocated prior to this call via RxilCreateRxi()
  820.         contains the information neccessary to launch the program.
  821.  
  822.  INPUTS
  823.         rxi     A pointer to an initialized RxilInvocation structure.
  824.  
  825.  RESULT
  826.         Zero if the launch was successful, non-zero otherwise.
  827.  
  828.  SIDES
  829.  
  830.  HISTORY
  831.         01-Aug-89   Creation.
  832.  
  833.  BUGS
  834.  
  835.  SEE ALSO
  836.         RxilCreateRxi(), RxilDeleteRxi()
  837.  
  838.  
  839. ----------------------------------------------------------------------
  840.  
  841.  
  842.  
  843.  NAME
  844.         RxilOpenConsole
  845.  
  846.  SYNOPSIS
  847.         RxilOpenConsole( console, rexxmsg );
  848.  
  849.         char *console;
  850.         struct RexxMsg *rexxmsg;
  851.  
  852.  FUNCTION
  853.         This will open an AmigaDOS stream as specified by the console
  854.         string.  The filehandle is then placed in the rm_Stdin and
  855.         rm_Stdout fields of the RexxMsg.
  856.  
  857.  INPUTS
  858.         console = a string which defines the console stream to be opened.
  859.             This will normally be something like "CON:0/0/400/100/".
  860.         rexxmsg = pointer to the RexxMsg that the AmigaDOS file handles
  861.             are to be set into.
  862.  
  863.  RESULT
  864.         None
  865.  
  866.  SIDES
  867.  
  868.  HISTORY
  869.         01-Aug-89   Creation.
  870.  
  871.  BUGS
  872.  
  873.  SEE ALSO
  874.         RxilCloseConsole()
  875.  
  876.  
  877. ----------------------------------------------------------------------
  878.  
  879.  
  880.  
  881.  NAME
  882.         RxilPending
  883.  
  884.  SYNOPSIS
  885.         flag = RxilPending();
  886.  
  887.  FUNCTION
  888.         If any ARexx functions or commands have been launched via
  889.         a call to RxilLaunch(), and have not yet terminated, this will
  890.         return TRUE.
  891.  
  892.  INPUTS
  893.         None
  894.  
  895.  RESULT
  896.         A boolean flag which indicates if any launches are in progress.
  897.  
  898.  SIDES
  899.  
  900.  HISTORY
  901.         01-Aug-89   Creation.
  902.  
  903.  BUGS
  904.  
  905.  SEE ALSO
  906.         RxilLaunch(), RxilCmdPending(), RxilFuncPending()
  907.  
  908.  
  909. ----------------------------------------------------------------------
  910.  
  911.  
  912.  
  913.  NAME
  914.         RxilPostCancel
  915.  
  916.  SYNOPSIS
  917.         RxilPostCancel();
  918.  
  919.  FUNCTION
  920.         This will post a cancel requester to allow the user to halt
  921.         macro execution by clicking a button on the requester.
  922.         The CancelWindow member of the RxilDef structure controls
  923.         where the requester is posted.
  924.         In the current version, the cancel requester always opens it's
  925.         own window on the same screen as the Window whose pointer is
  926.         in CancelWindow.  If CancelWindow is NULL, the window will open
  927.         on the WorkBench.
  928.  
  929.  INPUTS
  930.         None
  931.  
  932.  RESULT
  933.         None
  934.  
  935.  SIDES
  936.  
  937.  HISTORY
  938.         01-Aug-89   Creation.
  939.  
  940.  BUGS
  941.  
  942.  SEE ALSO
  943.         RxilCheckCancel(), RxilEndCancel()
  944.  
  945.  
  946. ----------------------------------------------------------------------
  947.  
  948.  
  949.  
  950.  NAME
  951.         RxilSetResult
  952.  
  953.  SYNOPSIS
  954.         RxilSetResult( rexxmsg, string );
  955.  
  956.         struct RexxMsg *rexxmsg;
  957.         char *string;
  958.  
  959.  FUNCTION
  960.         This can be called to handle the details of placing a result
  961.         string into the rexx message packet as the result Argstring.
  962.         If the string pointer is NULL, a general failure code will
  963.         be set.
  964.         This will deal with inability to allocate the Argstring by
  965.         setting a failure code in the RexxMsg.
  966.  
  967.  INPUTS
  968.         rexxmsg = pointer to the RexxMsg that the reply is being set
  969.             into.
  970.         string = pointer to a null terminated text string which will
  971.             be converted to an Argstring and returned.
  972.  
  973.  RESULT
  974.  
  975.  
  976.  SIDES
  977.  
  978.  HISTORY
  979.         01-Aug-89   Creation.
  980.  
  981.  BUGS
  982.  
  983.  SEE ALSO
  984.  
  985.  
  986.  
  987. ----------------------------------------------------------------------
  988.  
  989.  
  990.  
  991.  NAME
  992.         RxilToRexx
  993.  
  994.  SYNOPSIS
  995.         result = RxilToRexx( cmd, arg0, arg1, arg2, arg3 );
  996.  
  997.         LONG result
  998.  
  999.         ULONG cmd
  1000.         STRPTR arg0
  1001.         STRPTR arg1
  1002.         STRPTR arg2
  1003.         STRPTR arg3
  1004.  
  1005.  FUNCTION
  1006.         Send a command packet to the Rexx Master.
  1007.         This is an asynchronous send, no success or failure will be
  1008.         observed.
  1009.  
  1010.  INPUTS
  1011.         cmd = the command to send.
  1012.         arg0 = a null-terminated string to convert into an Argstring.
  1013.         arg1 = a null-terminated string to convert into an Argstring.
  1014.         arg2 = a null-terminated string to convert into an Argstring.
  1015.         arg3 = a null-terminated string to convert into an Argstring.
  1016.  
  1017.  RESULT
  1018.         Zero for success, non-zero to indicate failure.
  1019.  
  1020.  SIDES
  1021.  
  1022.  HISTORY
  1023.         01-Aug-89   Creation.
  1024.  
  1025.  BUGS
  1026.  
  1027.  SEE ALSO
  1028.  
  1029.  
  1030.  
  1031. ----------------------------------------------------------------------
  1032.