ut0byte.ic
上传用户:tsgydb
上传日期:2007-04-14
资源大小:10674k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************************
  2. Utilities for byte operations
  3. (c) 1994, 1995 Innobase Oy
  4. Created 5/30/1994 Heikki Tuuri
  5. *******************************************************************/
  6. /***********************************************************
  7. Creates a 64-bit dulint out of two ulints. */
  8. UNIV_INLINE
  9. dulint
  10. ut_dulint_create(
  11. /*=============*/
  12. /* out: created dulint */
  13. ulint high, /* in: high-order 32 bits */
  14. ulint low) /* in: low-order 32 bits */
  15. {
  16. dulint res;
  17. ut_ad(high <= 0xFFFFFFFF);
  18. ut_ad(low <= 0xFFFFFFFF);
  19. res.high = high;
  20. res.low  = low;
  21. return(res);
  22. }
  23. /***********************************************************
  24. Gets the high-order 32 bits of a dulint. */
  25. UNIV_INLINE
  26. ulint
  27. ut_dulint_get_high(
  28. /*===============*/
  29. /* out: 32 bits in ulint */
  30. dulint d) /* in: dulint */
  31. {
  32. return(d.high);
  33. }
  34. /***********************************************************
  35. Gets the low-order 32 bits of a dulint. */
  36. UNIV_INLINE
  37. ulint
  38. ut_dulint_get_low(
  39. /*==============*/
  40. /* out: 32 bits in ulint */
  41. dulint d) /* in: dulint */
  42. {
  43. return(d.low);
  44. }
  45. /***********************************************************
  46. Tests if a dulint is zero. */
  47. UNIV_INLINE
  48. ibool
  49. ut_dulint_is_zero(
  50. /*==============*/
  51. /* out: TRUE if zero */
  52. dulint a) /* in: dulint */
  53. {
  54. if ((a.low == 0) && (a.high == 0)) {
  55. return(TRUE);
  56. }
  57. return(FALSE);
  58. }
  59. /***********************************************************
  60. Compares two dulints. */
  61. UNIV_INLINE
  62. int
  63. ut_dulint_cmp(
  64. /*==========*/
  65. /* out: -1 if a < b, 0 if a == b,
  66. 1 if a > b */ 
  67. dulint a, /* in: dulint */
  68. dulint b) /* in: dulint */
  69. {
  70. if (a.high > b.high) {
  71. return(1);
  72. } else if (a.high < b.high) {
  73. return(-1);
  74. } else if (a.low > b.low) {
  75. return(1);
  76. } else if (a.low < b.low) {
  77. return(-1);
  78. } else {
  79. return(0);
  80. }
  81. }
  82. /***********************************************************
  83. Calculates the max of two dulints. */
  84. UNIV_INLINE
  85. dulint
  86. ut_dulint_get_max(
  87. /*==============*/
  88. /* out: max(a, b) */
  89. dulint a, /* in: dulint */
  90. dulint b) /* in: dulint */
  91. {
  92. if (ut_dulint_cmp(a, b) > 0) {
  93. return(a);
  94. }
  95. return(b);
  96. }
  97. /***********************************************************
  98. Calculates the min of two dulints. */
  99. UNIV_INLINE
  100. dulint
  101. ut_dulint_get_min(
  102. /*==============*/
  103. /* out: min(a, b) */
  104. dulint a, /* in: dulint */
  105. dulint b) /* in: dulint */
  106. {
  107. if (ut_dulint_cmp(a, b) > 0) {
  108. return(b);
  109. }
  110. return(a);
  111. }
  112. /***********************************************************
  113. Adds a ulint to a dulint. */
  114. UNIV_INLINE
  115. dulint
  116. ut_dulint_add(
  117. /*==========*/
  118. /* out: sum a + b */
  119. dulint a, /* in: dulint */
  120. ulint b) /* in: ulint */
  121. {
  122. if (0xFFFFFFFF - b >= a.low) {
  123. a.low += b;
  124. return(a);
  125. }
  126. a.low = a.low - (0xFFFFFFFF - b) - 1;
  127. a.high++;
  128. return(a);
  129. }
  130. /***********************************************************
  131. Subtracts a ulint from a dulint. */
  132. UNIV_INLINE
  133. dulint
  134. ut_dulint_subtract(
  135. /*===============*/
  136. /* out: a - b */
  137. dulint a, /* in: dulint */
  138. ulint b) /* in: ulint, b <= a */
  139. {
  140. if (a.low >= b) {
  141. a.low -= b;
  142. return(a);
  143. }
  144. b -= a.low + 1;
  145. a.low = 0xFFFFFFFF - b;
  146. ut_ad(a.high > 0);
  147. a.high--;
  148. return(a);
  149. }
  150. /***********************************************************
  151. Subtracts a dulint from another. NOTE that the difference must be positive
  152. and smaller that 4G. */
  153. UNIV_INLINE
  154. ulint
  155. ut_dulint_minus(
  156. /*============*/
  157. /* out: a - b */
  158. dulint a, /* in: dulint; NOTE a must be >= b and at most
  159. 2 to power 32 - 1 greater */
  160. dulint b) /* in: dulint */
  161. {
  162. ulint diff;
  163. if (a.high == b.high) {
  164. ut_ad(a.low >= b.low);
  165. return(a.low - b.low);
  166. }
  167. ut_ad(a.high == b.high + 1);
  168. diff = (ulint)(0xFFFFFFFF - b.low);
  169. diff += 1 + a.low;
  170. ut_ad(diff > a.low);
  171. return(diff);
  172. /************************************************************
  173. Rounds a dulint downward to a multiple of a power of 2. */
  174. UNIV_INLINE
  175. dulint
  176. ut_dulint_align_down(
  177. /*=================*/
  178. /* out: rounded value */
  179. dulint   n,         /* in: number to be rounded */
  180. ulint    align_no)   /* in: align by this number which must be a
  181. power of 2 */
  182. {
  183. ulint low, high;
  184. ut_ad(align_no > 0);
  185. ut_ad(((align_no - 1) & align_no) == 0);
  186. low = ut_dulint_get_low(n);
  187. high = ut_dulint_get_high(n);
  188. low = low & ~(align_no - 1);
  189. return(ut_dulint_create(high, low));
  190. }
  191. /************************************************************
  192. Rounds a dulint upward to a multiple of a power of 2. */
  193. UNIV_INLINE
  194. dulint
  195. ut_dulint_align_up(
  196. /*===============*/
  197. /* out: rounded value */
  198. dulint   n,         /* in: number to be rounded */
  199. ulint    align_no)   /* in: align by this number which must be a
  200. power of 2 */
  201. {
  202. return(ut_dulint_align_down(ut_dulint_add(n, align_no - 1), align_no));
  203. }
  204. /************************************************************
  205. The following function calculates the value of an integer n rounded
  206. to the least product of align_no which is >= n. align_no
  207. has to be a power of 2. */
  208. UNIV_INLINE
  209. ulint
  210. ut_calc_align(
  211. /*==========*/
  212. /* out: rounded value */
  213. ulint    n,         /* in: number to be rounded */
  214. ulint    align_no)   /* in: align by this number */
  215. {
  216. ut_ad(align_no > 0);
  217. ut_ad(((align_no - 1) & align_no) == 0);
  218. return((n + align_no - 1) & ~(align_no - 1));
  219. }
  220. /*************************************************************
  221. The following function rounds up a pointer to the nearest aligned address. */
  222. UNIV_INLINE
  223. void*
  224. ut_align(
  225. /*=====*/
  226. /* out: aligned pointer */
  227. void*   ptr,            /* in: pointer */
  228. ulint   align_no)       /* in: align by this number */
  229. {
  230. ut_ad(align_no > 0);
  231. ut_ad(((align_no - 1) & align_no) == 0);
  232. ut_ad(ptr);
  233. ut_ad(sizeof(void*) == sizeof(ulint));
  234. return((void*)((((ulint)ptr) + align_no - 1) & ~(align_no - 1)));
  235. }
  236. /************************************************************
  237. The following function calculates the value of an integer n rounded
  238. to the biggest product of align_no which is <= n. align_no has to be a
  239. power of 2. */
  240. UNIV_INLINE
  241. ulint
  242. ut_calc_align_down(
  243. /*===============*/
  244. /* out: rounded value */
  245. ulint    n,              /* in: number to be rounded */
  246. ulint    align_no)       /* in: align by this number */
  247. {
  248. ut_ad(align_no > 0);
  249. ut_ad(((align_no - 1) & align_no) == 0);
  250. return(n & ~(align_no - 1));
  251. }
  252. /*************************************************************
  253. The following function rounds down a pointer to the nearest
  254. aligned address. */
  255. UNIV_INLINE
  256. void*
  257. ut_align_down(
  258. /*==========*/
  259. /* out: aligned pointer */
  260. void*   ptr,            /* in: pointer */
  261. ulint   align_no)       /* in: align by this number */
  262. {
  263. ut_ad(align_no > 0);
  264. ut_ad(((align_no - 1) & align_no) == 0);
  265. ut_ad(ptr);
  266. ut_ad(sizeof(void*) == sizeof(ulint));
  267. return((void*)((((ulint)ptr)) & ~(align_no - 1)));
  268. }
  269. /*********************************************************************
  270. Gets the nth bit of a ulint. */
  271. UNIV_INLINE
  272. ibool
  273. ut_bit_get_nth(
  274. /*===========*/
  275. /* out: TRUE if nth bit is 1; 0th bit is defined to
  276. be the least significant */
  277. ulint a, /* in: ulint */
  278. ulint n) /* in: nth bit requested */
  279. {
  280. ut_ad(n < 8 * sizeof(ulint));
  281. ut_ad(TRUE == 1);
  282. return(1 & (a >> n));
  283. }
  284. /*********************************************************************
  285. Sets the nth bit of a ulint. */
  286. UNIV_INLINE
  287. ulint
  288. ut_bit_set_nth(
  289. /*===========*/
  290. /* out: the ulint with the bit set as requested */
  291. ulint a, /* in: ulint */
  292. ulint n, /* in: nth bit requested */
  293. ibool val) /* in: value for the bit to set */
  294. {
  295. ut_ad(n < 8 * sizeof(ulint));
  296. ut_ad(TRUE == 1);
  297. if (val) {
  298. return((1 << n) | a);
  299. } else {
  300. return(~(1 << n) & a);
  301. }
  302. }