home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1998 #6 / amigamamagazinepolishissue1998.iso / coders / arexx / moos / docs / english / rexx_exec.doc < prev    next >
Text File  |  1997-03-23  |  6KB  |  255 lines
  1.  
  2.  
  3. TABLE OF CONTENTS
  4.  
  5. --background--
  6. rexx_exec.library/AvailMem
  7. rexx_exec.library/FlushMem
  8. rexx_exec.library/GetSysBase
  9. rexx_exec.library/ReBoot
  10.  
  11.  
  12. --background--                                                  --background--
  13.  
  14.  $(C): (1996, Rocco Coluccelli, Bologna)
  15.  $VER: rexx_exec.library 37.2 (15.03.97)
  16.  
  17.     rexx_exec.library
  18.  
  19.     This sub-library of the rexxMOOS.library let ARexx programmers
  20.     use some function from the system exec.library
  21.  
  22.         AvailMem()
  23.         FlushMem()
  24.         GetSysBase()
  25.         ReBoot()
  26.  
  27.     NOTES
  28.  
  29.         Is part of the MOOS package.
  30.  
  31.     TODO
  32.  
  33.         A lot... :-)
  34.  
  35.     BUGS
  36.  
  37. rexx_exec.library/AvailMem                          rexx_exec.library/AvailMem
  38.  
  39.     NAME
  40.  
  41.         AvailMem -- Returns information about the available memory.
  42.  
  43.     SYNOPSIS
  44.  
  45.         size = AvailMem(options)
  46.  
  47.     FUNCTION
  48.  
  49.         Use this function to know how much memory is currently
  50.         available in the system or to returns the largest free block
  51.         of memory, according with any class of memory (see below).
  52.  
  53.     INPUTS
  54.  
  55.             options - "Flags/N,Outstem,Largest=L/S"
  56.  
  57.                 "Flags"   - A bit mask to select which value we need
  58.                             to be returned:
  59.  
  60.                                 Mem_Any      = 0
  61.                                 Mem_Public   = 1
  62.                                 Mem_Chip     = 2
  63.                                 Mem_Fast     = 4
  64.                                 Mem_Local    = 128
  65.                                 Mem_24bitdma = 256
  66.                                 Mem_Kick     = 512
  67.  
  68.                 "Outstem" - The function may fill a given stem with values
  69.                             of the available memory:
  70.  
  71.                                 <stem.>Mem_Any
  72.                                     Any type of memory
  73.  
  74.                                 <stem.>Mem_Public
  75.  
  76.                                 <stem.>Mem_Chip
  77.  
  78.                                 <stem.>Mem_Fast
  79.  
  80.                                 <stem.>Mem_Local
  81.                                     Memory that does not go away at RESET
  82.  
  83.                                 <stem.>Mem_24bitdma
  84.                                     Memory within 24 bits of address and
  85.                                     usable in DMA mode.
  86.  
  87.                                 <stem.>Mem_Kick
  88.                                     Memory that can be used for KickTags
  89.  
  90.                 "Largest" - Instead of return the total size of memory
  91.                             available, the function can return the largest
  92.                             contiguous block of free mem.
  93.  
  94.     RESULT
  95.  
  96.         The total size of available memory in the classes specified with
  97.         flags, or the largest block size specifying the "Largest" option.
  98.  
  99.     EXAMPLE
  100.  
  101.         SAY AvailMem()
  102.  
  103.     NOTES
  104.  
  105.         Due to the effect of multitasking, the value returned may not
  106.         actually be the amount of free memory available at that instant.
  107.  
  108.     SEE ALSO
  109.  
  110.         exec.library/AvailMem(), exec.library/AllocMem()
  111.  
  112. rexx_exec.library/FlushMem                          rexx_exec.library/FlushMem
  113.  
  114.     NAME
  115.  
  116.         FlushMem -- Flush all class of memory.
  117.  
  118.     SYNOPSIS
  119.  
  120.         FlushMem()
  121.  
  122.     FUNCTION
  123.  
  124.         Force the system for freeing all un-needed memory.
  125.  
  126.     INPUTS
  127.  
  128.     RESULT
  129.  
  130.     EXAMPLE
  131.  
  132.         CALL FlushMem()
  133.  
  134.     NOTES
  135.  
  136.     SEE ALSO
  137.  
  138.         exec.library/AllocMem()
  139.  
  140. rexx_exec.library/GetSysBase                      rexx_exec.library/GetSysBase
  141.  
  142.     NAME
  143.  
  144.         GetSysBase -- Returns information readed from ExecBase.
  145.  
  146.     SYNOPSIS
  147.  
  148.         GetSysBase(options)
  149.  
  150.     FUNCTION
  151.  
  152.         Use this function to read some information stored into the
  153.         ExecBase structure.
  154.  
  155.     INPUTS
  156.  
  157.             options - "Outstem/A"
  158.  
  159.                 "Outstem" - The function may fill a given stem with data
  160.                             readed from the ExecBase structure:
  161.  
  162.                                 <stem.>ColdCapture
  163.                                     Coldstart soft capture vector
  164.  
  165.                                 <stem.>CoolCapture
  166.                                     Coolstart soft capture vector
  167.  
  168.                                 <stem.>WarmCapture
  169.                                     Warmstart soft capture vector
  170.  
  171.                                 <stem.>KickMemPtr
  172.                                     Pointer to queue of mem lists
  173.  
  174.                                 <stem.>KickTagPtr
  175.                                     Pointer to ROM tag queue
  176.  
  177.                                 <stem.>KickCheckSum
  178.                                     Checksum for mem and tags
  179.  
  180.                                 <stem.>ThisTask
  181.                                     Pointer to current task structure
  182.  
  183.                                 <stem.>SysCPU
  184.                                     System's CPU: 68000, 68010, 68020,
  185.                                     68030, 68040.
  186.  
  187.                                 <stem.>SysFPU
  188.                                     System's FPU: 68881, 68882, FPU40,
  189.                                     NOFPU (if there isn't any FPU).
  190.  
  191.                             In this release an output stem must be
  192.                             specified when calling the function.
  193.  
  194.     RESULT
  195.  
  196.         In this release the function returns nothing.
  197.  
  198.     EXAMPLE
  199.  
  200.         CALL GetSysBase("sys.")
  201.         SAY "sys.ColdCapture  ==" sys.ColdCapture
  202.         SAY "sys.CoolCapture  ==" sys.CoolCapture
  203.         SAY "sys.WarmCapture  ==" sys.WarmCapture
  204.         SAY "sys.KickMemPtr   ==" sys.KickMemPtr
  205.         SAY "sys.KickTagPtr   ==" sys.KickTagPtr
  206.         SAY "sys.KickCheckSum ==" sys.KickCheckSum
  207.         SAY "sys.ThisTask     ==" sys.ThisTask
  208.         SAY "sys.SysCPU       ==" sys.SysCPU
  209.         SAY "sys.SysFPU       ==" sys.SysFPU
  210.  
  211.     NOTES
  212.  
  213.         The "SysCPU" and "SysFPU" fields are not valid using a 68060.
  214.  
  215.     SEE ALSO
  216.  
  217.         struct ExecBase
  218.  
  219. rexx_exec.library/ReBoot                              rexx_exec.library/ReBoot
  220.  
  221.     NAME
  222.  
  223.         ReBoot -- Reboot the Amiga.
  224.  
  225.     SYNOPSIS
  226.  
  227.         ReBoot()
  228.  
  229.     FUNCTION
  230.  
  231.         Reboot the machine.  All external memory and periperals will be
  232.         RESET, and the machine will start its power up diagnostics.
  233.         This function never returns.
  234.  
  235.     INPUTS
  236.  
  237.         All that we wants.
  238.  
  239.     RESULT
  240.  
  241.         An altogether totally integrated living system.
  242.  
  243.     EXAMPLE
  244.  
  245.         SAY "Bye, bye..."
  246.         CALL ReBoot()
  247.  
  248.     NOTES
  249.  
  250.     SEE ALSO
  251.  
  252.         exec.library/ColdReboot()
  253.  
  254.  
  255.