home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / ad109u18.zip / adeptrexxmiscfuncs.doc < prev    next >
Text File  |  1997-02-20  |  80KB  |  2,592 lines
  1.  
  2.                            AdeptXBBS REXX INTERFACE
  3.  
  4.                     Copyright (c) 1993 - 1996 by AdeptSoft
  5.                   portions Copyright (c)  1991-1994 M. Kimes
  6.                              All Rights Reserved
  7.  
  8.                       AdeptSoft, AdeptXBBS, GateKeeper,
  9.                         are trademarks of AdeptSoft.
  10.  
  11.       "XBBS"  Copyright (c) 1988 - 1994 by M. Kimes. The "XBBS" name is a
  12.                            Trademark of M. Kimes.
  13.                                        
  14.  
  15.  
  16. ADEPT REXX INTERFACE
  17. ---------------------------------------------------------------------------
  18.  
  19.      AdeptXBBS comes with two 'menu' systems, the standard text, ASCII
  20.      based menu system and a REXX subsystem.  The REXX subsystem 
  21.      included with the BBS software allows all basic menu functions with 
  22.      some additional flexibility.
  23.  
  24.      We also offer, still in development, a complete REXX API subsystem 
  25.      that gives even the novice programmer control over the BBS 
  26.      software.
  27.  
  28.      With the AdeptXBBS REXX API Programming module you get access to all
  29.      available memory variables,  all internal functions,  and  
  30.      unrestricted access to all running nodes at one time.
  31.  
  32.      This is an extremely powerful module, giving control over the
  33.      entire BBS.  For programmers wishing to write their own programs in a
  34.      simple language, yet maintain the speed and flexibility of AdeptXBBS
  35.      this is for you.  We also have utilities that allow you to ship your
  36.      programs without making the source code available to the end user.
  37.  
  38.      Adept contains a REXX interface to the BBS functions.  This allows you
  39.      to create your own scripts to execute from Adept.  By using REXX
  40.      functions alone you can completely customize Adept.
  41.  
  42.      Three types of REXX commands can be automatically executed by Adept. 
  43.      They are .cmd, .srx and .erx files.  To be executed they need only 
  44.      exist in the .\Menus directory.  Below is a list of .cmd files that
  45.      Adept will automatically run if they exist in the .\Menus directory.
  46.  
  47.      Main.Cmd or Main?.Cmd
  48.      ---------------------
  49.      This REXX script is executed INSTEAD OF the default menu system.
  50.  
  51.      AtEnd.Cmd or AtEnd?.Cmd
  52.      -----------------------
  53.      This REXX script is executed after the user logs off (or the default
  54.      script has ended) The BPS rate will be zero and the time left will be
  55.      five minutes.  This script is executed before the user info is saved to
  56.      the user data base.
  57.  
  58.      AtStart.Cmd or AtStart?.Cmd
  59.      ---------------------------
  60.      This REXX script is executed at logon.  The filename with the line 
  61.      number is executed in place of 'AtStart.Cmd' if it exists.
  62.  
  63.      Exception.Cmd
  64.      -------------
  65.      This REXX script is executed if a exception violation occurs.  You can
  66.      use this script to notify the user of what just happened.  And to help
  67.      assist us by asking the user what they where doing when the exception
  68.      happened.
  69.  
  70.      ConvertXXX.Cmd
  71.      --------------
  72.      Where 'XXX' is a file extension of a type of file you wish to convert 
  73.      to another format.  For instance, if you want to convert ARC files to 
  74.      ZIP,you would create a ConvertARC.CMD ConvertARC.Cmd would then 
  75.      convert the file, if the file is converted it creates a file called 
  76.      "xxxxx.NewName" where 'xxxxx' is the file name without the extension 
  77.      This file contains 1 line, the line has the new filename of the file  
  78.      after it was converted.  Adept will use this filename when it puts 
  79.      the file info into the file system.
  80.  
  81.      ChatReq.Cmd or ChatReq?.Cmd
  82.      ---------------------------
  83.      Where '?' is the line number. 
  84.  
  85.      Fax.Cmd or Fax?.Cmd
  86.      -------------------
  87.      Where '?' is the line number.  Executed when modem returns a fax result
  88.      code.
  89.  
  90.  
  91.  
  92.      Standard and Extended REXX Programs:
  93.      ------------------------------------
  94.      .SRX stands for Standard REXX files.  They are the same as .CMD files 
  95.      in that they are not compiled in any way.  .ERX files are REXX files 
  96.      that have been preprocessed with the AdeptREXX Processor (Srx2Erx).  
  97.      ERX files are typically 50% smaller and always faster then standard 
  98.      REXX files (When run Cached).
  99.  
  100.      We are asking that people who write rexx scripts for Adept that are 
  101.      not preprocessed please use the extension .SRX.  The preprocessor 
  102.      will ONLY process files with the .SRX extension.
  103.  
  104.      Srx2Erx.Exe FileNameWithoutExtention will yield a file with the same
  105.      name, but the .ERX extension.  If you are a commercial developer is
  106.      recommended that you preprocess your rexx .SRX files before 
  107.      distributing them.  Also it recommended that you DO NOT preprocess 
  108.      the following!
  109.  
  110.      Atstart.Cmd - This MUST remain a .CMD file.  So that others may modify
  111.      it and chain needed rexx scripts (preprocessed or not) from it.
  112.  
  113.      The BBS software will only look for .ERX versions of files that we feel are
  114.      OK to preprocess.  In fact if you are running a .SRX file (i.e. .cmd)
  115.      file in cached mode (as we default to) it is treated as a .ERX file
  116.      after we preprocess it internally.  So it is honestly recommended that
  117.      you do not preprocess anything that you are NOT going to be
  118.      distributing.
  119.  
  120.  
  121.  
  122.      Proper REXX Programming Syntax:
  123.      -------------------------------
  124.      ALL REXX functions in the software unless you are looking for a value
  125.      should be called with the CALL function NOT with the () method.
  126.  
  127.      i.e.
  128.        Call AdeptChainRexx "RexxCmdFile.Cmd", line
  129.      NOT
  130.        AdeptChainRexx("RexxCmdFile.Cmd", line)
  131.      
  132.      The call method is always preferred but sometimes the API set does not 
  133.      call for it.  Those functions must be set equal to some variable as they 
  134.      return a value to the calling Script. 
  135.    
  136.      The second one will usually work correctly but not always.  It is always
  137.      preferred to use the first method.
  138.  
  139.      
  140.  
  141. ADEPT REXX INTERFACE CALLS
  142. ---------------------------------------------------------------------------
  143.  
  144.      Adept registers functions which can be called from the REXX 
  145.      interpreter.  These calls are used to interface a REXX script to 
  146.      number as the first argument to the function.  The REXX script should 
  147.      store that line number because it must be passed back to the 
  148.      AdeptREXX functions as the first parameter.
  149.  
  150.      Remember to Start every REXX script with /* <text if any> */ then on
  151.      the next line (or the one after) Do the following ..
  152.  
  153.          ARG Line
  154.          *OR*
  155.          ARG LineNumber
  156.  
  157.      Remember, if you use "Line", then all your REXX Function must have the
  158.      first parameter as "Line". If you use "LineNumber" then all your REXX
  159.      functions must have the first parameter as "LineNumber".  If you have
  160.      used ARG Line and in a function you have put "LineNumber" (where it's
  161.      supposed to be) then nothing will happen :), so you must remember to
  162.      always use the same argument that you started with.
  163.  
  164.          ** Example **
  165.  
  166.          You used ARG Line so all your Functions (AdeptPrint, AdeptCall,
  167.          AdeptInput, etc..) will have to be passed like so:
  168.  
  169.          Call AdeptPrint Line,"String"
  170.  
  171.          and NOT
  172.  
  173.          Call AdeptPrint LineNumber, "String"
  174.  
  175.      It is the same if you have the two reversed. So really, where ever you
  176.      see "LineNumber" in this file, you replace it with the argument you
  177.      stated at the beginning of the REXX script.
  178.      
  179.      Note:
  180.   
  181.      Strings:
  182.      Strings in REXX are denoted by the double quote mark.  Characters are 
  183.      marked by singe quotes. "String"  'A'
  184.     
  185.      Empty Parameters:
  186.      If the function you wish to use does not require all the parameters 
  187.      filled in, do not simply terminate the function call when you have put 
  188.      all the parameters in that you need.  Continue to complete the function 
  189.      definition with commas with no intervening spaces. 
  190.   
  191.            Example:
  192.   
  193.                 Call AdeptCall Linenumber,1,,'cmd.exe /c twar.bat'
  194.    
  195.            Notice that the flags field is empty and that there are no
  196.            intervening spaces.
  197.  
  198.      Debugging Scripts:
  199.      When your script has terminated abnormally you will notce an integer 
  200.      value in the Recent Events Screen.  To find out what the error was 
  201.      record that integer value down and open an OS/2 window and type 
  202.   
  203.            help rex(ReturnNumber)
  204.   
  205.      So if you have an error and the value in the Recent Events window is 
  206.      (-6), Open up an OS/2 window and type help rex6
  207.   
  208.   
  209.  
  210. FUNCTION LISTING
  211. ---------------------------------------------------------------------------
  212. AdeptGetVersion()
  213.  
  214.      FUNCTION USAGE
  215.        Value = AdeptGetVersion()
  216.        
  217.      ARGUMENTS
  218.        None
  219.  
  220.      RETURNED VALUE
  221.        Returns the Current Adept Version
  222.  
  223.      DESCRIPTION
  224.        Returns the Current Adept Version
  225.  
  226.      NOTE
  227.  
  228.      EXAMPLE
  229.        Call AdeptPrint line,"Running AdeptXBBS Version "||AdeptGetVersion()
  230.  
  231.      RELATED FUNCTIONS
  232.  
  233. ---------------------------------------------------------------------------
  234. AdeptGetTempUser()
  235.  
  236.      FUNCTION USAGE
  237.        Value = AdeptGetTempUser(UserName)
  238.        
  239.      ARGUMENTS
  240.        UserName:
  241.        Users' Name
  242.  
  243.      RETURNED VALUE
  244.        Returns a userid to be used by the TempUser family of functions.
  245.  
  246.      DESCRIPTION
  247.        Gets a Temporary User record.  
  248.  
  249.      NOTE
  250.  
  251.      EXAMPLE
  252.        userid = AdeptGetTempUser("Paul Meyer")
  253.  
  254.      RELATED FUNCTIONS
  255.        AdeptGetTempUserVar()
  256.        AdeptPutTempUserVar()
  257.        AdeptFreeTempUser()
  258.        AdeptSaveTempUser()
  259.  
  260. ---------------------------------------------------------------------------
  261. AdeptGetTempUserVar()
  262.  
  263.      FUNCTION USAGE
  264.        Call AdeptGetTempUserVar UserID, Variable 
  265.        or
  266.        Value = AdeptGetTempUserVar(UserID, Variable)
  267.        
  268.      ARGUMENTS
  269.        UserID:
  270.        Userid Created by AdeptGetTempUser.
  271.        
  272.        Variable:
  273.        Number of variable to return.  Where the value can be a number
  274.        between 1 and 62 (See AdeptGetVar() for the list of variables)
  275.  
  276.      RETURNED VALUE
  277.        Returns the contents of the variable requested from userid.
  278.  
  279.      DESCRIPTION
  280.        Gets a Variable from a Temporary User record.  
  281.  
  282.      NOTE
  283.  
  284.      EXAMPLE
  285.        tempuserhandle = AdeptGetTempUserVar(userid,2)
  286.  
  287.      RELATED FUNCTIONS
  288.        AdeptGetTempUser()
  289.        AdeptPutTempUserVar()
  290.        AdeptFreeTempUser()
  291.        AdeptSaveTempUser()
  292.  
  293. ---------------------------------------------------------------------------
  294. AdeptPutTempUserVar()
  295.  
  296.      FUNCTION USAGE
  297.        Call AdeptGetTempUserVar UserID, Variable, Value
  298.        or
  299.        Value = AdeptGetTempUserVar(UserID, Variable, Value)
  300.        
  301.      ARGUMENTS
  302.        UserID:
  303.        Userid Created by AdeptGetTempUser.
  304.        
  305.        Variable:
  306.        Number of variable to place value.  Where the variable can be a 
  307.        number between 1 and 62 (See AdeptGetVar() for the list of variables)
  308.        
  309.        Value:
  310.        New value to place in Variable.
  311.  
  312.      RETURNED VALUE
  313.  
  314.      DESCRIPTION
  315.        Places value in a Temporary User record.  
  316.  
  317.      NOTE
  318.  
  319.      EXAMPLE
  320.        This example would change the user Joe Bloggs' handle to Sysop.
  321.        
  322.        userid = AdeptGetTempUser("Joe Bloggs")
  323.        Call AdeptPutTempUserVar userid, 2, "Sysop"
  324.        Call AdeptSaveTempUser userid
  325.        Call AdeptFreeTempUser userid
  326.  
  327.      RELATED FUNCTIONS
  328.        AdeptGetTempUser()
  329.        AdeptGetTempUserVar()
  330.        AdeptFreeTempUser()
  331.        AdeptSaveTempUser()
  332.  
  333. ---------------------------------------------------------------------------
  334. AdeptFreeTempUser()
  335.  
  336.      FUNCTION USAGE
  337.        Call AdeptFreeTempUser UserID
  338.        or
  339.        Value = AdeptFreeTempUser(UserID)
  340.        
  341.      ARGUMENTS
  342.        UserID:
  343.        Userid Created by AdeptGetTempUser.
  344.  
  345.      RETURNED VALUE
  346.  
  347.      DESCRIPTION
  348.        Frees the userid record.  
  349.  
  350.      NOTE
  351.  
  352.      EXAMPLE
  353.        Call AdeptFreeTempUser userid
  354.  
  355.      RELATED FUNCTIONS
  356.        AdeptGetTempUser()
  357.        AdeptGetTempUserVar()
  358.        AdeptPutTempUserVar()
  359.        AdeptSaveTempUser()
  360.  
  361. ---------------------------------------------------------------------------
  362. AdeptSaveTempUser()
  363.  
  364.      FUNCTION USAGE
  365.        Call AdeptSaveTempUser UserID
  366.        or
  367.        Value = AdeptSaveTempUser(UserID)
  368.        
  369.      ARGUMENTS
  370.        UserID:
  371.        Userid Created by AdeptGetTempUser.
  372.  
  373.      RETURNED VALUE
  374.  
  375.      DESCRIPTION
  376.        Saves any changes made to the userid record.
  377.  
  378.      NOTE
  379.  
  380.      EXAMPLE
  381.        Call AdeptSaveTempUser userid
  382.  
  383.      RELATED FUNCTIONS
  384.        AdeptGetTempUser()
  385.        AdeptGetTempUserVar()
  386.        AdeptPutTempUserVar()
  387.        AdeptFreeTempUser()
  388.  
  389. ---------------------------------------------------------------------------
  390. AChatSendMsg()
  391.  
  392.      FUNCTION USAGE
  393.        Call AChatSendMsg LineNumber, Flags, MsgTo, Text
  394.  
  395.      ARGUMENTS
  396.        LineNumber:
  397.        Node Number passed to REXX routine from Adept as first parameter. 
  398.          
  399.        Flags:
  400.        To be deciphered :)
  401.          
  402.        MsgTo:
  403.        Name to send message to.
  404.          
  405.        Text:
  406.        Text to send.
  407.  
  408.      RETURNED VALUE
  409.  
  410.      DESCRIPTION
  411.  
  412.      NOTE
  413.        This function is untested and due to the fact that other functions
  414.        similar to this do not exist anymore/are not completed, this function
  415.        may not exist in the future.
  416.  
  417.      EXAMPLE
  418.  
  419.      RELATED FUNCTIONS
  420.  
  421. ---------------------------------------------------------------------------
  422. Adept16BitCRC()
  423.  
  424.      FUNCTION USAGE
  425.        Value = Adept16BitCRC(LineNumber, String)
  426.  
  427.      ARGUMENTS
  428.        LineNumber:
  429.          Node Number passed to REXX routine from Adept as first parameter. 
  430.          
  431.        String:
  432.          String to CRC
  433.  
  434.      RETURNED VALUE
  435.        Returns 16bit CRC'd version of String
  436.  
  437.      DESCRIPTION
  438.        Returns the 16bit CRC version of the String passed.
  439.  
  440.      NOTE
  441.  
  442.      EXAMPLE
  443.  
  444.      RELATED FUNCTIONS
  445.        Adept32BitCRC()
  446.  
  447. ---------------------------------------------------------------------------
  448. Adept32BitCRC()
  449.  
  450.      FUNCTION USAGE
  451.        Value = Adept32BitCRC(LineNumber, String)
  452.  
  453.      ARGUMENTS
  454.        LineNumber:
  455.          Node Number passed to REXX routine from Adept as first parameter. 
  456.          
  457.        String:
  458.          String to CRC
  459.  
  460.      RETURNED VALUE
  461.        Returns 32bit CRC'd verision of String
  462.  
  463.      DESCRIPTION
  464.        Returns the 32bit CRC version of the String passsed.
  465.  
  466.      NOTE
  467.        Use to check users' password.
  468.  
  469.      EXAMPLE
  470.  
  471.      RELATED FUNCTIONS
  472.        Adept16BitCRC()
  473.  
  474. ---------------------------------------------------------------------------
  475. AdeptAddToXferList()
  476.  
  477.      FUNCTION USAGE
  478.        Call AdeptAddToXferList LineNumber, File
  479.  
  480.      ARGUMENTS
  481.        LineNumber: 
  482.          Node Number passed to REXX routine from Adept as first parameter. 
  483.        
  484.        File:
  485.          Path/Filename of file to add to list.
  486.      
  487.      RETURNED VALUE
  488.  
  489.      DESCRIPTION
  490.        Adds File to the users tagged file list.
  491.  
  492.      NOTE
  493.  
  494.      EXAMPLE
  495.        Call AdeptAddToXFerList line,"/files/newfiles.txt"
  496.  
  497.      RELATED FUNCTIONS
  498.        AdeptClearXFerList()
  499.  
  500. ---------------------------------------------------------------------------
  501. AdeptCall()
  502.  
  503.      FUNCTION USAGE
  504.        Call AdeptCall LineNumber, Type, Flags, String1, ..., StringN
  505.        or
  506.        Value = AdeptCall(LineNumber, Type, Flags, String1, ..., StringN)
  507.  
  508.      ARGUMENTS
  509.        LineNumber: 
  510.        Node Number passed to REXX routine from Adept as first parameter. 
  511.  
  512.        Type:
  513.        1   Same as menu item 801. Spawn a separate session. 
  514.            Strings are concatenated to form one string which is 
  515.            used as the spawn string. Can be used for a door 
  516.            program that accesses the com port in a more 
  517.            traditional (and complicated) fashion.
  518.            You can run DOS doors here also.
  519.            Flags: 1 - Start session in background.
  520.        
  521.        2   Same as menu item 802. Run OS/2 type door.
  522.            (same as menu item 800 but assumes a program which is 
  523.            more friendly to having its I/O redirected thru pipes 
  524.            to the com port.)  Program must allow itself to be 
  525.            killed.
  526.            Flags:  Not Used.
  527.  
  528.        3   Same as menu item 800. Run OS/2 type door. Program must 
  529.            allow itself to be killed.
  530.            Flags:  Not Used.
  531.  
  532.        Flags:
  533.        Only Used for a Type 1 call.
  534.        1   Start session in background.
  535.  
  536.        String1..N:
  537.        Strings are added together to form one string which is used to 
  538.        spawn the session.
  539.  
  540.      RETURNED VALUE
  541.        0       No Error
  542.  
  543.      DESCRIPTION
  544.        Runs an external program.  All sessions inherit Adepts environment.
  545.  
  546.      NOTE
  547.  
  548.      EXAMPLE
  549.        The following EXAMPLE would call the batch file twar.bat and run 
  550.        TradeWars in the Foreground.
  551.  
  552.        Call AdeptCall Linenumber,1,,'cmd.exe /c twar.bat'
  553.  
  554.      RELATED FUNCTIONS
  555.          
  556. ---------------------------------------------------------------------------
  557. AdeptChainRexx()
  558.  
  559.      FUNCTION USAGE
  560.        Call AdeptChainRexx "RexxScriptName", LineNumber
  561.        or
  562.        Value = AdeptChainRexx("RexxScriptName", LineNumber)
  563.  
  564.      ARGUMENTS
  565.        RexxScriptName:
  566.        Name and path of file you want to run.
  567.  
  568.        LineNumber: 
  569.        Node Number passed to REXX routine from Adept as first parameter. 
  570.  
  571.      RETURNED VALUE
  572.  
  573.      DESCRIPTION
  574.        Chains REXX files within REXX files.  Runs the rexx script in cached 
  575.        mode.
  576.  
  577.      NOTE
  578.  
  579.      EXAMPLE
  580.  
  581.      RELATED FUNCTIONS
  582.        AdeptChainRexxNc()
  583.  
  584. ---------------------------------------------------------------------------
  585. AdeptChainRexxNc()
  586.  
  587.      FUNCTION USAGE
  588.        Call AdeptChainRexxNc "RexxScriptName", LineNumber
  589.  
  590.      ARGUMENTS
  591.        RexxScriptName:
  592.        Name and path of file you want to run.
  593.  
  594.        LineNumber: 
  595.        Node Number passed to REXX routine from Adept as first parameter. 
  596.  
  597.      RETURNED VALUE
  598.  
  599.      DESCRIPTION       
  600.        Chains REXX files within REXX files.  Runs the rexx script in 
  601.        cached mode. 
  602.  
  603.      NOTE
  604.        Once a script is cached by Adept into Memory it will remain there 
  605.        until you shut down Adept.  So if you modify a script, the changes 
  606.        will not take effect until you shutdown Adept.
  607.  
  608.      EXAMPLE
  609.        The following would chain the REXX file Pager.ERX from another REXX 
  610.        script and not cache the script into memory.
  611.  
  612.        Call AdeptChainRexxNc "D:\Adept\Batch\Pager.Erx",LineNumber
  613.   
  614.      RELATED FUNCTIONS
  615.        AdeptChainRexx()
  616.   
  617. ---------------------------------------------------------------------------
  618. AdeptChangeGroup()
  619.  
  620.      FUNCTION USAGE
  621.        Call AdeptChangeGroup LineNumber, GroupNum
  622.        or
  623.        Value = AdeptChangeGroup(LineNumber, GroupNum)
  624.  
  625.      ARGUMENTS
  626.        LineNumber: 
  627.        Node Number passed to REXX routine from Adept as first parameter. 
  628.  
  629.        GroupNum:
  630.        Number that corresponds to the group level that you want to 
  631.        change the user to.
  632.  
  633.      RETURNED VALUE
  634.        0       Users group was not upgraded or GroupNum not found.
  635.        1       Successful upgrade.
  636.  
  637.      DESCRIPTION
  638.        This works just like upgrading a users group in the local user 
  639.        editor.  The user will take on the changes specified for the specific 
  640.        group that they have joined/are in.
  641.  
  642.      NOTE
  643.  
  644.      EXAMPLE
  645.        The following EXAMPLE will change the current user to group level 10.
  646.  
  647.        Call AdeptChangeGroup LineNumber, 10
  648.  
  649.      RELATED FUNCTIONS
  650.  
  651. ---------------------------------------------------------------------------
  652. AdeptCheckCard()
  653.  
  654.      FUNCTION USAGE
  655.        Call AdeptCheckCard(LineNumber, String)
  656.  
  657.      ARGUMENTS
  658.        LineNumber: 
  659.        Node Number passed to REXX routine from Adept as first parameter. 
  660.  
  661.      RETURNED VALUE
  662.        0       on error
  663.        >0      for no error
  664.  
  665.      DESCRIPTION
  666.  
  667.      NOTE
  668.  
  669.      EXAMPLE
  670.  
  671.      RELATED FUNCTIONS
  672.  
  673. ---------------------------------------------------------------------------
  674. AdeptCheckBit()
  675.  
  676.      FUNCTION USAGE
  677.        Call AdeptCheckBit Linenumber, BitNumber, Numeric Long
  678.        or
  679.        Value = AdeptCheckBit(Linenumber, BitNumber, Numeric Long)
  680.  
  681.      ARGUMENTS
  682.        LineNumber: 
  683.        Node Number passed to REXX routine from Adept as first parameter. 
  684.  
  685.        BitNumber:
  686.        Which bit number to check.
  687.        
  688.        Numeric Long:
  689.        A numeric long to be checked.  ie - User Flags.
  690.  
  691.      RETURNED VALUE
  692.        1       Bit is set
  693.        0       Bit is not set
  694.      
  695.      DESCRIPTION
  696.        This can be used to test if a users bit is turned on for any of 
  697.        the LONG bitmap'd flags.
  698.  
  699.      NOTE
  700.  
  701.      EXAMPLE
  702.        The following EXAMPLE will check to see if the current user has
  703.        bit number 10 turned on.  If so, it will print "Flag 10 is on!"
  704.        If the bit is not set, it will not print anything.
  705.  
  706.        UserFlag = AdeptGetVar(LineNumber, 42) /* 42 - User Flags */
  707.        IsOn = AdeptCheckBit(LineNumber, 10, UserFlag)
  708.        if IsOn = '1' then
  709.           Call AdeptPrint LineNumber, "Flag 10 is on!\r\n"
  710.  
  711.      RELATED FUNCTIONS
  712.        AdeptSetBit()
  713.        AdeptUnSetBit()
  714.  
  715. ---------------------------------------------------------------------------
  716. AdeptClearXferList()
  717.      
  718.      FUNCTION USAGE
  719.        Call AdeptClearXferList LineNumber
  720.  
  721.      ARGUMENTS
  722.        LineNumber: 
  723.        Node Number passed to REXX routine from Adept as first parameter. 
  724.  
  725.      RETURNED VALUE
  726.  
  727.      DESCRIPTION
  728.        Empties users' Tagged file list
  729.      
  730.      NOTE
  731.  
  732.      EXAMPLE
  733.        Call AdeptClearXferList line
  734.  
  735.      RELATED FUNCTIONS
  736.        AdeptAddToXFerList()
  737.  
  738. ---------------------------------------------------------------------------
  739. AdeptCls()
  740.  
  741.      FUNCTION USAGE
  742.        Call AdeptCls LineNumber
  743.        or
  744.        Value = AdeptCls(LineNumber)
  745.  
  746.      ARGUMENTS
  747.        LineNumber: 
  748.        Node Number passed to REXX routine from Adept as first parameter. 
  749.  
  750.      RETURNED VALUE
  751.  
  752.      DESCRIPTION
  753.        Clears local and remote screen.
  754.  
  755.      NOTE
  756.  
  757.      EXAMPLE
  758.        The following EXAMPLE will clear the screen
  759.  
  760.        Call AdeptCls LineNumber
  761.  
  762.      RELATED FUNCTIONS
  763.  
  764. ---------------------------------------------------------------------------
  765. AdeptConvert()
  766.  
  767.      FUNCTION USAGE
  768.        Value = AdeptConvert(LineNumber, String)
  769.  
  770.      ARGUMENTS
  771.        LineNumber: 
  772.        Node Number passed to REXX routine from Adept as first parameter. 
  773.  
  774.        String:
  775.        String which contains META variables which need to be converted.
  776.  
  777.      RETURNED VALUE
  778.        Converted string.
  779.  
  780.      DESCRIPTION
  781.        Converts META variables passed in String.
  782.  
  783.      NOTE
  784.  
  785.      EXAMPLE
  786.        The following EXAMPLE will convert the Meta variable {F5 to dred. 
  787.        {F5 is the Meta var for the color dark red. So where ever you use
  788.        dred it will put it in Dark Red since there are some Functions 
  789.        that do not support Meta Codes (NOT just color, ALL Meta Codes)
  790.  
  791.        dred=AdeptConvert(LineNumber,'{F5')
  792.  
  793.      RELATED FUNCTIONS
  794.  
  795. ---------------------------------------------------------------------------
  796. AdeptCurPos()
  797.  
  798.      FUNCTION USAGE
  799.        Call AdeptCurPos LineNumber, Row, Column
  800.        or
  801.        Value = AdeptCurPos(LineNumber, Row, Column)
  802.  
  803.      ARGUMENTS
  804.        LineNumber: 
  805.        Node Number passed to REXX routine from Adept as first parameter. 
  806.        
  807.        Row:
  808.        Screen row to move the cursor to.
  809.        
  810.        Column:
  811.        Screen column to move the cursor to.
  812.        
  813.      RETURNED VALUE
  814.        "row col" - returns the row value then the column value separated by 
  815.                    a space.
  816.  
  817.      DESCRIPTION
  818.        Moves Cursor to row, column
  819.  
  820.      NOTE
  821.  
  822.      EXAMPLE
  823.        Call AdeptCurPos line,20,10
  824.  
  825.      RELATED FUNCTIONS
  826.  
  827. ---------------------------------------------------------------------------
  828. AdeptDropGlobalVar()
  829.  
  830.      FUNCTION USAGE
  831.        RetCode = AdeptDropGlobalVar('VarName')
  832.  
  833.      ARGUMENTS
  834.  
  835.      RETURNED VALUE
  836.  
  837.      DESCRIPTION
  838.        AdeptDropGlobalVar will free the memory space occupied by VarName, 
  839.        where VarName is a Global Variable made by AdeptSetGlobalVar.
  840.   
  841.      NOTE
  842.  
  843.      EXAMPLE
  844.        
  845.        AdeptDropGlobalVar('VarName')
  846.    
  847.      RELATED FUNCTIONS
  848.        AdeptGetGlobalVar()
  849.        AdeptSetGlobalVar()
  850.  
  851. ---------------------------------------------------------------------------
  852. AdeptFile()
  853.  
  854.      FUNCTION USAGE
  855.        Call AdeptFile LineNumber, Type, StartAt, KeyName
  856.          
  857.      ARGUMENTS
  858.        LineNumber: 
  859.        Node Number passed to REXX routine from Adept as first parameter. 
  860.  
  861.        Type:
  862.        1     Returns name of current file area.
  863.        2     Returns number of current file area.
  864.        3     Find file area by number.
  865.              Returns file area number
  866.        4     Find file area by name.
  867.              Returns name of current file area.
  868.        5     Go to next file area
  869.              Returns name of current file area.
  870.        6     Go to previous file area
  871.              Returns name of current file area.
  872.        7     Returns download path of current file area.
  873.        8     Returns upload path of current file area.
  874.  
  875.        StartAt:
  876.        Only required for Type 3.
  877.        Number of area to look for.
  878.  
  879.        Keyname:
  880.        Only required for Type 4.
  881.        Name of area to look for.
  882.  
  883.      RETURNED VALUE
  884.        Type:
  885.        1       Name of current file area.
  886.        2       Number of current file area.
  887.        3       File area number.
  888.        4       File area name.
  889.        5       Sets area to the Next file area and returns file area name.
  890.        6       Sets area to the Previous file area and returns file area name.
  891.        7       Download path of current file area.
  892.        8       Upload path of current area.
  893.  
  894.      DESCRIPTION
  895.        File area manipulation
  896.  
  897.      NOTE
  898.  
  899.      EXAMPLE
  900.        Call AdeptFile LineNumber,4,,"AdeptSoft" /* This would find the File
  901.                                                    area "AdeptSoft" as
  902.                                                    listed in File_Areas */
  903.        Call AdeptFile LineNumber,5,,""          /* Goto next area       */
  904.        Call AdeptFile LineNumber,6,,""          /* Goto previous area   */
  905.       
  906.      RELATED FUNCTIONS
  907.        AdeptMessage()
  908.        AdeptLibrary()
  909.  
  910. ---------------------------------------------------------------------------
  911. AdeptGetGlobalVar()
  912.  
  913.      FUNCTION USAGE
  914.        RetCode = AdeptGetGlobalVar('VarName')
  915.  
  916.      ARGUMENTS
  917.        VarName:
  918.        Name of global variable.
  919.  
  920.      RETURNED VALUE
  921.        Returns value of the global variable.
  922.  
  923.      DESCRIPTION
  924.        AdeptGetGlobalVar will pull a variable's value out of memory. 
  925.   
  926.      NOTE
  927.  
  928.      EXAMPLE  
  929.        RetCode = AdeptGetGlobalVar('STATUS')
  930.   
  931.      RELATED FUNCTIONS
  932.        AdeptSetGlobalVar()
  933.        AdeptDropGlobalVar()
  934.  
  935. ---------------------------------------------------------------------------
  936. AdeptGetVar() and 
  937. AdeptPutVar()
  938.  
  939.      FUNCTION USAGE
  940.        Value = AdeptGetVar(LineNumber, varnumber)
  941.        or
  942.        Value = AdeptPutVar(LineNumber, varnumber, Data)
  943.  
  944.      ARGUMENTS
  945.        LineNumber: 
  946.        Node Number passed to REXX routine from Adept as first parameter. 
  947.  
  948.        varnumber:
  949.        Variable number from the list below.
  950.  
  951.        Data:
  952.        Data that you want to replace in varnumber.
  953.  
  954.      RETURNED VALUE
  955.  
  956.      DESCRIPTION
  957.        This function duplicates some of the functions already in the
  958.        AdeptREXX language.  This returns almost every single variable 
  959.        Adept uses in the BBS software.  This will give a REXX programmer 
  960.        total control over all of the BBS's users and mailers memory 
  961.        variables.
  962.        There will also be some new variables added that will be blank.
  963.        These variables will be usable in real time across nodes by 
  964.        multiple REXX programs running at the same time.  The 
  965.        possibilities of such a setup are limitless.
  966.  
  967.      NOTE
  968.        The following are the variable numbers:
  969.  
  970.          User Info:
  971.             1 - Users Name
  972.             2 - Users Handle
  973.             3 - Users Address
  974.             4 - Users Address1
  975.             5 - Users Address2
  976.             6 - Users City
  977.             7 - Users State
  978.             8 - Users Zipcode
  979.             9 - Users Home Phone
  980.             10 - Users Data Phone
  981.             11 - Users Fax Phone
  982.             12 - Users Business Phone
  983.             13 - Users Interests
  984.             14 - Sysop Comment about User
  985.             15 - Users Bank Time
  986.             16 - Users Computer Type (Number)
  987.             17 - Users User ID
  988.             18 - Users Point ID
  989.             19 - Users BirthYear
  990.             20 - Users BirthMonth
  991.             21 - Users BirthDay
  992.             22 - Users Gender (Represented by 1 letter)
  993.             23 - Users NetMail Credit
  994.             25 - The Group the User belongs to
  995.             27 - Time Used Today
  996.             28 - Time Per Day
  997.             29 - Time Per Call
  998.             30 - Number of calls the user has made
  999.             31 - Upload Number
  1000.             32 - Download Number
  1001.             33 - Uploads in K
  1002.             34 - Downloads in K
  1003.             35 - Upload K today
  1004.             36 - Download K today
  1005.             37 - Upload K per day (Max Allowed)
  1006.             38 - Download K per day (Max Allowed)
  1007.             39 - Number of posts (Total)
  1008.             40 - Security Level #1
  1009.             41 - Security Level #2
  1010.             42 - Flags represented as a 32-bit long
  1011.             43 - Flags2 Represented as a 32-bit long
  1012.             44 - User Attributes represented as a 32-bit long
  1013.             45 - User Attributes #2 represented as a 32-bit long
  1014.             46 - Users Screen Length
  1015.             47 - Users Screen width
  1016.             48 - Last Message Area number user was in
  1017.             49 - Last File Area Number user was in
  1018.             50 - Last Protocol Chosen (Returns the letter for the protocol)
  1019.             51 - Last Archiver Chosen Returns Archive Letter
  1020.             53 - Percentage of Upload/Download ratio to consider the user a
  1021.                  leech
  1022.             54 - Maximum Bank time allowed for this user
  1023.             55 - Password Represented as a 32-bit long (32-bit CRC)
  1024.             56 - Password reversed represented as a 32-bit long (32-bit 
  1025.                  CRC)
  1026.             57 - Max Messages to pack into a mail packet.
  1027.             58 - Users Age
  1028.             59 - User Bad Password Attempts
  1029.             60 - MailStatus (I forget how we use this at the moment)
  1030.             61 - Number of lines shown to the remote user since last reset
  1031.                  (clear screen or new screen shown, etc).  This is 
  1032.                  calculated by the display subsystem and should always be 
  1033.                  correct.
  1034.                  This variable takes everything from ANSI and Avatar cursor
  1035.                  movement into account, to number of actual lines 
  1036.                  displayed.
  1037.             62 - Did the user pick non-stop display after the last more
  1038.                  prompt or non-stop display choice.
  1039.  
  1040.          BBS Info:
  1041.             100 - Number of Calls to the BBS
  1042.             101 - Last User ID Assigned by the BBS
  1043.             102 - Last Point ID Assigned by the BBS
  1044.             103 - Minimum Age Required to Log on
  1045.             104 - Maximum Age Allows on the BBS
  1046.             105 - Amount of NetMail Credit the user has
  1047.             106 - Expire Users after x amount of days
  1048.             107 - Expire Users after x amount of minutes
  1049.             108 - Default User Time Per Day
  1050.             109 - Default User Security Level #1
  1051.             110 - Default User Security Level #2
  1052.             111 - BBS User Default Flags #1 returned as a 32-bit long
  1053.             112 - BBS User Default Flags #2 returned as a 32-bit long
  1054.             113 - Default Upload K per day max
  1055.             114 - Maximum download k per day
  1056.             115 - BBS User Default Attribs returned as a 32-bit long
  1057.             116 - BBS User Default Attribs #2 returned as 32-bit long
  1058.             117 - The default group the user belongs to.  The user will      
  1059.                   inherit the default settings for this group. 0 for none.
  1060.             118 - Maximum Users to allow in the user file
  1061.             119 - Default Origin Line for EchoMail Areas
  1062.             120 - Maximum Password Attempts Allowed
  1063.             125 - Default Cost to send a NetMail message
  1064.             126 - Line number the BBS is on in the quote file
  1065.             127 - Default Maximum Time Per Call
  1066.             128 - I don't remember I will have to check this one (ulmulti)
  1067.             129 - Odds of getting a quote when called
  1068.             130 - Mailer Incoming Password Protected Mail Path
  1069.             131 - Mailer OkFile for Password Protected Nodes
  1070.             132 - Mailer Incoming Public Mail Path
  1071.             133 - Mailer OkFile for Public Mail
  1072.             134 - Mailer Unlisted Node Mail Path
  1073.             135 - Mailer OkFile for Unlisted Nodes
  1074.             136 - Number of times a user can page the sysop
  1075.             137 - The BBS's Name
  1076.             138 - BBS UAttribs 32-bit long
  1077.             139 - BBS UAttribs #2 32-bit long
  1078.             140 - Sysops Name
  1079.             141 - Is The Sysop In (0 or 1)
  1080.             142 - Default Max Messages in Packet
  1081.             143 - City/State info for BBS & .QWK Packet
  1082.             144 - .QWK BBS ID
  1083.             145 - BBS .QWK Phone Number
  1084.             146 - Default Max Bank Time
  1085.  
  1086.          Modem/Mailer Info:
  1087.             200 - Modem Handle
  1088.             201 - Node Number
  1089.             202 - Port Name (COM1, \PIPE\ADEPT1, etc)
  1090.             203 - Modem Init String
  1091.             204 - Default Dialing Prefix
  1092.             205 - Default Dialing Suffix
  1093.             206 - Optional Dialing Prefix #1
  1094.             207 - Optional Dialing Suffix #1
  1095.             208 - Optional Dialing Prefix #2
  1096.             209 - Optional Dialing Suffix #2
  1097.             210 - Optional Dialing Prefix #3
  1098.             211 - Optional Dialing Suffix #3
  1099.             212 - Optional Dialing Prefix #4
  1100.             213 - Optional Dialing Suffix #4
  1101.             214 - Optional Dialing Prefix #5
  1102.             215 - Optional Dialing Suffix #5
  1103.             216 - Optional Dialing Prefix #6
  1104.             217 - Optional Dialing Suffix #6
  1105.             218 - Optional Dialing Prefix #7
  1106.             219 - Optional Dialing Suffix #7
  1107.             220 - Optional Dialing Prefix #8
  1108.             221 - Optional Dialing Suffix #8
  1109.             222 - Modem Answer String
  1110.             223 - Obsolete
  1111.             224 - Obsolete
  1112.             225 - Mail Only Event Text
  1113.             226 - Text if User is too slow
  1114.             228 - Baud Rate to Init Modem at
  1115.             229 - Minimum Baud rate Allowed on BBS
  1116.             230 - Minimum Incoming Baud Rate for Mail
  1117.             231 - Minimum Baud Rate to Call Out for Mail
  1118.             232 - Maximum Baud Rate for Outbound Mail
  1119.             233 - Current Baud Rate of Modem
  1120.             234 - Minimum Cost of Mail for This Event (Dialout)
  1121.             235 - Maximum Cost of Mail for This Event (Dialout)
  1122.             236 - Maximum Mail in K to send in a mail session
  1123.             237 - Maximum Time Limit for a mail session
  1124.             239 - Maximum Bad Mail Calls before no more are made
  1125.             240 - Maximum Times to call a node to send mail
  1126.             241 - If Port Locked (0 / 1)
  1127.             242 - Allow Human Callers or Users on the BBS? (0/1)
  1128.             243 - Allow File Requests (0/1)
  1129.             244 - Accept File Request (0/1)
  1130.             245 - Dialing Out OK?
  1131.             246 - OK To Answer the Phone?
  1132.             248 - Force FTS-0001 Mail Sessions (0/1)
  1133.             249 - Receive Mail From Unlisted Nodes? (0/1)
  1134.             250 - Send Mail to Unlisted Nodes? (0/1)
  1135.             251 - Was the last incoming call to the BBS or Mail 
  1136.                   (1 for BBS, 0 for mailer)
  1137.             252 - Sealink Overdrive Off (0/1) 1 = off
  1138.             253 - Sealink Mail On/Off (1 = on)
  1139.             254 - 1k Sealink On/Off (1 = off)
  1140.             255 - Allow DietINFA (1 = on (TBBS & XBBS use dietINFA))
  1141.             256 - In Chat with Sysop (0/1)
  1142.             257 - Debug Transfers (0/1) Extra Log Info
  1143.             258 - Allow Hydra Mail Transfers (0/1) (Currently Disabled)
  1144.             259 - Allow ZedZip for Mail Transfers (0/1)
  1145.             260 - Allow ZedZap for Mail Transfer (0/1)
  1146.             261 - Turn the mailer off? (0/1) 1 = off
  1147.             262 - Key to represent Yes (Y) for USA
  1148.             263 - Key to represent No (N) for USA
  1149.             264 - Key to represent Stop (S) for USA
  1150.             264 - Key to represent Pause (P) for USA
  1151.             264 - Key to represent Quit (Q) for USA
  1152.             268 - Maximum # of resyncs to abort transfers
  1153.             269 - Maximum # of transfer errors to abort on
  1154.             270 - Last Users on this lines name
  1155.             271 - Last Mailer to call this node
  1156.             272 - Last Long Entry Written
  1157.             276 - Check Carrier Detect (0/1) 1 = on
  1158.             277 - Video Display Handle
  1159.             278 - Number of ring to wait for answer on this node
  1160.  
  1161.      EXAMPLE        
  1162.        The following would come out like "Welcome to AdeptSoft! You are welcomed
  1163.        by Julie Strietelmeier". (Except AdeptSoft would be your BBS name and
  1164.        Julie Strietelmeier would be your name.
  1165.  
  1166.        BBSname=AdeptGetVar(LineNumber,137)
  1167.        SYSOPname=AdeptGetVar(LineNumber,140)
  1168.  
  1169.        AdeptPrint(line,"\r\nWelcome to " BBSname "! You are welcomed by "
  1170.        SYSOPname)
  1171.  
  1172.      RELATED FUNCTIONS
  1173.  
  1174. ---------------------------------------------------------------------------
  1175. AdeptHitReturn()
  1176.  
  1177.      FUNCTION USAGE
  1178.        Call AdeptHitReturn LineNumber
  1179.  
  1180.      ARGUMENTS
  1181.        LineNumber: 
  1182.        Node Number passed to REXX routine from Adept as first parameter. 
  1183.         
  1184.      RETURNED VALUE
  1185.  
  1186.      DESCRIPTION         
  1187.        AdeptHitReturn will wait for the user to press enter.  This will
  1188.        use the Press Enter to continue in the English.Text or other
  1189.        language file.
  1190.  
  1191.      NOTE
  1192.  
  1193.      EXAMPLE
  1194.        The following would prompt the user to press Enter (return) to continue.
  1195.  
  1196.        Call AdeptHitReturn LineNumber
  1197.  
  1198.      RELATED FUNCTIONS
  1199.        AdeptMore()
  1200.  
  1201. ---------------------------------------------------------------------------
  1202. AdeptInKey()
  1203.  
  1204.      FUNCTION USAGE
  1205.        Call AdeptInKey LineNumber
  1206.        or
  1207.        Value = AdeptInKey(LineNumber)
  1208.  
  1209.      ARGUMENTS
  1210.        LineNumber: 
  1211.        Node Number passed to REXX routine from Adept as first parameter. 
  1212.  
  1213.      RETURNED VALUE
  1214.        0       No Keys waiting
  1215.        If the function does not return 0, then it will return the ASCII
  1216.        code for the incoming key sequence.
  1217.  
  1218.      DESCRIPTION
  1219.        AdeptInKey will return the ASCII code for a incoming key sequence.
  1220.        AdeptInKey will not wait for a key, it will return 0 if there are 
  1221.        no keys waiting.  If you use this in a loop, please offset the 
  1222.        amount of CPU time a loop uses with a AdeptSleep command.
  1223.  
  1224.      NOTE
  1225.  
  1226.      EXAMPLE
  1227.  
  1228.        ReturnCode = AdeptInKey(LineNumber)
  1229.  
  1230.      RELATED FUNCTIONS
  1231.        AdeptTimedInKey()
  1232.        AdeptWaitKey()
  1233.  
  1234. ---------------------------------------------------------------------------
  1235. AdeptInput()
  1236.    
  1237.      FUNCTION USAGE
  1238.        Value = AdeptInput(LineNumber, MinLen, MaxLen, Type, Flags, 
  1239.                           Prompt, Help, HelpFile, Default)
  1240.  
  1241.      ARGUMENTS
  1242.        LineNumber:
  1243.        Node number passed to REXX routine from Adept as first parameter.
  1244.        
  1245.        MinLen:
  1246.        Minimum length of input string.
  1247.  
  1248.        MaxLen:
  1249.        Maximum length of input string.
  1250.  
  1251.        Type:
  1252.        /* Types for AdeptInput */
  1253.        STRT_ALPHA            /* Letters Only */
  1254.        STRT_NUMERIC          /* Numbers Only */
  1255.        STRT_ALPHANUMERIC     /* Letters and Numbers Only */
  1256.        STRT_HEX              /* Read as Hexadecimal */
  1257.        STRT_FILENAME         /* Read as Filename */
  1258.        STRT_FILESPEC         /* Read as File Spec (ie *.*) */
  1259.        STRT_ALL              /* Read All Keys */
  1260.        STRT_ANY              /* Read Any ? Same as above? */
  1261.        STRT_YN               /* Yes or No (Y/N) */
  1262.        STRT_MULTFILES
  1263.        STRT_MULTSPECS
  1264.        STRT_YNQ
  1265.        STRT_YNQS
  1266.        STRT_JUSTFILE
  1267.        STRT_MULTJUST
  1268.        STRT_TELEPHONE
  1269.        STRT_YNNUM
  1270.  
  1271.        Flags:
  1272.        /* Flags for AdeptInput */
  1273.        STRF_UCASE       /* Uppercased Input */
  1274.        STRF_LCASE       /* Lowercased Input */
  1275.        STRF_REQUIRED    /* Input is Required */
  1276.        STRF_NOECHO      /* Don't echo typing to screen */
  1277.        STRF_ENCRYPT     /* Encrypt? */
  1278.        STRF_HOT         /* Hotkey Input Don't wait for CRLF */
  1279.        STRF_EDIT        /* Means INS DEL etc work? */
  1280.        STRF_PRETTY      /* I think this is First letter Uppercased */
  1281.        STRF_MUSTHOT     /* Required+Hot? */
  1282.        STRF_NEAT        /* Neat? Same as pretty? */
  1283.        STRF_NOHELP      /* Don't look up help file */
  1284.        STRF_NOQUE       /* ??? */
  1285.        STRF_NOQUEONE    /* ??? */
  1286.        STRF_CHATCLNT    /* ??? */
  1287.        STRF_NOTIMECHECK /* Don't check time remaining */
  1288.  
  1289.        Prompt:
  1290.        Prompt to display when asking for input.
  1291.  
  1292.        Help:
  1293.        Name of subject to look for in HelpFile when user asks for help.
  1294.  
  1295.        HelpFile:
  1296.        Contains help on subjects pertaining to this input prompt.
  1297.  
  1298.        Default:
  1299.        Default keystroke.
  1300.  
  1301.      RETURNED VALUE
  1302.        Returns the string read from the user.
  1303.  
  1304.      DESCRIPTION
  1305.        Get a string from the user.
  1306.  
  1307.      NOTE
  1308.        Make sure you call AdeptInitREXX before using any of the flags 
  1309.        or types.
  1310.  
  1311.      EXAMPLE
  1312.        The following would ask the User for his or her name with a MinLen 
  1313.        of 1 Character and a MaxLen of 50 Characters, with a prompt of "What
  1314.        is your Name". When this is printed, it will print to the local
  1315.        and remote screen "Your Name is Jean-Ray" (Jean-Ray being the
  1316.        name entered).
  1317.  
  1318.        answer=AdeptInput(LineNumber,1,50,,,'What Is your Name: ',,,)
  1319.        Call AdeptPrint LineNumber,'\r\n Your name is' answer
  1320.  
  1321.      RELATED FUNCTIONS
  1322.        AdeptInKey()
  1323.        AdeptTimedInKey()
  1324.  
  1325. ---------------------------------------------------------------------------
  1326. AdeptKillRexxThread()
  1327.  
  1328.      FUNCTION USAGE
  1329.        AdeptKillRexxThread(TID)
  1330.  
  1331.      ARGUMENTS
  1332.        TID:
  1333.        Thread ID
  1334.  
  1335.      RETURNED VALUE
  1336.        0       No error
  1337.        0>      Error
  1338.  
  1339.      DESCRIPTION
  1340.        Terminates the rexx thread with the ID "TID".
  1341.  
  1342.      NOTE
  1343.        Terminating a running thread can return a REXX Error 40 (Program 
  1344.        Interrupted).  You can suppress this error message by using the
  1345.        Signal on Halt keyword.
  1346.  
  1347.        If you want to share variables between a REXX thread and its parent,
  1348.        use the AdeptSetGlobalVar() and AdeptGetGlobalVar() functions.
  1349.  
  1350.      EXAMPLE
  1351.        This example will start a rexx script called ftp_progress.cmd in a
  1352.        thread, meaning it will run at the same time as the calling script.
  1353.        It will then kill the thread when the calling script no longer needs
  1354.        it.
  1355.  
  1356.        Tid = AdeptStartRexxThread("ftp_progress.cmd",line,file)
  1357.          .
  1358.          .
  1359.          .
  1360.        AdeptKillRexxThread(Tid)
  1361.  
  1362.      RELATED FUNCTIONS
  1363.        AdeptStartRexxThread()
  1364.  
  1365. ---------------------------------------------------------------------------
  1366. AdeptLibrary()
  1367.  
  1368.      FUNCTION USAGE
  1369.        Call AdeptLibraryLineNumber, Type, StartAt, KeyName
  1370.  
  1371.      ARGUMENTS
  1372.        LineNumber:
  1373.        Node number passed to REXX routine from Adept as first parameter.
  1374.        
  1375.        Type:
  1376.        1     Returns name of current library area.
  1377.        2     Returns number of current library area.
  1378.        3     Find library area by number
  1379.              Returns library area number
  1380.        4     Find library area by name
  1381.              Returns name of current library area.
  1382.        5     Go to next library area
  1383.              Returns name of current library area.
  1384.        6     Go to previous library area
  1385.              Returns name of current library area.
  1386.        7     Returns path of current library area.
  1387.  
  1388.        StartAt:
  1389.        Ony required for Type 3.
  1390.        Number of area to look for.
  1391.        
  1392.        Keyname:
  1393.        Only required for Type 4.
  1394.        Name of area to look for.
  1395.          
  1396.      RETURNED VALUE
  1397.        Type:
  1398.        1        Name of current library area.
  1399.        2        Number of current library area.
  1400.        3        Library area number.
  1401.        4        Library area name.
  1402.        5        Sets area to the Next library area and returns the area name.
  1403.        6        Sets area to the Previous library area and returns the area 
  1404.                 name.
  1405.        7        Path of current library area.
  1406.  
  1407.      DESCRIPTION
  1408.        Library area manipulation.
  1409.  
  1410.      NOTE
  1411.        The Adept Library Functions are not yet finished.
  1412.  
  1413.      EXAMPLE
  1414.  
  1415.      RELATED FUNCTIONS
  1416.        AdeptFile()
  1417.        AdeptMessage()
  1418.  
  1419. ---------------------------------------------------------------------------
  1420. AdeptLocation()
  1421.  
  1422.      FUNCTION USAGE
  1423.        Call AdeptLocation LineNumber, "User Location on the BBS"
  1424.        or
  1425.        Value = AdeptLocation(LineNumber, "User Location on the BBS")
  1426.        or
  1427.        Location = AdeptLocation(LineNumber)
  1428.  
  1429.      ARGUMENTS
  1430.  
  1431.      RETURNED VALUE
  1432.        Users' Location
  1433.  
  1434.      DESCRIPTION
  1435.        Will display where the User is on the BBS (Sysop defined).  If the
  1436.        location is omitted, the function will return the users' current
  1437.        location.
  1438.  
  1439.      NOTE
  1440.        Remember, Once the script ends, the location will go back to what 
  1441.        it was before the function was executed. This function however is
  1442.        great for Doors and Chat Mode with the Sysop if you use a Main.Cmd
  1443.        or a .Cmd file for your Door Menu. It can let other users know what 
  1444.        Door the other node(s) are in if any.
  1445.  
  1446.      EXAMPLE
  1447.        This would display the user on that particular line in a Door of
  1448.        Barren Realms Elite.
  1449.  
  1450.        Call AdeptLocation LineNumber,"In Door - Barren Realms Elite"
  1451.  
  1452.      RELATED FUNCTIONS
  1453.        AdeptSayGen()
  1454.  
  1455. ---------------------------------------------------------------------------
  1456. AdeptLog()
  1457.          
  1458.      FUNCTION USAGE
  1459.        Call AdeptLog LineNumber, Flags, String1, ..., StringN
  1460.        or
  1461.        Value = AdeptLog(LineNumber, Flags, String1, ..., StringN)
  1462.  
  1463.      ARGUMENTS
  1464.        LineNumber:
  1465.        Node number passed to REXX routine from Adept as first parameter.
  1466.  
  1467.        Flags:
  1468.        1    Output to log only
  1469.        2    Output to listbox only
  1470.        3    Output to log and listbox
  1471.  
  1472.        String1..N:                                                                            
  1473.        Strings are added together to form one string which is used to
  1474.        create the string to log.
  1475.  
  1476.      RETURNED VALUE
  1477.  
  1478.      DESCRIPTION
  1479.        Log an action to the logfile and/or listbox.
  1480.  
  1481.      NOTE
  1482.  
  1483.      EXAMPLE
  1484.        Call AdeptLog LineNumber,2, "User entered AdeptVote"
  1485.        Call AdeptLog LineNumber,3, "MainMenu Started"
  1486.  
  1487.      RELATED FUNCTIONS
  1488.  
  1489. ---------------------------------------------------------------------------
  1490. AdeptMenu()
  1491.  
  1492.      FUNCTION USAGE
  1493.        Call AdeptMenu LineNumber, Flags, MenuName
  1494.        or
  1495.        Value = AdeptMenu(LineNumber, Flags, MenuName)
  1496.  
  1497.      ARGUMENTS
  1498.        LineNumber:
  1499.        Node number passed to REXX routine from Adept as first parameter.
  1500.  
  1501.        Flags:
  1502.        1    Return after user chooses a command from the menu.
  1503.        2    Return after executing all commands contained in menu.
  1504.  
  1505.        MenuName:
  1506.        File name of the menu to use.
  1507.  
  1508.      RETURNED VALUE
  1509.  
  1510.      DESCRIPTION
  1511.        Executes a menu contained in the file MenuName.
  1512.  
  1513.      NOTE
  1514.  
  1515.      EXAMPLE
  1516.  
  1517.        Call AdeptMenu LineNumber,2, "AskPhoneNumbers.Menu"
  1518.        Call AdeptMenu LineNumber,1, "Message.Menu"
  1519.  
  1520.      RELATED FUNCTIONS
  1521.  
  1522. ---------------------------------------------------------------------------
  1523. AdeptMenuType()
  1524.  
  1525.      FUNCTION USAGE
  1526.        Call AdeptMenuType LineNumber, MenuType, MenuData
  1527.        or
  1528.        Value = AdeptMenuType(LineNumber, MenuType, MenuData)
  1529.  
  1530.      ARGUMENTS
  1531.        LineNumber:
  1532.        Node number passed to REXX routine from Adept as first parameter.
  1533.        
  1534.        MenuType:
  1535.        MenuType to execute.  See ADPXBBS.DOC for list of menutypes.
  1536.        
  1537.        MenuData:
  1538.        Optional data to be sent to MenuType.
  1539.        
  1540.      RETURNED VALUE
  1541.  
  1542.      DESCRIPTION
  1543.        This function let's you use one of Adept's menu types in a rexx
  1544.        script.  See the ADPXBBS.DOC file for more info on menu types.
  1545.        When using menutype 10, put quotes around the file name.
  1546.  
  1547.      NOTE
  1548.        Menu types below menu type 10 are not allowed for this function.  
  1549.        Only 10 and above are legal.
  1550.  
  1551.      EXAMPLE
  1552.        This command allows you to execute a menu options 10 - 998.  Just
  1553.        pass the standard menudata.
  1554.  
  1555.        Call AdeptMenuType LineNumber,42,,,0  /* This would display The 
  1556.                                               Users online at the current 
  1557.                                               time. */
  1558.        Call AdeptMenuType LineNumber,900,""  /* Your Mailbox */
  1559.        Call AdeptMenuType LineNumber,15,""   /* New mail read */
  1560.        Call AdeptMenuType LineNumber,16,,""  /* Quickscan messages */
  1561.        Call AdeptMenuType LineNumber,78,""   /* List files in area */
  1562.        Call AdeptMenuType LineNumber,76,""   /* KeyWord Search */
  1563.        Call AdeptMenuType LineNumber,74,""   /* New files */
  1564.        Call AdeptMenuType LineNumber,85,""   /* Download */
  1565.        Call AdeptMenuType LineNumber,90,""   /* Upload a file */
  1566.        Call AdeptMenuType LineNumber,146,""  /* Select Default Protocol */
  1567.  
  1568.      RELATED FUNCTIONS
  1569.                   
  1570. ---------------------------------------------------------------------------
  1571. AdeptMessage()
  1572.  
  1573.      FUNCTION USAGE
  1574.        Call AdeptMessage LineNumber, Type, StartAt, KeyName
  1575.   
  1576.      ARGUMENTS
  1577.        LineNumber:
  1578.        Node number passed to REXX routine from Adept as first parameter.
  1579.  
  1580.        Type:
  1581.        1     Returns name of current message area.
  1582.        2     Returns number of current message area.
  1583.        3     Find message area by number
  1584.              Returns message area number
  1585.        4     Find message area (name of area to find in KeyName)
  1586.              Returns name of current message area.
  1587.        5     Go to next message area
  1588.              Returns name of current message area.
  1589.        6     Go to previous message area
  1590.              Returns name of current message area.
  1591.        7     Returns number of messages in current message area.
  1592.        8     Lists available message areas to user.
  1593.        9     Sets the first message area, in the message area list, 
  1594.              that user is currently 'looking at' 
  1595.              (the user is not necessarily in the area)
  1596.              The name of the area is returned if one is available,
  1597.              otherwise '-1' is returned.
  1598.              This function type is useful when listing message areas.
  1599.              This function type should be called before using type 10.
  1600.        10    Sets the next message area, in the message area list, 
  1601.              that user is currently 'looking at'. It is the next area
  1602.              based on the current area the user is 'looking at'.
  1603.              (the user is not necessarily in the area)
  1604.              The name of the area is returned if one is available,
  1605.              otherwise '-1' is returned.
  1606.              This function type is useful when listing message areas.
  1607.              You must call AdeptMessage() with the type 9 before using
  1608.              this function, or results will be undefined!
  1609.        11    Sets the previous message area, in the message area list, 
  1610.              that user is currently 'looking at'. It is the previous 
  1611.              area based on the current area the user is 'looking at'.
  1612.              (the user is not necessarily in the area)
  1613.              The name of the area is returned if one is available,
  1614.              otherwise '-1' is returned.
  1615.              This function type is useful when listing message areas.
  1616.              You must call AdeptMessage() with the type 9 before using
  1617.              this function, or results will be undefined!
  1618.        12    Sets the next message area, in the message area list, 
  1619.              that user is currently 'looking at'. It is the next area
  1620.              based on the current area the user is in.
  1621.              The name of the area is returned if one is available,
  1622.              otherwise '-1' is returned.
  1623.        13    Sets the previous message area, in the message area list, 
  1624.              that user is currently 'looking at'. It is the previous 
  1625.              area based on the current area the user is in.
  1626.              The name of the area is returned if one is available,
  1627.              otherwise '-1' is returned.
  1628.  
  1629.        StartAt:
  1630.        Only required for Type 3.
  1631.        Number of area to look for.
  1632.  
  1633.        Keyname:
  1634.        Only required for Type 4.
  1635.        Name of area to look for.
  1636.  
  1637.      RETURNED VALUE
  1638.        Depends on the type used.
  1639.  
  1640.      DESCRIPTION
  1641.        Message area manipulation.
  1642.  
  1643.      NOTE
  1644.        Types 5 and 6 have pecularities.  Do not use the Call method on them.
  1645.  
  1646.      EXAMPLE
  1647.        Would find message area Number 1 as listed in the
  1648.        Adept\System\Message_Areas file.
  1649.  
  1650.        Call AdeptMessage LineNumber,3,'1',
  1651.                
  1652.        AdeptMessage(LineNumber,5,,"")       /* Goto next area */
  1653.        AdeptMessage(LineNumber,6,,"")       /* Goto previous area */
  1654.   
  1655.      RELATED FUNCTIONS
  1656.        AdeptFile()
  1657.        AdeptLibrary()
  1658.  
  1659. ---------------------------------------------------------------------------
  1660. AdeptMore()
  1661.  
  1662.      FUNCTION USAGE
  1663.        Call AdeptMore LineNumber
  1664.  
  1665.      ARGUMENTS
  1666.        LineNumber:
  1667.        Node number passed to REXX routine from Adept as first parameter.
  1668.  
  1669.      RETURNED VALUE
  1670.  
  1671.      DESCRIPTION         
  1672.        AdeptMore will execute a standard more prompt.  This will use the
  1673.        More prompt in the English.Text or other language file.  This will
  1674.        also use the International Y/N/Q/A info.
  1675.  
  1676.      EXAMPLE
  1677.        Call AdeptMore LineNumber
  1678.   
  1679.      RELATED FUNCTIONS   
  1680.        AdeptHitReturn()
  1681.  
  1682. ---------------------------------------------------------------------------
  1683. AdeptPause()
  1684.  
  1685.      FUNCTION USAGE
  1686.        Call AdeptPause LineNumber
  1687.        or      
  1688.        Value = AdeptPause(LineNumber)
  1689.  
  1690.      ARGUMENTS
  1691.        LineNumber:
  1692.        Node number passed to REXX routine from Adept as first parameter.
  1693.  
  1694.      RETURN VALUE
  1695.  
  1696.      DESCRIPTION
  1697.        AdeptPause will wait for any key.  This does not display any text.
  1698.  
  1699.      NOTE
  1700.  
  1701.      EXAMPLE
  1702.        Will wait for any key to be pressed on current node.
  1703.  
  1704.        Call AdeptPause LineNumber
  1705.  
  1706.      RELATED FUNCTIONS
  1707.        AdeptWaitKey()
  1708.  
  1709. ---------------------------------------------------------------------------
  1710. AdeptPlayMM()
  1711.  
  1712.      FUNCTION USAGE
  1713.        Call AdeptPlayMM LineNumber, Filename
  1714.  
  1715.      ARGUMENTS
  1716.        LineNumber: 
  1717.        Node Number passed to REXX routine from Adept as first parameter. 
  1718.        
  1719.        Filename:
  1720.        Name of WAV file to play.
  1721.  
  1722.      RETURNED VALUE
  1723.  
  1724.      DESCRIPTION
  1725.        Plays a WAV sound file.
  1726.  
  1727.      NOTE
  1728.  
  1729.      EXAMPLE
  1730.        Call AdeptPlayMM line,"/sounds/paging.wav"
  1731.  
  1732.      RELATED FUNCTIONS
  1733.  
  1734. ---------------------------------------------------------------------------
  1735. AdeptPostTextMessage()
  1736.  
  1737.      FUNCTION USAGE
  1738.        Call AdeptPostTextMessage LineNumber, AreaNum, To, From, Subject,
  1739.                                  File, IsPrivate
  1740.  
  1741.      ARGUMENTS
  1742.        LineNumber:
  1743.        Node number passed to REXX routine from Adept as first parameter.
  1744.  
  1745.        AreaNum:
  1746.        Message area number to post the message in.
  1747.  
  1748.        To:
  1749.        Name of the person to whom the message should go to.
  1750.  
  1751.        From:
  1752.        Name of the person that the message is from.
  1753.  
  1754.        Subject:
  1755.        The subject for the message.
  1756.  
  1757.        File:
  1758.        Name of the text file to use as the message.
  1759.        
  1760.        IsPrivate:
  1761.        If omitted, message is public, else private.
  1762.        
  1763.  
  1764.      RETURNED VALUE
  1765.        There's no return code
  1766.  
  1767.      DESCRIPTION
  1768.        Post a message using a text file as the message.
  1769.        IsPrivate may be ommited. If so, the msg is assumed public. All other
  1770.        parameters are manadtory.  Node maybe 0 if the rexx program isn't 
  1771.        running in a particular node (ie. a global script).
  1772.  
  1773.      NOTE
  1774.  
  1775.      EXAMPLE
  1776.  
  1777.      RELATED FUNCTIONS
  1778.        AdeptWrite()
  1779.  
  1780. ---------------------------------------------------------------------------
  1781. AdeptPrint()
  1782.  
  1783.      FUNCTION USAGE
  1784.        Call AdeptPrint LineNumber, String1, ..., StringN
  1785.  
  1786.      ARGUMENTS
  1787.        LineNumber:
  1788.        Node number passed to REXX routine from Adept as first parameter.
  1789.  
  1790.        String1..N:
  1791.        Strings are printed in the order that they were passed.
  1792.  
  1793.      RETURNED VALUE
  1794.  
  1795.      DESCRIPTION        
  1796.        Prints a string to the local and remote screen. The string may
  1797.        contain Adept META variables.  You may pass more than one or more
  1798.        strings to this function.
  1799.  
  1800.      NOTE
  1801.  
  1802.      EXAMPLE
  1803.        This Would print "Hello! Welcome to The BBS" to the User online.
  1804.  
  1805.        Call AdeptPrint LineNumber,"Hello! Welcome to The BBS"
  1806.  
  1807.      RELATED FUNCTIONS
  1808.        AdeptPrintL()
  1809.  
  1810. ---------------------------------------------------------------------------
  1811. AdeptPrintL()
  1812.  
  1813.      FUNCTION USAGE
  1814.        Call AdeptPrintL LineNumber, String1, ..., StringN
  1815.  
  1816.      ARGUMENTS
  1817.        LineNumber:
  1818.        Node number passed to REXX routine from Adept as first parameter.
  1819.  
  1820.        String1..N:
  1821.        Strings are printed in the order that they were passed.
  1822.  
  1823.      RETURNED VALUE
  1824.  
  1825.      DESCRIPTION
  1826.        AdeptPrintL works exactly like AdeptPrint except it prints to the
  1827.        LOCAL screen only.
  1828.  
  1829.      NOTE
  1830.  
  1831.      EXAMPLE
  1832.  
  1833.      RELATED FUNCTIONS
  1834.        AdeptPrint()
  1835.  
  1836. ---------------------------------------------------------------------------
  1837. AdeptPutKey()
  1838.      
  1839.      FUNCTION USAGE
  1840.        Call AdeptPutKey LineNumber, Char
  1841.        or
  1842.        Value = AdeptPutKey(LineNumber, Char)
  1843.  
  1844.      ARGUMENTS
  1845.        LineNumber:
  1846.        Node number passed to REXX routine from Adept as first parameter.
  1847.  
  1848.        Char:
  1849.        Character to put into the keyboard input stream
  1850.  
  1851.      RETURNED VALUE
  1852.  
  1853.      DESCRIPTION
  1854.        AdeptPutKey will place a character into keyboard input stream.  
  1855.        Char can be a character i.e. 'A' or a ASCII character code.
  1856.  
  1857.      NOTE
  1858.  
  1859.      EXAMPLE
  1860.        Will put the Character 'A' in the Keyboard's input stream.
  1861.  
  1862.        Call AdeptPutKey LineNumber,'A'
  1863.  
  1864.      RELATED FUNCTIONS
  1865.  
  1866. ---------------------------------------------------------------------------
  1867. AdeptRead()
  1868.  
  1869.      FUNCTION USAGE
  1870.        Call AdeptRead LineNumber, Type, Flags, StartAt
  1871.        or
  1872.        Value = AdeptRead(LineNumber, Type, Flags, StartAt)
  1873.  
  1874.      ARGUMENTS
  1875.        LineNumber:
  1876.        Node number passed to REXX routine from Adept as first parameter.
  1877.  
  1878.        Type:
  1879.        1    Read messages in current area.
  1880.        2    Globally read messages.
  1881.  
  1882.        Flags:
  1883.        (for Type 1)
  1884.        1    Show only messages to user
  1885.        2    Show only messages from user
  1886.        8    Don't clear top of screen
  1887.        16   Read Reverse (default is forward)
  1888.        (for Type 2)
  1889.        1    Stop at all areas
  1890.        8    Don't clear top of screen
  1891.  
  1892.        StartAt:
  1893.        Number of message at which Adept should start reading.
  1894.        StartAt is not used with global message reading.
  1895.  
  1896.      RETURNED VALUE
  1897.        (for Type 1)
  1898.        Direction user is reading in. 1 = User is reading forward,
  1899.        -1 = user is reading backwards.
  1900.  
  1901.        (for Type 2)
  1902.        Returns 0
  1903.  
  1904.      DESCRIPTION
  1905.        Read messages.
  1906.        You should do a carrier check after this function to make sure
  1907.        the user is online.
  1908.  
  1909.      EXAMPLE
  1910.  
  1911.        Call AdeptRead LineNumber,2,,4   /* This would start the user
  1912.                                           currently online reading the
  1913.                                           messages globally starting from
  1914.                                           Message Area #4 (as defined in
  1915.                                           Adept\System\Message_Areas
  1916.                                           file). */
  1917.        Call AdeptRead line,1,,1         /* This will start reading messages
  1918.                                           in the current area */
  1919.  
  1920.      RELATED FUNCTIONS
  1921.        AdeptWrite()
  1922.       
  1923. ---------------------------------------------------------------------------
  1924. AdeptRecv()
  1925.  
  1926.      FUNCTION USAGE
  1927.        Call AdeptRecv LineNumber, Flags, Path, Area, File1, ..., FileN
  1928.        or
  1929.        Value = AdeptRecv(LineNumber, Flags, Path, Area, File1, ..., FileN)
  1930.          
  1931.      ARGUMENTS
  1932.        LineNumber:
  1933.        Node number passed to REXX routine from Adept as first parameter.
  1934.  
  1935.        Flags:
  1936.        1    No time verification
  1937.        4    Silence
  1938.        8    Never be silent
  1939.        16   Don't ask for DESCRIPTION
  1940.        64   Don't credit upload (does not return files size)
  1941.        128  Accept as private file.
  1942.  
  1943.        Path:
  1944.        Path to put files in.
  1945.  
  1946.        Area:
  1947.        Name of area to put files in.
  1948.  
  1949.        File1..N:
  1950.        Names of files to be received.
  1951.  
  1952.      RETURNED VALUE
  1953.        String containing number of bytes downloaded, a space and the
  1954.        number of files downloaded.
  1955.  
  1956.      DESCRIPTION
  1957.        Upload files
  1958.         
  1959.      NOTE
  1960.        This function will change in the future.
  1961.  
  1962.      EXAMPLE
  1963.        This will send the File Adept97b.Zip from the AdeptSoft area and
  1964.        the directory of D:\ADEPT
  1965.  
  1966.        Call AdeptRecv line,128,'D:\ADEPT','AdeptSoft','Adept97b.Zip'
  1967.  
  1968.      RELATED FUNCTIONS
  1969.        AdeptSend()
  1970.  
  1971. ---------------------------------------------------------------------------
  1972. AdeptRequestsLogoff()
  1973.      
  1974.      FUNCTION USAGE
  1975.        Value = AdeptRequestsLogoff(LineNumber)
  1976.        
  1977.      ARGUMENTS
  1978.        LineNumber:
  1979.        Node number passed to REXX routine from Adept as first parameter.
  1980.        
  1981.      RETURNED VALUE
  1982.        1       if Adept wants user logged off
  1983.        0       if User can stay
  1984.        
  1985.      DESCRIPTION
  1986.        Will check if Adept wants the user to be logged off.  ie - if user
  1987.        is out of time or has timed out
  1988.        
  1989.      NOTE
  1990.  
  1991.      EXAMPLE
  1992.        if(AdeptRequestsLogoff(line)==1)then
  1993.          exit
  1994.          
  1995.      RELATED FUNCTIONS
  1996.      
  1997. ---------------------------------------------------------------------------
  1998. AdeptSayGen()
  1999.  
  2000.      FUNCTION USAGE
  2001.        Call AdeptSayGen LineNumber, String
  2002.        or
  2003.        Value = AdeptSayGen(LineNumber, String)
  2004.  
  2005.      ARGUMENTS
  2006.        LineNumber:
  2007.        Node number passed to REXX routine from Adept as first parameter.
  2008.  
  2009.        String:
  2010.        Status String.
  2011.  
  2012.      RETURNED VALUE
  2013.        0       No error
  2014.        0>      Error
  2015.  
  2016.      DESCRIPTION
  2017.        Sets the "user location" for the given node in the Adept line status 
  2018.        window.
  2019.  
  2020.      NOTE
  2021.  
  2022.      EXAMPLE
  2023.        The following example sets the message in the Line Status Window to
  2024.        reflect that the user is playing LORD.
  2025.  
  2026.        Call AdeptSayGen line, "Legend Of The Red Dragon"
  2027.  
  2028.      RELATED FUNCTIONS
  2029.        AdeptLocation()
  2030.  
  2031. ---------------------------------------------------------------------------
  2032. AdeptSend()
  2033.  
  2034.      FUNCTION USAGE
  2035.        Call AdeptSend LineNumber, Flags, Path, File1, ..., FileN
  2036.        Call AdeptSend LineNumber,,,''@file''
  2037.        or
  2038.        Value = AdeptSend(LineNumber, Flags, Path, File1, ..., FileN)
  2039.        Value = AdeptSend(LineNumber,,,''@file'')
  2040.  
  2041.      ARGUMENTS
  2042.        LineNumber:
  2043.        Node number passed to REXX routine from Adept as first parameter.
  2044.  
  2045.        Flags:
  2046.        1    No time verification
  2047.        2    No leech checking
  2048.        4    Silence
  2049.        8    Never be silent
  2050.        16   Don't check all download paths
  2051.        64   Don't return files length (free file/bytes)
  2052.  
  2053.        Path:
  2054.        Path to files.  If blank, use current file area path.
  2055.  
  2056.        File1..N:
  2057.        Names of files to be sent.
  2058.        NOTE: Currently the files are sent one at a time.
  2059.  
  2060.        @File:
  2061.        Text file with the filenames and paths (one per line) of
  2062.        the files to send.
  2063.  
  2064.      RETURNED VALUE
  2065.        String containing number of bytes downloaded, a space and the
  2066.        number of files downloaded.
  2067.  
  2068.      DESCRIPTION
  2069.        Download Files.
  2070.         
  2071.      NOTE
  2072.  
  2073.      EXAMPLE
  2074.        Will send the File that is in the file called list.
  2075.        Call AdeptSend LineNumber,,,'@c:\list')
  2076.  
  2077.      RELATED FUNCTIONS
  2078.        AdeptRecv()
  2079.        AdeptAddToXFerList()
  2080.  
  2081. ---------------------------------------------------------------------------
  2082. AdeptSetBit()
  2083.  
  2084.      FUNCTION USAGE
  2085.        Call AdeptSetBit LineNumber, Bit Number, Numeric Long
  2086.        or
  2087.        Value = AdeptSetBit(LineNumber, Bit Number, Numeric Long)
  2088.  
  2089.      ARGUMENTS
  2090.        LineNumber:
  2091.        Node number passed to REXX routine from Adept as first parameter.
  2092.      
  2093.        BitNumber:
  2094.        Which bit number to set.
  2095.        
  2096.        Numeric Long:
  2097.        A numeric long to be manipulated.  ie - User Flags.
  2098.  
  2099.      RETURNED VALUE
  2100.  
  2101.      DESCRIPTION
  2102.        Will set Bit Number to ON.
  2103.  
  2104.      NOTE
  2105.        The changes are not saved until you put the changes back into
  2106.        active memory with the AdeptPutVar option.
  2107.  
  2108.      EXAMPLE
  2109.        SetBit = AdeptGetVar(LineNumber, 42)
  2110.        Call AdeptSetBit LineNumber, 30, SetBit
  2111.  
  2112.      RELATED FUNCTIONS
  2113.        AdeptCheckBit()
  2114.        AdeptUnSetBit()
  2115.  
  2116. ---------------------------------------------------------------------------
  2117. AdeptSetGlobalVar()
  2118.  
  2119.      FUNCTION USAGE
  2120.        RetCode = AdeptSetGlobalVar('VarName', Value)
  2121.  
  2122.      ARGUMENTS
  2123.       VarName:
  2124.       Name of variable enclosed in quotes.
  2125.       
  2126.       Value:
  2127.       Value to assign to VarName.
  2128.  
  2129.      RETURNED VALUE
  2130.  
  2131.      DESCRIPTION
  2132.        AdeptSetGlobalVar will set a global variable named VarName in
  2133.        memory with a value of VarValue.
  2134.   
  2135.      NOTE
  2136.  
  2137.      EXAMPLE
  2138.        Value = 6
  2139.        RetCode = AdeptSetGlobalVar('VarName', Value)
  2140.  
  2141.      RELATED FUNCTIONS
  2142.        AdeptGetGlobalVar()
  2143.        AdeptDropGlobalVar()
  2144.   
  2145. ---------------------------------------------------------------------------
  2146. AdeptSetTimer()
  2147.  
  2148.      FUNCTION USAGE
  2149.        Call AdeptSetTimer LineNumber, Timer
  2150.        or
  2151.        Value = AdeptSetTimer(LineNumber, Timer)
  2152.  
  2153.      ARGUMENTS
  2154.        LineNumber:
  2155.        Node number passed to REXX routine from Adept as First Parameter.
  2156.   
  2157.        Timer: 
  2158.        Time In Milliseconds
  2159.  
  2160.      RETURNED VALUE
  2161.  
  2162.      DESCRIPTION
  2163.        Starts a timer.
  2164.  
  2165.      NOTE
  2166.  
  2167.      EXAMPLE
  2168.        Call AdeptSetTimer LineNumber,10000  /* 10 seconds */
  2169.  
  2170.      RELATED FUNCTIONS
  2171.        AdeptTimerUp()
  2172.  
  2173. ---------------------------------------------------------------------------
  2174. AdeptShow()
  2175.  
  2176.      FUNCTION USAGE
  2177.        Call AdeptShow LineNumber, Type, Flags, StartAt, KeyName
  2178.  
  2179.      ARGUMENTS
  2180.        LineNumber:
  2181.        Node number passed to REXX routine from Adept as first parameter.
  2182.  
  2183.        Type:
  2184.        1     Show a text file (StartAt=filename, KeyName=keys to abort
  2185.              on)
  2186.        2     Page-read text file (Keyname=filename)
  2187.        3     Show new text files (Keyname=directory to look in)
  2188.        4     Show any text file (Keyname=directory to look in)
  2189.  
  2190.        Flags:
  2191.        <undefined> (for now)
  2192.  
  2193.        StartAt:
  2194.        (see type 1)
  2195.  
  2196.        KeyName:
  2197.        Keys on which to abort showing of the text file. (see type 1)
  2198.        -or-
  2199.        Name of file or directory to look for. (see types 2-4)
  2200.  
  2201.      RETURNED VALUE
  2202.  
  2203.      DESCRIPTION
  2204.        Display text files.
  2205.  
  2206.      NOTE
  2207.  
  2208.      EXAMPLE
  2209.        The following will display the Bullet.Ans file in the Adept\Text 
  2210.        directory and if the User presses the letter 'Q' it will abort 
  2211.        viewing of the file.
  2212.        Call AdeptShow LineNumber,1,,'C:\Adept\Text\Bullet.Ans,Q
  2213.  
  2214.      RELATED FUNCTIONS
  2215.  
  2216. ---------------------------------------------------------------------------
  2217. AdeptSleep()
  2218.  
  2219.      FUNCTION USAGE         
  2220.        Call AdeptSleep LineNumber, time_to_sleep_in_milliseconds
  2221.        or
  2222.        Value = AdeptSleep(LineNumber, time_to_sleep_in_milliseconds)
  2223.  
  2224.      ARGUMENTS
  2225.        LineNumber:
  2226.        Node number passed to REXX routine from Adept as first parameter.
  2227.  
  2228.        time_to_sleep_in_milliseconds:
  2229.        1000 milliseconds = 1 second.
  2230.        The smallest timeslice OS/2 can sleep is 32ms.
  2231.  
  2232.      RETURNED VALUE
  2233.  
  2234.      DESCRIPTION
  2235.        AdeptSleep will cause the current node to sleep for x amount of
  2236.        milliseconds.  This is very helpful in making your REXX scripts 
  2237.        CPU friendly. When you use this command it will release the 
  2238.        current time slice to the next node or program waiting in line.  
  2239.        A decent sleep amount is AdeptSleep(65), 65 milliseconds, 1000 
  2240.            
  2241.      NOTE
  2242.  
  2243.      EXAMPLE
  2244.        Call AdeptSleep LineNumber,1000    /* 1 Second   */
  2245.        Call AdeptSleep LineNumber,10000   /* 10 Seconds */
  2246.        Call AdeptSleep LineNumber,60000   /* 1 Minute   */
  2247.        Call AdeptSleep LineNumber,600000  /* 10 Minutes */
  2248.  
  2249.      RELATED FUNCTIONS
  2250.  
  2251. ---------------------------------------------------------------------------
  2252. AdeptStartRexxThread()
  2253.  
  2254.      FUNCTION USAGE
  2255.        RetCode = AdeptStartRexxThread(FileName, [var1 var2 var3 var4])
  2256.  
  2257.      ARGUMENTS
  2258.        FileName:
  2259.        Name of AdeptREXX program to execute as a background thread.
  2260.  
  2261.        Var1 ...:
  2262.        Variable to pass to the rexx program, you can pass as many variables 
  2263.        you want.  They are not shared once they are passed. 
  2264.  
  2265.      RETURNED VALUE
  2266.        Thread ID >0 if thread started
  2267.  
  2268.      DESCRIPTION
  2269.        This will cause the program Thread.Cmd to be run in the
  2270.        background with the rexx programming calling it as the parent.
  2271.        When the parent ends, all children and grandchildren are 
  2272.        killed with it.
  2273.  
  2274.      NOTE
  2275.  
  2276.      EXAMPLE
  2277.        rc = AdeptStartRexxThread('Thread.Cmd', line)
  2278.  
  2279.      RELATED FUNCTIONS
  2280.        AdeptKillRexxThread()
  2281.        AdeptStartRexxThreadNC()
  2282.         
  2283. ---------------------------------------------------------------------------
  2284. AdeptStartRexxThreadNC()
  2285.  
  2286.      FUNCTION USAGE
  2287.        RetCode = AdeptStartRexxThread(FileName, [var1 var2 var3 var4])
  2288.  
  2289.      ARGUMENTS
  2290.        FileName:
  2291.        Name of AdeptREXX program to execute as a background thread.
  2292.  
  2293.        Var1 ...:
  2294.        Variable to pass to the rexx program, you can pass as many variables 
  2295.        you want.  They are not shared once they are passed. 
  2296.  
  2297.      RETURNED VALUE
  2298.        Thread ID >0 if thread started
  2299.  
  2300.      DESCRIPTION
  2301.        This will cause the program Thread.Cmd to be run in the
  2302.        background with the rexx programming calling it as the parent.
  2303.        When the parent ends, all children and grandchildren are 
  2304.        killed with it.  Starts Thread in non-cached mode.
  2305.  
  2306.      NOTE
  2307.  
  2308.      EXAMPLE
  2309.        rc = AdeptStartRexxThread('Thread.Cmd', line)
  2310.  
  2311.      RELATED FUNCTIONS
  2312.        AdeptKillRexxThread()
  2313.        AdeptStartRexxThread()
  2314.         
  2315. ---------------------------------------------------------------------------
  2316. AdeptTimedInKey()
  2317.  
  2318.      FUNCTION USAGE
  2319.        Call AdeptTimedInKey LineNumber, Timeout
  2320.        or
  2321.        Value = AdeptTimedInKey(LineNumber, Timeout)
  2322.  
  2323.      ARGUMENTS
  2324.        LineNumber:
  2325.        Node number passed to REXX routine from Adept as first parameter.
  2326.  
  2327.        Timeout:
  2328.        Timeout period.  In Milliseconds.
  2329.  
  2330.      RETURNED VALUE
  2331.        Value for key inputed.
  2332.        If no key is pressed with in the timeout value a -1 or 0 for timeout.
  2333.        If the Carrier is lost a value of -2 is returned.
  2334.        If the SysOp presses F3 on the local BBS Window -3 is returned.
  2335.        If the SysOp presses F4 on the local BBS Window -4 is returned.
  2336.    
  2337.      DESCRIPTION
  2338.        Returns the value for the key inputed, watched the port for a
  2339.        period of time in milliseconds.
  2340.  
  2341.      NOTE
  2342.  
  2343.      EXAMPLE
  2344.        KeyIn=AdeptTimedInKey(LineNumber,5000)    /* 5 seconds */
  2345.  
  2346.      RELATED FUNCTIONS
  2347.        AdeptInput()
  2348.        AdeptInKey()
  2349.        AdeptWaitKey()
  2350.  
  2351. ---------------------------------------------------------------------------
  2352. AdeptTimeLeft()
  2353.  
  2354.      FUNCTION USAGE
  2355.        Call AdeptTimeLeft LineNumber [, SecsLeftInSession]
  2356.        or
  2357.        Value = AdeptTimeLeft(LineNumber [, SecsLeftInSession])
  2358.  
  2359.      ARGUMENTS
  2360.        LineNumber:
  2361.        Node number passed to REXX routine from Adept as first parameter.
  2362.  
  2363.        SecsLeftInSession:
  2364.        Optional.  Set seconds left in current session.
  2365.      
  2366.      RETURNED VALUE
  2367.        Time left in session in seconds.
  2368.  
  2369.      DESCRIPTION
  2370.        Optionally sets time left in current session. Always returns time
  2371.        left in current session.
  2372.          
  2373.      NOTE
  2374.  
  2375.      EXAMPLE
  2376.        This will give the user online 1 minute left in his/her session.
  2377.        Call AdeptTimeLeft LineNumber, 60000
  2378.          
  2379.      RELATED FUNCTIONS
  2380.        
  2381. ---------------------------------------------------------------------------
  2382. AdeptTimerUp()
  2383.  
  2384.      FUNCTION USAGE
  2385.        Call AdeptTimerUp LineNumber, Timer
  2386.        or
  2387.        Value = AdeptTimerUp(LineNumber, Timer)
  2388.  
  2389.      ARGUMENTS
  2390.        LineNumber:
  2391.        Node number passed to REXX routine from Adept as first parameter.
  2392.  
  2393.        Timer:
  2394.        The return value of the AdeptSetTimer function.
  2395.  
  2396.      RETURNED VALUE
  2397.        0       Time is up
  2398.        1       Time is not up
  2399.  
  2400.      DESCRIPTION
  2401.        Checks to see if the timer is up.
  2402.  
  2403.      NOTE
  2404.  
  2405.      EXAMPLE
  2406.        The following example sets the timer to 10 seconds and then checks to
  2407.        see if the time is up.
  2408.  
  2409.        ** EXAMPLE with the TWO PREVIOUS rexx Functions **
  2410.        Timer=AdeptSetTimer(LineNumber,10000)  /* 10 Seconds */
  2411.        MyRet=AdeptTimerUp(LineNumber,timer)
  2412.  
  2413.      RELATED FUNCTIONS
  2414.        AdeptSetTimer()
  2415.  
  2416. ---------------------------------------------------------------------------
  2417. AdeptUnsetBit()
  2418.  
  2419.      FUNCTION USAGE
  2420.        Call AdeptUnsetBit LineNumber, Bit Number, Numeric Long
  2421.        or
  2422.        Value = AdeptUnsetBit(LineNumber, Bit Number, Numeric Long)
  2423.  
  2424.      ARGUMENTS
  2425.        LineNumber:
  2426.        Node number passed to REXX routine from Adept as first parameter.
  2427.  
  2428.        Bit Number:
  2429.        Which bit number to set.
  2430.        
  2431.        Numeric Long:
  2432.        A numeric long to be manipulated.  ie - User Flags.
  2433.  
  2434.      RETURNED VALUE
  2435.  
  2436.      DESCRIPTION
  2437.        Will set Bit Number to OFF.
  2438.  
  2439.      NOTE
  2440.        The changes are not saved until you put the changes back into active 
  2441.        memory with the AdeptPutVar option.
  2442.  
  2443.      EXAMPLE
  2444.        The following example will turn bit number 30 OFF.
  2445.        Call AdeptUnsetBit LineNumber, 30, SetBit
  2446.  
  2447.      RELATED FUNCTIONS
  2448.        AdeptSetBit()
  2449.        AdeptCheckBit()
  2450.  
  2451. ---------------------------------------------------------------------------
  2452. AdeptWaitKey()
  2453.  
  2454.      FUNCTION USAGE
  2455.        Call AdeptWaitKey LineNumber
  2456.        or
  2457.        Value = AdeptWaitKey(LineNumber)
  2458.  
  2459.      ARGUMENTS
  2460.        LineNumber:
  2461.        Node number passed to REXX routine from Adept as first parameter.
  2462.  
  2463.      RETURNED VALUE
  2464.        ASCII code for the key pressed.
  2465.  
  2466.      DESCRIPTION
  2467.        AdeptWaitKey will return the ASCII code for a incoming key 
  2468.        sequence. Unlike AdeptInKey, AdeptWaitKey will actually wait for 
  2469.        a key sequence. If the user times out, it will log the user off.
  2470.  
  2471.      NOTE
  2472.  
  2473.      EXAMPLE
  2474.        ReturnCode = AdeptInKey(LineNumber)
  2475.   
  2476.      RELATED FUNCTIONS
  2477.        AdeptInKey()
  2478.        AdeptTimedInKey()
  2479.  
  2480. ---------------------------------------------------------------------------
  2481. AdeptWrite()
  2482.  
  2483.      FUNCTION USAGE
  2484.        Call AdeptWrite LineNumber, Type, Flags, Filename
  2485.        or
  2486.        Value = AdeptWrite(LineNumber, Type, Flags, Filename)
  2487.  
  2488.      ARGUMENTS
  2489.        LineNumber:
  2490.        Node number passed to REXX routine from Adept as first parameter.
  2491.  
  2492.        Type:
  2493.        1    Write a message  (Filename is unused)
  2494.        2    edit a file using editor (Flags are unused)
  2495.  
  2496.        Flags:
  2497.        1    Force message to force-to-name of current message area.
  2498.        2    Force private
  2499.        4    Force public
  2500.        8    Use MSGTMP.LineNumber file
  2501.  
  2502.        Filename:
  2503.        Name of text file to edit.
  2504.  
  2505.      RETURNED VALUE
  2506.  
  2507.      DESCRIPTION
  2508.        Write a message.
  2509.  
  2510.      NOTE
  2511.  
  2512.      EXAMPLE
  2513.        This would prompt a user to write a public message in the current 
  2514.        area.
  2515.  
  2516.        Call AdeptWrite LineNumber, 1, 4,""
  2517.  
  2518.      RELATED FUNCTIONS
  2519.        AdeptPostTextMessage()
  2520.        AdeptRead()
  2521.  
  2522. ---------------------------------------------------------------------------
  2523. Print()
  2524.  
  2525.      FUNCTION USAGE
  2526.        RetCode = Print(LineNumber, Arg1,  ....)
  2527.  
  2528.      ARGUMENTS
  2529.        LineNumber:
  2530.        Node number passed to REXX routine from Adept as first parameter.
  2531.  
  2532.        Arg1 ...:
  2533.        1st argument to be displayed 
  2534.  
  2535.      RETURNED VALUE
  2536.        0       No errors.
  2537.        -1      REXX killed by BBS or Carrier lost
  2538.  
  2539.      DESCRIPTION
  2540.        Displays the argument(s) on the given line.
  2541.  
  2542.      NOTE
  2543.        Does not convert Meta's
  2544.  
  2545.      EXAMPLE
  2546.  
  2547.      RELATED FUNCTIONS
  2548.        AdeptPrint()
  2549.        AdeptPrintL()
  2550.  
  2551. ---------------------------------------------------------------------------
  2552. Printf()
  2553.  
  2554.      FUNCTION USAGE
  2555.        Printf(Arg)
  2556.  
  2557.      ARGUMENTS
  2558.        Arg:
  2559.        Argument to be displayed
  2560.  
  2561.      RETURNED VALUE
  2562.        0       No errors.
  2563.        -1      REXX killed by BBS or Carrier lost
  2564.  
  2565.      DESCRIPTION
  2566.        Sends the argument to pmprintf. Useful ONLY to developers.
  2567.        and even then only of limited value.
  2568.  
  2569.      NOTE
  2570.        It is better to use a combination of AdeptLog() and AdeptPrintL()
  2571.        functions for debugging rather than using this.
  2572.  
  2573.      EXAMPLE
  2574.  
  2575.      RELATED FUNCTIONS
  2576.  
  2577. ---------------------------------------------------------------------------
  2578.      ________________________________________________
  2579.      _ _ CTRL AND OTHER KEYS AND THEIR RETURN CODES _
  2580.      ________________________________________________
  2581.        CTRL_A = 1        CTRL_B = 2        CTRL_C = 3        CTRL_D = 4
  2582.        CTRL_E = 5        CTRL_F = 6        CTRL_G = 7        CTRL_H = 8
  2583.        CTRL_I = 9        CTRL_J = 10       CTRL_K = 11       CTRL_L = 12
  2584.        CTRL_N = 14       CTRL_O = 15       CTRL_P = 16       CTRL_Q = 17
  2585.        CTRL_R = 18       CTRL_S = 19       CTRL_T = 20       CTRL_U = 21
  2586.        CTRL_V = 22       CTRL_W = 23       CTRL_X = 24       CTRL_Y = 25
  2587.        CTRL_Z = 26
  2588.        HOME = 71+1024  UP   = 72+1024  PGUP   = 73+1024  BS     = 24
  2589.        FWD  = 77+1024  END  = 79+1024  DN     = 80+1024  PGDN   = 1+1024
  2590.        INS  = 82+1024  DEL  = 83+1024  LEFT   = 75+1024  RIGHT  = 77+1024
  2591.  
  2592.