home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / fenv.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  10.1 KB  |  275 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        fenv.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Pascal, July 8, 1994 
  8.     
  9.     Note:        The following file was hand converted from fenv.h
  10.                 See fenv.h for more information and comments.
  11. }
  12.  
  13. {$IFC UNDEFINED UsingIncludes}
  14. {$SETC UsingIncludes := 0}
  15. {$ENDC}
  16.  
  17. {$IFC NOT UsingIncludes}
  18.  UNIT fenv;
  19.  INTERFACE
  20. {$ENDC}
  21.  
  22. {$IFC UNDEFINED __FENV__}
  23. {$SETC __FENV__ := 1}
  24.  
  25. {$I+}
  26. {$SETC fpenvIncludes := UsingIncludes}
  27. {$SETC UsingIncludes := 1}
  28.  
  29. {$IFC UNDEFINED __TYPES__}
  30. {$I Types.p}
  31. {$ENDC}
  32.  
  33.  
  34. {$IFC GENERATINGPOWERPC }
  35. TYPE
  36. {   fenv_t is a type for representing the entire floating-point
  37.       environment in a single object.                                         }
  38.  
  39.     fenv_t = LONGINT;
  40.  
  41. {   fexcept_t is a type for representing the floating-point
  42.       exception flag state collectively.                                      }
  43.  
  44.     fexcept_t = LONGINT;
  45.  
  46. CONST
  47. {    Definitions of floating-point exception macros                          }
  48.  
  49.     FE_INEXACT         = $02000000;       {     inexact              }
  50.     FE_DIVBYZERO       = $04000000;       {     divide-by-zero       }
  51.     FE_UNDERFLOW       = $08000000;       {     underflow            }
  52.     FE_OVERFLOW        = $10000000;       {     overflow             }
  53.     FE_INVALID         = $20000000;       {     invlalid             }
  54.  
  55. {   Definitions of rounding direction macros                                }
  56.  
  57.     FE_TONEAREST       = $00000000;
  58.     FE_TOWARDZERO      = $00000001;
  59.     FE_UPWARD          = $00000002;
  60.     FE_DOWNWARD        = $00000003;
  61.     
  62. {$ELSEC}
  63.  
  64. CONST
  65.     FE_TONEAREST       = $0000;
  66.     FE_UPWARD          = $0001;
  67.     FE_DOWNWARD        = $0002;
  68.     FE_TOWARDZERO      = $0003;
  69.     
  70. {   Definitions of rounding precision macros  (68K only)                    }
  71.  
  72.     FE_LDBLPREC        = $0000;
  73.     FE_DBLPREC         = $0001;
  74.     FE_FLTPREC         = $0002;
  75.  
  76.     {$IFC OPTION(mc68881) }
  77.     TYPE
  78.         fenv_t =     RECORD
  79.                         FPCR: LONGINT;
  80.                         FPSR: LONGINT;
  81.                     END;
  82.         fexcept_t = LONGINT;
  83.         
  84.     CONST
  85.         FE_INEXACT         = $00000008;  
  86.         FE_DIVBYZERO       = $00000010;     
  87.         FE_UNDERFLOW       = $00000020;    
  88.         FE_OVERFLOW        = $00000040;      
  89.         FE_INVALID         = $00000080;   
  90.     
  91.     {$ELSEC}
  92.     TYPE
  93.         fenv_t    = INTEGER;
  94.         fexcept_t = INTEGER;
  95.     CONST
  96.         FE_INVALID         = $0001;   
  97.         FE_UNDERFLOW       = $0002;    
  98.         FE_OVERFLOW        = $0004;      
  99.         FE_DIVBYZERO       = $0008;     
  100.         FE_INEXACT         = $0010;  
  101.     {$ENDC}
  102.     
  103. {$ENDC}
  104.  
  105.  
  106. {   The bitwise OR of all exception macros                                  }
  107.  
  108.     FE_ALL_EXCEPT  =   FE_INEXACT + FE_DIVBYZERO + FE_UNDERFLOW + FE_OVERFLOW + FE_INVALID;
  109.  
  110.  
  111. {   Definition of pointer to IEEE default environment object                }
  112. VAR
  113.     {$PUSH}
  114.     {$J+}
  115.     _FE_DFL_ENV: fenv_t;   {default environment object        }
  116.     {$POP}
  117.  
  118.  
  119.  
  120. (******************************************************************************
  121. *     The following functions provide access to the exception flags.  The      *
  122. *     "int" input argument can be constructed by bitwise ORs of the exception  *
  123. *     macros: for example: FE_OVERFLOW | FE_INEXACT.                           *
  124. *******************************************************************************)
  125.  
  126. (*******************************************************************************
  127. *     The function "feclearexcept" clears the supported exceptions represented *
  128. *     by its argument.                                                         *
  129. *******************************************************************************)
  130.  
  131. PROCEDURE feclearexcept( excepts: LONGINT ); C;
  132.  
  133.  
  134.  
  135. (*******************************************************************************
  136. *    The function "fegetexcept" stores a representation of the exception       *
  137. *     flags indicated by the argument "excepts" through the pointer argument   *
  138. *     "flagp".                                                                 *
  139. *******************************************************************************)
  140.  
  141. PROCEDURE fegetexcept( VAR flagp:    fexcept_t;
  142.                         excepts:    LONGINT ); C;
  143.  
  144.  
  145.  
  146. (*******************************************************************************
  147. *     The function "feraiseexcept" raises the supported exceptions             *
  148. *     represented by its argument.                                             *
  149. *******************************************************************************)
  150.  
  151. PROCEDURE feraiseexcept( excepts:    LONGINT ); C;
  152.  
  153.  
  154.  
  155. (*******************************************************************************
  156. *     The function "fesetexcept" sets or clears the exception flags indicated  *
  157. *     by the int argument "excepts" according to the representation in the     *
  158. *     object pointed to by the pointer argument "flagp".  The value of         *
  159. *     "*flagp" must have been set by a previous call to "fegetexcept".         *
  160. *     This function does not raise exceptions; it just sets the state of       *
  161. *     the flags.                                                               *
  162. *******************************************************************************)
  163.  
  164. PROCEDURE fesetexcept( VAR flagp:  fexcept_t; excepts:    LONGINT ); C;
  165.  
  166.  
  167.  
  168. (*******************************************************************************
  169. *     The function "fetestexcept" determines which of the specified subset of  *
  170. *     the exception flags are currently set.  The argument "excepts" specifies *
  171. *     the exception flags to be queried as a bitwise OR of the exception       *
  172. *     macros.  This function returns the bitwise OR of the exception macros    *
  173. *     corresponding to the currently set exceptions included in "excepts".     *
  174. *******************************************************************************)
  175.  
  176. FUNCTION fetestexcept( excepts: LONGINT ): LONGINT; C;
  177.  
  178.  
  179.  
  180. (*******************************************************************************
  181. *     The following functions provide control of rounding direction modes.     *
  182. *******************************************************************************)
  183.  
  184. (*******************************************************************************
  185. *     The function "fegetround" returns the value of the rounding direction    *
  186. *     macro which represents the current rounding direction.                   *
  187. *******************************************************************************)
  188.  
  189. FUNCTION fegetround: LONGINT; C;
  190.  
  191.  
  192.  
  193. (*******************************************************************************
  194. *     The function "fesetround" establishes the rounding direction represented *
  195. *     by its argument.  It returns nonzero if and only if the argument matches *
  196. *     a rounding direction macro.  If not, the rounding direction is not       *
  197. *     changed.                                                                 *
  198. *******************************************************************************)
  199.  
  200. FUNCTION fesetround(round: LONGINT): LONGINT; C;
  201.  
  202.  
  203. (*******************************************************************************
  204. *    The following functions manage the floating-point environment, exception  *
  205. *    flags and dynamic modes, as one entity.                                   *
  206. *******************************************************************************)
  207.  
  208. (*******************************************************************************
  209. *     The function "fegetenv" stores the current floating-point environment    *
  210. *     in the object pointed to by its pointer argument "envp".                 *
  211. *******************************************************************************)
  212.  
  213. PROCEDURE fegetenv( VAR envp:    fenv_t ); C;
  214.  
  215.  
  216.  
  217. (*******************************************************************************
  218. *     The function "feholdexcept" saves the current environment in the object  *
  219. *     pointed to by its pointer argument "envp", clears the exception flags,   *
  220. *     and clears floating-point exception enables.  This function supersedes   *
  221. *     the SANE function "procentry", but it does not change the current        *
  222. *     rounding direction mode.                                                 *
  223. *******************************************************************************)
  224.  
  225. FUNCTION feholdexcept( VAR envp: fenv_t ): LONGINT; C;
  226.  
  227.  
  228.  
  229. (*******************************************************************************
  230. *     The function "fesetenv" installs the floating-point environment          *
  231. *     environment represented by the object pointed to by its argument         *
  232. *     "envp".  The value of "*envp" must be set by a call to "fegetenv" or     *
  233. *     "feholdexcept", by an implementation-defined macro of type "fenv_t",     *
  234. *     or by the use of the pointer macro FE_DFL_ENV as the argument.           *
  235. *******************************************************************************)
  236.  
  237. PROCEDURE fesetenv( VAR envp: fenv_t ); C;
  238.  
  239.  
  240.  
  241. (*******************************************************************************
  242. *     The function "feupdateenv" saves the current exceptions into its         *
  243. *     automatic storage, installs the environment represented through its      *
  244. *     pointer argument "envp", and then re-raises the saved exceptions.        *
  245. *     This function, which supersedes the SANE function "procexit", can be     *
  246. *     used in conjunction with "feholdexcept" to write routines which hide     *
  247. *     spurious exceptions from their callers.                                  *
  248. *******************************************************************************)
  249.       
  250. PROCEDURE feupdateenv( VAR envp: fenv_t ); C;
  251.  
  252. {$IFC GENERATING68K}
  253.  
  254. (*******************************************************************************
  255. *     The following functions provide control of rounding precision.           *
  256. *     Because the PowerPC does not provide this capability, these functions    *  
  257. *     are available only for the 68K Macintosh.  Rounding precision values     *
  258. *     are defined by the rounding precision macros.  These functions are       *
  259. *     equivalent to the SANE functions getprecision and setprecision.          *
  260. *******************************************************************************)
  261.  
  262. FUNCTION fegetprec: LONGINT; C;
  263. FUNCTION fesetprec (precision: LONGINT): LONGINT; C;
  264.  
  265. {$ENDC}
  266.  
  267.  
  268. {$SETC UsingIncludes := fpenvIncludes}
  269.  
  270. {$ENDC} {__FPENV__}
  271.  
  272. {$IFC NOT UsingIncludes}
  273.  END.
  274. {$ENDC}
  275.