ut0byte.ic
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:8k
源码类别:

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