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

MySQL数据库

开发平台:

Visual C++

  1. /**********************************************************************
  2. Utilities for byte operations
  3. (c) 1994, 1995 Innobase Oy
  4. Created 1/20/1994 Heikki Tuuri
  5. ***********************************************************************/
  6. #ifndef ut0byte_h
  7. #define ut0byte_h
  8. #include "univ.i"
  9. /* Type definition for a 64-bit unsigned integer, which works also
  10. in 32-bit machines. NOTE! Access the fields only with the accessor
  11. functions. This definition appears here only for the compiler to
  12. know the size of a dulint. */
  13. typedef struct dulint_struct dulint;
  14. struct dulint_struct{
  15. ulint high; /* most significant 32 bits */
  16. ulint low; /* least significant 32 bits */
  17. };
  18. /* Zero value for a dulint */
  19. extern dulint ut_dulint_zero;
  20. /* Maximum value for a dulint */
  21. extern dulint ut_dulint_max;
  22. /***********************************************************
  23. Creates a 64-bit dulint out of two ulints. */
  24. UNIV_INLINE
  25. dulint
  26. ut_dulint_create(
  27. /*=============*/
  28. /* out: created dulint */
  29. ulint high, /* in: high-order 32 bits */
  30. ulint low); /* in: low-order 32 bits */
  31. /***********************************************************
  32. Gets the high-order 32 bits of a dulint. */
  33. UNIV_INLINE
  34. ulint
  35. ut_dulint_get_high(
  36. /*===============*/
  37. /* out: 32 bits in ulint */
  38. dulint d); /* in: dulint */
  39. /***********************************************************
  40. Gets the low-order 32 bits of a dulint. */
  41. UNIV_INLINE
  42. ulint
  43. ut_dulint_get_low(
  44. /*==============*/
  45. /* out: 32 bits in ulint */
  46. dulint d); /* in: dulint */
  47. /***********************************************************
  48. Converts a dulint (a struct of 2 ulints) to ib_longlong, which is a 64-bit
  49. integer type. */
  50. UNIV_INLINE
  51. ib_longlong
  52. ut_conv_dulint_to_longlong(
  53. /*=======================*/
  54. /* out: value in ib_longlong type */
  55. dulint d); /* in: dulint */
  56. /***********************************************************
  57. Tests if a dulint is zero. */
  58. UNIV_INLINE
  59. ibool
  60. ut_dulint_is_zero(
  61. /*==============*/
  62. /* out: TRUE if zero */
  63. dulint a); /* in: dulint */
  64. /***********************************************************
  65. Compares two dulints. */
  66. UNIV_INLINE
  67. int
  68. ut_dulint_cmp(
  69. /*==========*/
  70. /* out: -1 if a < b, 0 if a == b,
  71. 1 if a > b */ 
  72. dulint a, /* in: dulint */
  73. dulint b); /* in: dulint */
  74. /***********************************************************
  75. Calculates the max of two dulints. */
  76. UNIV_INLINE
  77. dulint
  78. ut_dulint_get_max(
  79. /*==============*/
  80. /* out: max(a, b) */
  81. dulint a, /* in: dulint */
  82. dulint b); /* in: dulint */
  83. /***********************************************************
  84. Calculates the min of two dulints. */
  85. UNIV_INLINE
  86. dulint
  87. ut_dulint_get_min(
  88. /*==============*/
  89. /* out: min(a, b) */
  90. dulint a, /* in: dulint */
  91. dulint b); /* in: dulint */
  92. /***********************************************************
  93. Adds a ulint to a dulint. */
  94. UNIV_INLINE
  95. dulint
  96. ut_dulint_add(
  97. /*==========*/
  98. /* out: sum a + b */
  99. dulint a, /* in: dulint */
  100. ulint b); /* in: ulint */
  101. /***********************************************************
  102. Subtracts a ulint from a dulint. */
  103. UNIV_INLINE
  104. dulint
  105. ut_dulint_subtract(
  106. /*===============*/
  107. /* out: a - b */
  108. dulint a, /* in: dulint */
  109. ulint b); /* in: ulint, b <= a */
  110. /***********************************************************
  111. Subtracts a dulint from another. NOTE that the difference must be positive
  112. and smaller that 4G. */
  113. UNIV_INLINE
  114. ulint
  115. ut_dulint_minus(
  116. /*============*/
  117. /* out: a - b */
  118. dulint a, /* in: dulint; NOTE a must be >= b and at most
  119. 2 to power 32 - 1 greater */
  120. dulint b); /* in: dulint */
  121. /************************************************************
  122. Rounds a dulint downward to a multiple of a power of 2. */
  123. UNIV_INLINE
  124. dulint
  125. ut_dulint_align_down(
  126. /*=================*/
  127. /* out: rounded value */
  128. dulint   n,         /* in: number to be rounded */
  129. ulint    align_no);   /* in: align by this number which must be a
  130. power of 2 */
  131. /************************************************************
  132. Rounds a dulint upward to a multiple of a power of 2. */
  133. UNIV_INLINE
  134. dulint
  135. ut_dulint_align_up(
  136. /*===============*/
  137. /* out: rounded value */
  138. dulint   n,         /* in: number to be rounded */
  139. ulint    align_no);   /* in: align by this number which must be a
  140. power of 2 */
  141. /***********************************************************
  142. Increments a dulint variable by 1. */
  143. #define UT_DULINT_INC(D)
  144. {
  145. if ((D).low == 0xFFFFFFFFUL) {
  146. (D).high = (D).high + 1;
  147. (D).low = 0;
  148. } else {
  149. (D).low = (D).low + 1;
  150. }
  151. }
  152. /***********************************************************
  153. Tests if two dulints are equal. */
  154. #define UT_DULINT_EQ(D1, D2) (((D1).low == (D2).low)
  155. && ((D1).high == (D2).high))
  156. /****************************************************************
  157. Sort function for dulint arrays. */
  158. void
  159. ut_dulint_sort(dulint* arr, dulint* aux_arr, ulint low, ulint high);
  160. /*===============================================================*/
  161. /************************************************************
  162. The following function calculates the value of an integer n rounded
  163. to the least product of align_no which is >= n. align_no has to be a
  164. power of 2. */
  165. UNIV_INLINE
  166. ulint
  167. ut_calc_align(
  168. /*==========*/
  169. /* out: rounded value */
  170. ulint    n,             /* in: number to be rounded */
  171. ulint    align_no);     /* in: align by this number */
  172. /************************************************************
  173. The following function calculates the value of an integer n rounded
  174. to the biggest product of align_no which is <= n. align_no has to be a
  175. power of 2. */
  176. UNIV_INLINE
  177. ulint
  178. ut_calc_align_down(
  179. /*===============*/
  180. /* out: rounded value */
  181. ulint    n,           /* in: number to be rounded */
  182. ulint    align_no); /* in: align by this number */
  183. /*************************************************************
  184. The following function rounds up a pointer to the nearest aligned address. */
  185. UNIV_INLINE
  186. void*
  187. ut_align(
  188. /*=====*/
  189. /* out: aligned pointer */
  190. void*   ptr,            /* in: pointer */
  191. ulint   align_no);      /* in: align by this number */
  192. /*************************************************************
  193. The following function rounds down a pointer to the nearest
  194. aligned address. */
  195. UNIV_INLINE
  196. void*
  197. ut_align_down(
  198. /*==========*/
  199. /* out: aligned pointer */
  200. void*   ptr,            /* in: pointer */
  201. ulint   align_no);      /* in: align by this number */
  202. /*********************************************************************
  203. Gets the nth bit of a ulint. */
  204. UNIV_INLINE
  205. ibool
  206. ut_bit_get_nth(
  207. /*===========*/
  208. /* out: TRUE if nth bit is 1; 0th bit is defined to
  209. be the least significant */
  210. ulint a, /* in: ulint */
  211. ulint n); /* in: nth bit requested */
  212. /*********************************************************************
  213. Sets the nth bit of a ulint. */
  214. UNIV_INLINE
  215. ulint
  216. ut_bit_set_nth(
  217. /*===========*/
  218. /* out: the ulint with the bit set as requested */
  219. ulint a, /* in: ulint */
  220. ulint n, /* in: nth bit requested */
  221. ibool val); /* in: value for the bit to set */
  222. #ifndef UNIV_NONINL
  223. #include "ut0byte.ic"
  224. #endif
  225. #endif