home *** CD-ROM | disk | FTP | other *** search
/ Game Zone - 1,000+ Games / GAMEZONE.BIN / Programs / PALM / Oh-One / src / mathcalls.c < prev    next >
C/C++ Source or Header  |  1998-07-13  |  9KB  |  352 lines
  1. /* MathLib: Pilot shared library of IEEE-754 double math functions
  2.  *
  3.  * Jump target stub routines called from the library's dispatch table.
  4.  * These routines serve two important functions:
  5.  *    1.  They encapsulate the GCC math routines, translating the
  6.  *        function call format as required for invocation through
  7.  *        the OS library SYS_TRAP() interface.  This allows us to
  8.  *        leave the GCC source code largely untouched, for easier
  9.  *        inclusion of future GCC updates.
  10.  *    2.  By cleverly controlling the way the library is linked so
  11.  *        that these routines end up being placed somewhere around
  12.  *        the middle of the code segment, they provide a way to
  13.  *        get around the 32KB code segment size limit.  The 32KB code
  14.  *        limit is caused by the limited range of a 68000 pc-relative
  15.  *        'jmp' instruction, which can only jump +/-32KB.  Since
  16.  *        the dispatch table at the start of our library has to do a
  17.  *        jmp anyway, we put these intermediate routines in the middle,
  18.  *        and now from here we can jump 32KB in *either* direction.
  19.  *        This lets us get by with having almost 64KB of code.
  20.  *
  21.  * Copyright (C) 1997 Rick Huebner
  22.  *
  23.  * This program is free software; you can redistribute it and/or modify
  24.  * it under the terms of the GNU Library General Public License as
  25.  * published by the Free Software Foundation; either version 2 of
  26.  * the License, or (at your option) any later version.
  27.  *
  28.  * This program is distributed in the hope that it will be useful,
  29.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  30.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31.  * GNU Library General Public License for more details.
  32.  *
  33.  * You should have received a copy of the GNU Library General Public License
  34.  * along with this program; see file COPYING.LIB.  If not, write to the
  35.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  36.  * Boston, MA 02111-1307, USA
  37.  *
  38.  * Version 1.0, 15 August 1997, Rick Huebner
  39.  */
  40. #include <Pilot.h>
  41. #include <SysAll.h>
  42.  
  43. #include "MathLib.h"
  44. #include "MathLibPrv.h"
  45. #include "math.h"
  46.  
  47.  
  48.  
  49. // Special "jump island" routines, used to provide a bridge when
  50. // a routine near one end of our oversized code segment has to call
  51. // a routine near the other end.  The need for these rest stops has
  52. // been minimized by trying to arrange our code segment for good
  53. // locality of reference.
  54. double jumpto__ieee754_sqrt(double x) {
  55.     return __ieee754_sqrt(x);
  56. }
  57.  
  58. double jumpto__fabs(double x) {
  59.     return __fabs(x);
  60. }
  61.  
  62. double jumpto__scalbn(double x, int n) {
  63.     return __scalbn(x, n);
  64. }
  65.  
  66.  
  67.  
  68. // Jump target/GCC encapsulation stub routines
  69. Err mathlib_acos(UInt refnum, double x, double *result) {
  70. #pragma unused(refnum)
  71.     *result = __ieee754_acos(x);
  72.     return mlErrNone;
  73. }
  74.  
  75. Err mathlib_asin(UInt refnum, double x, double *result) {
  76. #pragma unused(refnum)
  77.     *result = __ieee754_asin(x);
  78.     return mlErrNone;
  79. }
  80.  
  81. Err mathlib_atan(UInt refnum, double x, double *result) {
  82. #pragma unused(refnum)
  83.     *result = __atan(x);
  84.     return mlErrNone;
  85. }
  86.  
  87. Err mathlib_atan2(UInt refnum, double y, double x, double *result) {
  88. #pragma unused(refnum)
  89.     *result = __ieee754_atan2(y, x);
  90.     return mlErrNone;
  91. }
  92.  
  93. Err mathlib_cos(UInt refnum, double x, double *result) {
  94. #pragma unused(refnum)
  95.     *result = __cos(x);
  96.     return mlErrNone;
  97. }
  98.  
  99. Err mathlib_sin(UInt refnum, double x, double *result) {
  100. #pragma unused(refnum)
  101.     *result = __sin(x);
  102.     return mlErrNone;
  103. }
  104.  
  105. Err mathlib_tan(UInt refnum, double x, double *result) {
  106. #pragma unused(refnum)
  107.     *result = __tan(x);
  108.     return mlErrNone;
  109. }
  110.  
  111. Err mathlib_sincos(UInt refnum, double x, double *sinx, double *cosx) {
  112. #pragma unused(refnum)
  113.     __sincos(x, sinx, cosx);
  114.     return mlErrNone;
  115. }
  116.  
  117. Err mathlib_cosh(UInt refnum, double x, double *result) {
  118. #pragma unused(refnum)
  119.     *result = __ieee754_cosh(x);
  120.     return mlErrNone;
  121. }
  122.  
  123. Err mathlib_sinh(UInt refnum, double x, double *result) {
  124. #pragma unused(refnum)
  125.     *result = __ieee754_sinh(x);
  126.     return mlErrNone;
  127. }
  128.  
  129. Err mathlib_tanh(UInt refnum, double x, double *result) {
  130. #pragma unused(refnum)
  131.     *result = __tanh(x);
  132.     return mlErrNone;
  133. }
  134.  
  135. Err mathlib_acosh(UInt refnum, double x, double *result) {
  136. #pragma unused(refnum)
  137.     *result = __ieee754_acosh(x);
  138.     return mlErrNone;
  139. }
  140.  
  141. Err mathlib_asinh(UInt refnum, double x, double *result) {
  142. #pragma unused(refnum)
  143.     *result = __asinh(x);
  144.     return mlErrNone;
  145. }
  146.  
  147. Err mathlib_atanh(UInt refnum, double x, double *result) {
  148. #pragma unused(refnum)
  149.     *result = __ieee754_atanh(x);
  150.     return mlErrNone;
  151. }
  152.  
  153. Err mathlib_exp(UInt refnum, double x, double *result) {
  154. #pragma unused(refnum)
  155.     *result = __ieee754_exp(x);
  156.     return mlErrNone;
  157. }
  158.  
  159. Err mathlib_frexp(UInt refnum, double x, double *fraction, Int *exponent) {
  160. #pragma unused(refnum)
  161.     int exp;
  162.     *fraction = __frexp(x, &exp);
  163.     *exponent = exp;
  164.     return mlErrNone;
  165. }
  166.  
  167. Err mathlib_ldexp(UInt refnum, double x, Int exponent, double *result) {
  168. #pragma unused(refnum)
  169.     *result = __ldexp(x, exponent);
  170.     return mlErrNone;
  171. }
  172.  
  173. Err mathlib_log(UInt refnum, double x, double *result) {
  174. #pragma unused(refnum)
  175.     *result = __ieee754_log(x);
  176.     return mlErrNone;
  177. }
  178.  
  179. Err mathlib_log10(UInt refnum, double x, double *result) {
  180. #pragma unused(refnum)
  181.     *result = __ieee754_log10(x);
  182.     return mlErrNone;
  183. }
  184.  
  185. Err mathlib_modf(UInt refnum, double x, double *intpart, double *fracpart) {
  186. #pragma unused(refnum)
  187.     *fracpart = __modf(x, intpart);
  188.     return mlErrNone;
  189. }
  190.  
  191. Err mathlib_expm1(UInt refnum, double x, double *result) {
  192. #pragma unused(refnum)
  193.     *result = __expm1(x);
  194.     return mlErrNone;
  195. }
  196.  
  197. Err mathlib_log1p(UInt refnum, double x, double *result) {
  198. #pragma unused(refnum)
  199.     *result = __log1p(x);
  200.     return mlErrNone;
  201. }
  202.  
  203. Err mathlib_logb(UInt refnum, double x, double *result) {
  204. #pragma unused(refnum)
  205.     *result = __logb(x);
  206.     return mlErrNone;
  207. }
  208.  
  209. Err mathlib_log2(UInt refnum, double x, double *result) {
  210. #pragma unused(refnum)
  211.     *result = __log2(x);
  212.     return mlErrNone;
  213. }
  214.  
  215. Err mathlib_pow(UInt refnum, double x, double y, double *result) {
  216. #pragma unused(refnum)
  217.     *result = __ieee754_pow(x, y);
  218.     return mlErrNone;
  219. }
  220.  
  221. Err mathlib_sqrt(UInt refnum, double x, double *result) {
  222. #pragma unused(refnum)
  223.     *result = __ieee754_sqrt(x);
  224.     return mlErrNone;
  225. }
  226.  
  227. Err mathlib_hypot(UInt refnum, double x, double y, double *result) {
  228. #pragma unused(refnum)
  229.     *result = __ieee754_hypot(x, y);
  230.     return mlErrNone;
  231. }
  232.  
  233. Err mathlib_cbrt(UInt refnum, double x, double *result) {
  234. #pragma unused(refnum)
  235.     *result = __cbrt(x);
  236.     return mlErrNone;
  237. }
  238.  
  239. Err mathlib_ceil(UInt refnum, double x, double *result) {
  240. #pragma unused(refnum)
  241.     *result = __ceil(x);
  242.     return mlErrNone;
  243. }
  244.  
  245. Err mathlib_fabs(UInt refnum, double x, double *result) {
  246. #pragma unused(refnum)
  247.     *result = __fabs(x);
  248.     return mlErrNone;
  249. }
  250.  
  251. Err mathlib_floor(UInt refnum, double x, double *result) {
  252. #pragma unused(refnum)
  253.     *result = __floor(x);
  254.     return mlErrNone;
  255. }
  256.  
  257. Err mathlib_fmod(UInt refnum, double x, double y, double *result) {
  258. #pragma unused(refnum)
  259.     *result = __ieee754_fmod(x, y);
  260.     return mlErrNone;
  261. }
  262.  
  263. Err mathlib_isinf(UInt refnum, double x, Int *result) {
  264. #pragma unused(refnum)
  265.     *result = __isinf(x);
  266.     return mlErrNone;
  267. }
  268.  
  269. Err mathlib_finite(UInt refnum, double x, Int *result) {
  270. #pragma unused(refnum)
  271.     *result = __finite(x);
  272.     return mlErrNone;
  273. }
  274.  
  275. Err mathlib_scalbn(UInt refnum, double x, Int exponent, double *result) {
  276. #pragma unused(refnum)
  277.     *result = __scalbn(x, exponent);
  278.     return mlErrNone;
  279. }
  280.  
  281. Err mathlib_drem(UInt refnum, double x, double y, double *result) {
  282. #pragma unused(refnum)
  283.     *result = __ieee754_remainder(x, y);
  284.     return mlErrNone;
  285. }
  286.  
  287. Err mathlib_significand(UInt refnum, double x, double *result) {
  288. #pragma unused(refnum)
  289.     *result = __significand(x);
  290.     return mlErrNone;
  291. }
  292.  
  293. Err mathlib_copysign(UInt refnum, double x, double y, double *result) {
  294. #pragma unused(refnum)
  295.     *result = __copysign(x, y);
  296.     return mlErrNone;
  297. }
  298.  
  299. Err mathlib_isnan(UInt refnum, double x, Int *result) {
  300. #pragma unused(refnum)
  301.     *result = __isnan(x);
  302.     return mlErrNone;
  303. }
  304.  
  305. Err mathlib_ilogb(UInt refnum, double x, Int *result) {
  306. #pragma unused(refnum)
  307.     *result = __ilogb(x);
  308.     return mlErrNone;
  309. }
  310.  
  311. Err mathlib_rint(UInt refnum, double x, double *result) {
  312. #pragma unused(refnum)
  313.     *result = __rint(x);
  314.     return mlErrNone;
  315. }
  316.  
  317. Err mathlib_nextafter(UInt refnum, double x, double y, double *result) {
  318. #pragma unused(refnum)
  319.     *result = __nextafter(x, y);
  320.     return mlErrNone;
  321. }
  322.  
  323. Err mathlib_remainder(UInt refnum, double x, double y, double *result) {
  324. #pragma unused(refnum)
  325.     *result = __ieee754_remainder(x, y);
  326.     return mlErrNone;
  327. }
  328.  
  329. Err mathlib_scalb(UInt refnum, double x, double exponent, double *result) {
  330. #pragma unused(refnum)
  331.     *result = __ieee754_scalb(x, exponent);
  332.     return mlErrNone;
  333. }
  334.  
  335. Err mathlib_round(UInt refnum, double x, double *result) {
  336. #pragma unused(refnum)
  337.     *result = __round(x);
  338.     return mlErrNone;
  339. }
  340.  
  341. Err mathlib_trunc(UInt refnum, double x, double *result) {
  342. #pragma unused(refnum)
  343.     *result = __trunc(x);
  344.     return mlErrNone;
  345. }
  346.  
  347. Err mathlib_signbit(UInt refnum, double x, ULong *result) {
  348. #pragma unused(refnum)
  349.     *result = __signbit(x);
  350.     return mlErrNone;
  351. }
  352.