home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / g__inc / builtin.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-23  |  7.7 KB  |  284 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2.  
  3. /* 
  4. Copyright (C) 1988 Free Software Foundation
  5.     written by Doug Lea (dl@rocky.oswego.edu)
  6.  
  7. This file is part of the GNU C++ Library.  This library is free
  8. software; you can redistribute it and/or modify it under the terms of
  9. the GNU Library General Public License as published by the Free
  10. Software Foundation; either version 2 of the License, or (at your
  11. option) any later version.  This library is distributed in the hope
  12. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  13. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14. PURPOSE.  See the GNU Library General Public License for more details.
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free Software
  17. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19.  
  20. /*
  21.   arithmetic, etc. functions on built in types
  22. */
  23.  
  24.  
  25. #ifndef _builtin_h
  26. #ifdef __GNUG__
  27. #pragma once
  28. #pragma interface
  29. #endif
  30. #define _builtin_h 1
  31.  
  32. typedef void (*one_arg_error_handler_t)(const char*);
  33. typedef void (*two_arg_error_handler_t)(const char*, const char*);
  34.  
  35.  
  36.  
  37. #include <stddef.h>
  38. #include <std.h>
  39. #include <math.h>
  40.  
  41. #ifdef min
  42. #undef min
  43. #endif
  44.  
  45. #ifdef max
  46. #undef max
  47. #endif
  48.  
  49. long         gcd(long, long);
  50. long         lg(unsigned long); 
  51. double       pow(double, long);
  52. long         pow(long, long);
  53.  
  54. double       start_timer();
  55. double       return_elapsed_time(double last_time = 0.0);
  56.  
  57. char*        itoa(long x, int base = 10, int width = 0);
  58. char*        itoa(unsigned long x, int base = 10, int width = 0);
  59. #ifdef __GNUG__
  60. char*        itoa(long long x, int base = 10, int width = 0);
  61. char*        itoa(unsigned long long x, int base = 10, int width = 0);
  62. #endif
  63. char*        dtoa(double x, char cvt = 'g', int width = 0, int prec = 6);
  64.  
  65. char*        hex(long x, int width = 0);
  66. char*        hex(unsigned long x, int width = 0);
  67. char*        hex(int x, int width = 0);
  68. char*        hex(short x, int width = 0);
  69. char*        hex(unsigned int x, int width = 0);
  70. char*        hex(unsigned short x, int width = 0);
  71.  
  72. char*        oct(long x, int width = 0);
  73. char*        oct(unsigned long x, int width = 0);
  74. char*        oct(int x, int width = 0);
  75. char*        oct(short x, int width = 0);
  76. char*        oct(unsigned int x, int width = 0) ;
  77. char*        oct(unsigned short x, int width = 0); 
  78.  
  79. char*        dec(long x, int width = 0);
  80. char*        dec(unsigned long x, int width = 0);
  81. char*        dec(int x, int width = 0);
  82. char*        dec(short x, int width = 0);
  83. char*        dec(unsigned int x, int width = 0) ;
  84. char*        dec(unsigned short x, int width = 0); 
  85.  
  86. char*        form(const char* fmt ...);
  87. char*        chr(char ch, int width = 0);
  88. #ifdef atarist
  89. char*        str(const char* s, size_t width = 0);
  90. #else
  91. char*        str(const char* s, int width = 0);
  92. #endif
  93.  
  94. unsigned long hashpjw(const char*);
  95. unsigned long multiplicativehash(int);
  96. unsigned long foldhash(double);
  97.  
  98. extern void default_one_arg_error_handler(const char*);
  99. extern void default_two_arg_error_handler(const char*, const char*);
  100.  
  101. extern two_arg_error_handler_t lib_error_handler;
  102.  
  103. extern two_arg_error_handler_t 
  104.        set_lib_error_handler(two_arg_error_handler_t f);
  105.  
  106.  
  107. double abs(double arg);
  108. float abs(float arg);
  109. short abs(short arg);
  110. long abs(long arg);
  111. int sign(long arg);
  112. int sign(double arg);
  113. long sqr(long arg);
  114. double sqr(double arg);
  115. int even(long arg);
  116. int odd(long arg);
  117. long lcm(long x, long y);
  118. void setbit(long& x, long b);
  119. void clearbit(long& x, long b);
  120. int testbit(long x, long b);
  121.  
  122.  
  123. signed char min(signed char a, signed char b);
  124. unsigned char min(unsigned char a, unsigned char b);
  125.  
  126. signed short min(signed short a, signed short b);
  127. unsigned short min(unsigned short a, unsigned short b);
  128.  
  129. signed int min(signed int a, signed int b);
  130. unsigned int min(unsigned int a, unsigned int b);
  131.  
  132. signed long min(signed long a, signed long b);
  133. unsigned long min(unsigned long a, unsigned long b);
  134.  
  135. float min(float a, float b);
  136.  
  137. double min(double a, double b);
  138.  
  139. signed char max(signed char a, signed char b);
  140. unsigned char max(unsigned char a, unsigned char b);
  141.  
  142. signed short max(signed short a, signed short b);
  143. unsigned short max(unsigned short a, unsigned short b);
  144.  
  145. signed int max(signed int a, signed int b);
  146. unsigned int max(unsigned int a, unsigned int b);
  147.  
  148. signed long max(signed long a, signed long b);
  149. unsigned long max(unsigned long a, unsigned long b);
  150.  
  151. float max(float a, float b);
  152.  
  153. double max(double a, double b);
  154.  
  155. #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
  156.  
  157.  
  158. inline double abs(double arg) 
  159. {
  160.   return (arg < 0.0)? -arg : arg;
  161. }
  162.  
  163. inline float abs(float arg) 
  164. {
  165.   return (arg < 0.0)? -arg : arg;
  166. }
  167.  
  168. inline short abs(short arg) 
  169. {
  170.   return (arg < 0)? -arg : arg;
  171. }
  172.  
  173. inline long abs(long arg) 
  174. {
  175.   return (arg < 0)? -arg : arg;
  176. }
  177.  
  178. inline int sign(long arg)
  179. {
  180.   return (arg == 0) ? 0 : ( (arg > 0) ? 1 : -1 );
  181. }
  182.  
  183. inline int sign(double arg)
  184. {
  185.   return (arg == 0.0) ? 0 : ( (arg > 0.0) ? 1 : -1 );
  186. }
  187.  
  188. inline long sqr(long arg)
  189. {
  190.   return arg * arg;
  191. }
  192.  
  193. inline double sqr(double arg)
  194. {
  195.   return arg * arg;
  196. }
  197.  
  198. inline int even(long arg)
  199. {
  200.   return !(arg & 1);
  201. }
  202.  
  203. inline int odd(long arg)
  204. {
  205.   return (arg & 1);
  206. }
  207.  
  208. inline long lcm(long x, long y)
  209. {
  210.   return x / gcd(x, y) * y;
  211. }
  212.  
  213. inline void setbit(long& x, long b)
  214. {
  215.   x |= (1 << b);
  216. }
  217.  
  218. inline void clearbit(long& x, long b)
  219. {
  220.   x &= ~(1 << b);
  221. }
  222.  
  223. inline int testbit(long x, long b)
  224. {
  225.   return ((x & (1 << b)) != 0);
  226. }
  227.  
  228. inline char* hex(int x, int width) { return hex(long(x), width); }
  229. inline char* hex(short x, int width) { return hex(long(x), width); }
  230. inline char* hex(unsigned int x, int width) 
  231. { return hex((unsigned long)(x), width); }
  232. inline char* hex(unsigned short x, int width) 
  233. { return hex((unsigned long)(x), width); }
  234.  
  235. inline char* oct(int x, int width) { return oct(long(x), width); }
  236. inline char* oct(short x, int width) { return oct(long(x), width); }
  237. inline char* oct(unsigned int x, int width) 
  238. { return oct((unsigned long)(x), width); }
  239. inline char* oct(unsigned short x, int width) 
  240. { return oct((unsigned long)(x), width); }
  241.  
  242. inline char* dec(int x, int width) { return dec(long(x), width); }
  243. inline char* dec(short x, int width) { return dec(long(x), width); }
  244. inline char* dec(unsigned int x, int width) 
  245. { return dec((unsigned long)(x), width); }
  246. inline char* dec(unsigned short x, int width) 
  247. { return dec((unsigned long)(x), width); }
  248.  
  249. inline signed char min(signed char a, signed char b) { return (a < b)?a:b;}
  250. inline unsigned char min(unsigned char a, unsigned char b) {return (a < b)?a:b;}
  251.  
  252. inline signed short min(signed short a, signed short b) {return (a < b) ?a:b;}
  253. inline unsigned short min(unsigned short a, unsigned short b) {return (a < b)?a:b;}
  254.  
  255. inline signed int min(signed int a, signed int b) {return (a < b)?a:b;}
  256. inline unsigned int min(unsigned int a, unsigned int b) {return (a < b)?a:b;}
  257.  
  258. inline signed long min(signed long a, signed long b) {return (a < b)?a:b;}
  259. inline unsigned long min(unsigned long a, unsigned long b) {return (a < b)?a:b;}
  260.  
  261. inline float min(float a, float b) {return (a < b)?a:b;}
  262.  
  263. inline double min(double a, double b) {return (a < b)?a:b;}
  264.  
  265. inline signed char max(signed char a, signed char b) { return (a > b)?a:b;}
  266. inline unsigned char max(unsigned char a, unsigned char b) {return (a > b)?a:b;}
  267.  
  268. inline signed short max(signed short a, signed short b) {return (a > b) ?a:b;}
  269. inline unsigned short max(unsigned short a, unsigned short b) {return (a > b)?a:b;}
  270.  
  271. inline signed int max(signed int a, signed int b) {return (a > b)?a:b;}
  272. inline unsigned int max(unsigned int a, unsigned int b) {return (a > b)?a:b;}
  273.  
  274. inline signed long max(signed long a, signed long b) {return (a > b)?a:b;}
  275. inline unsigned long max(unsigned long a, unsigned long b) {return (a > b)?a:b;}
  276.  
  277. inline float max(float a, float b) {return (a > b)?a:b;}
  278.  
  279. inline double max(double a, double b) {return (a > b)?a:b;}
  280.  
  281. #endif
  282.  
  283. #endif
  284.