1 /*
2 * Large integer functions
3 *
4 * Copyright 2000 Alexandre Julliard
5 * Copyright 2003 Thomas Mertes
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23
24 #include "ntstatus.h"
25 #define WIN32_NO_STATUS
26 #include "windef.h"
27 #include "winternl.h"
28
29 /*
30 * Note: we use LONGLONG instead of LARGE_INTEGER, because
31 * the latter is a structure and the calling convention for
32 * returning a structure would not be binary-compatible.
33 *
34 * FIXME: for platforms that don't have a native LONGLONG type,
35 * we should define LONGLONG as a structure similar to LARGE_INTEGER
36 * and do everything by hand. You are welcome to do it...
37 */
38
39 /******************************************************************************
40 * RtlLargeIntegerAdd (NTDLL.@)
41 *
42 * Add two 64 bit integers.
43 *
44 * PARAMS
45 * a [I] Initial number.
46 * b [I] Number to add to a.
47 *
48 * RETURNS
49 * The sum of a and b.
50 */
51 LONGLONG WINAPI RtlLargeIntegerAdd( LONGLONG a, LONGLONG b )
52 {
53 return a + b;
54 }
55
56
57 /******************************************************************************
58 * RtlLargeIntegerSubtract (NTDLL.@)
59 *
60 * Subtract two 64 bit integers.
61 *
62 * PARAMS
63 * a [I] Initial number.
64 * b [I] Number to subtract from a.
65 *
66 * RETURNS
67 * The difference of a and b.
68 */
69 LONGLONG WINAPI RtlLargeIntegerSubtract( LONGLONG a, LONGLONG b )
70 {
71 return a - b;
72 }
73
74
75 /******************************************************************************
76 * RtlLargeIntegerNegate (NTDLL.@)
77 *
78 * Negate a 64 bit integer.
79 *
80 * PARAMS
81 * a [I] Initial number.
82 *
83 * RETURNS
84 * The value of a negated.
85 */
86 LONGLONG WINAPI RtlLargeIntegerNegate( LONGLONG a )
87 {
88 return -a;
89 }
90
91
92 /******************************************************************************
93 * RtlLargeIntegerShiftLeft (NTDLL.@)
94 *
95 * Perform a shift left on a 64 bit integer.
96 *
97 * PARAMS
98 * a [I] Initial number.
99 * count [I] Number of bits to shift by
100 *
101 * RETURNS
102 * The value of a following the shift.
103 */
104 LONGLONG WINAPI RtlLargeIntegerShiftLeft( LONGLONG a, INT count )
105 {
106 return a << count;
107 }
108
109
110 /******************************************************************************
111 * RtlLargeIntegerShiftRight (NTDLL.@)
112 *
113 * Perform a shift right on a 64 bit integer.
114 *
115 * PARAMS
116 * a [I] Initial number.
117 * count [I] Number of bits to shift by
118 *
119 * RETURNS
120 * The value of a following the shift.
121 */
122 LONGLONG WINAPI RtlLargeIntegerShiftRight( LONGLONG a, INT count )
123 {
124 return (ULONGLONG)a >> count;
125 }
126
127
128 /******************************************************************************
129 * RtlLargeIntegerArithmeticShift (NTDLL.@)
130 *
131 * Perform an arithmetic shift right on a 64 bit integer.
132 *
133 * PARAMS
134 * a [I] Initial number.
135 * count [I] Number of bits to shift by
136 *
137 * RETURNS
138 * The value of a following the shift.
139 */
140 LONGLONG WINAPI RtlLargeIntegerArithmeticShift( LONGLONG a, INT count )
141 {
142 /* FIXME: gcc does arithmetic shift here, but it may not be true on all platforms */
143 return a >> count;
144 }
145
146
147 /******************************************************************************
148 * RtlLargeIntegerDivide (NTDLL.@)
149 *
150 * Divide one 64 bit unsigned integer by another, with remainder.
151 *
152 * PARAMS
153 * a [I] Initial number.
154 * b [I] Number to divide a by
155 * rem [O] Destination for remainder
156 *
157 * RETURNS
158 * The dividend of a and b. If rem is non-NULL it is set to the remainder.
159 *
160 * FIXME
161 * Should it be signed division instead?
162 */
163 ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG a, ULONGLONG b, ULONGLONG *rem )
164 {
165 ULONGLONG ret = a / b;
166 if (rem) *rem = a - ret * b;
167 return ret;
168 }
169
170
171 /******************************************************************************
172 * RtlConvertLongToLargeInteger (NTDLL.@)
173 *
174 * Convert a 32 bit integer into 64 bits.
175 *
176 * PARAMS
177 * a [I] Number to convert
178 *
179 * RETURNS
180 * a.
181 */
182 LONGLONG WINAPI RtlConvertLongToLargeInteger( LONG a )
183 {
184 return a;
185 }
186
187
188 /******************************************************************************
189 * RtlConvertUlongToLargeInteger (NTDLL.@)
190 *
191 * Convert a 32 bit unsigned integer into 64 bits.
192 *
193 * PARAMS
194 * a [I] Number to convert
195 *
196 * RETURNS
197 * a.
198 */
199 ULONGLONG WINAPI RtlConvertUlongToLargeInteger( ULONG a )
200 {
201 return a;
202 }
203
204
205 /******************************************************************************
206 * RtlEnlargedIntegerMultiply (NTDLL.@)
207 *
208 * Multiply two integers giving a 64 bit integer result.
209 *
210 * PARAMS
211 * a [I] Initial number.
212 * b [I] Number to multiply a by.
213 *
214 * RETURNS
215 * The product of a and b.
216 */
217 LONGLONG WINAPI RtlEnlargedIntegerMultiply( INT a, INT b )
218 {
219 return (LONGLONG)a * b;
220 }
221
222
223 /******************************************************************************
224 * RtlEnlargedUnsignedMultiply (NTDLL.@)
225 *
226 * Multiply two unsigned integers giving a 64 bit unsigned integer result.
227 *
228 * PARAMS
229 * a [I] Initial number.
230 * b [I] Number to multiply a by.
231 *
232 * RETURNS
233 * The product of a and b.
234 */
235 ULONGLONG WINAPI RtlEnlargedUnsignedMultiply( UINT a, UINT b )
236 {
237 return (ULONGLONG)a * b;
238 }
239
240
241 /******************************************************************************
242 * RtlEnlargedUnsignedDivide (NTDLL.@)
243 *
244 * Divide one 64 bit unsigned integer by a 32 bit unsigned integer, with remainder.
245 *
246 * PARAMS
247 * a [I] Initial number.
248 * b [I] Number to divide a by
249 * remptr [O] Destination for remainder
250 *
251 * RETURNS
252 * The dividend of a and b. If remptr is non-NULL it is set to the remainder.
253 */
254 UINT WINAPI RtlEnlargedUnsignedDivide( ULONGLONG a, UINT b, UINT *remptr )
255 {
256 #if defined(__i386__) && defined(__GNUC__)
257 UINT ret, rem, p1, p2;
258
259 p1 = a >> 32;
260 p2 = a & 0xffffffffLL;
261
262 __asm__("div %4,%%eax"
263 : "=a" (ret), "=d" (rem)
264 : "" (p2), "1" (p1), "g" (b) );
265 if (remptr) *remptr = rem;
266 return ret;
267 #else
268 UINT ret = a / b;
269 if (remptr) *remptr = a % b;
270 return ret;
271 #endif
272 }
273
274
275 /******************************************************************************
276 * RtlExtendedLargeIntegerDivide (NTDLL.@)
277 *
278 * Divide one 64 bit integer by a 32 bit integer, with remainder.
279 *
280 * PARAMS
281 * a [I] Initial number.
282 * b [I] Number to divide a by
283 * rem [O] Destination for remainder
284 *
285 * RETURNS
286 * The dividend of a and b. If rem is non-NULL it is set to the remainder.
287 */
288 LONGLONG WINAPI RtlExtendedLargeIntegerDivide( LONGLONG a, INT b, INT *rem )
289 {
290 LONGLONG ret = a / b;
291 if (rem) *rem = a - b * ret;
292 return ret;
293 }
294
295
296 /******************************************************************************
297 * RtlExtendedIntegerMultiply (NTDLL.@)
298 *
299 * Multiply one 64 bit integer by another 32 bit integer.
300 *
301 * PARAMS
302 * a [I] Initial number.
303 * b [I] Number to multiply a by.
304 *
305 * RETURNS
306 * The product of a and b.
307 */
308 LONGLONG WINAPI RtlExtendedIntegerMultiply( LONGLONG a, INT b )
309 {
310 return a * b;
311 }
312
313
314 /******************************************************************************
315 * RtlExtendedMagicDivide (NTDLL.@)
316 *
317 * Allows replacing a division by a longlong constant with a multiplication by
318 * the inverse constant.
319 *
320 * RETURNS
321 * (dividend * inverse_divisor) >> (64 + shift)
322 *
323 * NOTES
324 * If the divisor of a division is constant, the constants inverse_divisor and
325 * shift must be chosen such that inverse_divisor = 2^(64 + shift) / divisor.
326 * Then we have RtlExtendedMagicDivide(dividend,inverse_divisor,shift) ==
327 * dividend * inverse_divisor / 2^(64 + shift) == dividend / divisor.
328 *
329 * The Parameter inverse_divisor although defined as LONGLONG is used as
330 * ULONGLONG.
331 */
332 #define LOWER_32(A) ((A) & 0xffffffff)
333 #define UPPER_32(A) ((A) >> 32)
334 LONGLONG WINAPI RtlExtendedMagicDivide(
335 LONGLONG dividend, /* [I] Dividend to be divided by the constant divisor */
336 LONGLONG inverse_divisor, /* [I] Constant computed manually as 2^(64+shift) / divisor */
337 INT shift) /* [I] Constant shift chosen to make inverse_divisor as big as possible for 64 bits */
338 {
339 ULONGLONG dividend_high;
340 ULONGLONG dividend_low;
341 ULONGLONG inverse_divisor_high;
342 ULONGLONG inverse_divisor_low;
343 ULONGLONG ah_bl;
344 ULONGLONG al_bh;
345 LONGLONG result;
346 int positive;
347
348 if (dividend < 0) {
349 dividend_high = UPPER_32((ULONGLONG) -dividend);
350 dividend_low = LOWER_32((ULONGLONG) -dividend);
351 positive = 0;
352 } else {
353 dividend_high = UPPER_32((ULONGLONG) dividend);
354 dividend_low = LOWER_32((ULONGLONG) dividend);
355 positive = 1;
356 } /* if */
357 inverse_divisor_high = UPPER_32((ULONGLONG) inverse_divisor);
358 inverse_divisor_low = LOWER_32((ULONGLONG) inverse_divisor);
359
360 ah_bl = dividend_high * inverse_divisor_low;
361 al_bh = dividend_low * inverse_divisor_high;
362
363 result = (LONGLONG) ((dividend_high * inverse_divisor_high +
364 UPPER_32(ah_bl) +
365 UPPER_32(al_bh) +
366 UPPER_32(LOWER_32(ah_bl) + LOWER_32(al_bh) +
367 UPPER_32(dividend_low * inverse_divisor_low))) >> shift);
368
369 if (positive) {
370 return result;
371 } else {
372 return -result;
373 } /* if */
374 }
375
376
377 /******************************************************************************
378 * RtlLargeIntegerToChar [NTDLL.@]
379 *
380 * Convert an unsigned large integer to a character string.
381 *
382 * RETURNS
383 * Success: STATUS_SUCCESS. str contains the converted number
384 * Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
385 * STATUS_BUFFER_OVERFLOW, if str would be larger than length.
386 * STATUS_ACCESS_VIOLATION, if str is NULL.
387 *
388 * NOTES
389 * Instead of base 0 it uses 10 as base.
390 * Writes at most length characters to the string str.
391 * Str is '\0' terminated when length allows it.
392 * When str fits exactly in length characters the '\0' is omitted.
393 * If value_ptr is NULL it crashes, as the native function does.
394 *
395 * DIFFERENCES
396 * - Accept base 0 as 10 instead of crashing as native function does.
397 * - The native function does produce garbage or STATUS_BUFFER_OVERFLOW for
398 * base 2, 8 and 16 when the value is larger than 0xFFFFFFFF.
399 */
400 NTSTATUS WINAPI RtlLargeIntegerToChar(
401 const ULONGLONG *value_ptr, /* [I] Pointer to the value to be converted */
402 ULONG base, /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
403 ULONG length, /* [I] Length of the str buffer in bytes */
404 PCHAR str) /* [O] Destination for the converted value */
405 {
406 ULONGLONG value = *value_ptr;
407 CHAR buffer[65];
408 PCHAR pos;
409 CHAR digit;
410 ULONG len;
411
412 if (base == 0) {
413 base = 10;
414 } else if (base != 2 && base != 8 && base != 10 && base != 16) {
415 return STATUS_INVALID_PARAMETER;
416 } /* if */
417
418 pos = &buffer[64];
419 *pos = '\0';
420
421 do {
422 pos--;
423 digit = value % base;
424 value = value / base;
425 if (digit < 10) {
426 *pos = '' + digit;
427 } else {
428 *pos = 'A' + digit - 10;
429 } /* if */
430 } while (value != 0L);
431
432 len = &buffer[64] - pos;
433 if (len > length) {
434 return STATUS_BUFFER_OVERFLOW;
435 } else if (str == NULL) {
436 return STATUS_ACCESS_VIOLATION;
437 } else if (len == length) {
438 memcpy(str, pos, len);
439 } else {
440 memcpy(str, pos, len + 1);
441 } /* if */
442 return STATUS_SUCCESS;
443 }
444
445
446 /**************************************************************************
447 * RtlInt64ToUnicodeString (NTDLL.@)
448 *
449 * Convert a large unsigned integer to a '\0' terminated unicode string.
450 *
451 * RETURNS
452 * Success: STATUS_SUCCESS. str contains the converted number
453 * Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
454 * STATUS_BUFFER_OVERFLOW, if str is too small to hold the string
455 * (with the '\0' termination). In this case str->Length
456 * is set to the length, the string would have (which can
457 * be larger than the MaximumLength).
458 *
459 * NOTES
460 * Instead of base 0 it uses 10 as base.
461 * If str is NULL it crashes, as the native function does.
462 *
463 * DIFFERENCES
464 * - Accept base 0 as 10 instead of crashing as native function does.
465 * - Do not return STATUS_BUFFER_OVERFLOW when the string is long enough.
466 * The native function does this when the string would be longer than 31
467 * characters even when the string parameter is long enough.
468 * - The native function does produce garbage or STATUS_BUFFER_OVERFLOW for
469 * base 2, 8 and 16 when the value is larger than 0xFFFFFFFF.
470 */
471 NTSTATUS WINAPI RtlInt64ToUnicodeString(
472 ULONGLONG value, /* [I] Value to be converted */
473 ULONG base, /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
474 UNICODE_STRING *str) /* [O] Destination for the converted value */
475 {
476 WCHAR buffer[65];
477 PWCHAR pos;
478 WCHAR digit;
479
480 if (base == 0) {
481 base = 10;
482 } else if (base != 2 && base != 8 && base != 10 && base != 16) {
483 return STATUS_INVALID_PARAMETER;
484 } /* if */
485
486 pos = &buffer[64];
487 *pos = '\0';
488
489 do {
490 pos--;
491 digit = value % base;
492 value = value / base;
493 if (digit < 10) {
494 *pos = '' + digit;
495 } else {
496 *pos = 'A' + digit - 10;
497 } /* if */
498 } while (value != 0L);
499
500 str->Length = (&buffer[64] - pos) * sizeof(WCHAR);
501 if (str->Length >= str->MaximumLength) {
502 return STATUS_BUFFER_OVERFLOW;
503 } else {
504 memcpy(str->Buffer, pos, str->Length + sizeof(WCHAR));
505 } /* if */
506 return STATUS_SUCCESS;
507 }
508
509
510 /******************************************************************************
511 * _alldiv (NTDLL.@)
512 *
513 * Divide two 64 bit unsigned integers.
514 *
515 * PARAMS
516 * a [I] Initial number.
517 * b [I] Number to multiply a by.
518 *
519 * RETURNS
520 * The dividend of a and b.
521 */
522 LONGLONG WINAPI _alldiv( LONGLONG a, LONGLONG b )
523 {
524 return a / b;
525 }
526
527
528 /******************************************************************************
529 * _allmul (NTDLL.@)
530 *
531 * Multiply two 64 bit integers.
532 *
533 * PARAMS
534 * a [I] Initial number.
535 * b [I] Number to multiply a by.
536 *
537 * RETURNS
538 * The product of a and b.
539 */
540 LONGLONG WINAPI _allmul( LONGLONG a, LONGLONG b )
541 {
542 return a * b;
543 }
544
545
546 /******************************************************************************
547 * _allrem (NTDLL.@)
548 *
549 * Calculate the remainder after dividing two 64 bit integers.
550 *
551 * PARAMS
552 * a [I] Initial number.
553 * b [I] Number to divide a by.
554 *
555 * RETURNS
556 * The remainder of a divided by b.
557 */
558 LONGLONG WINAPI _allrem( LONGLONG a, LONGLONG b )
559 {
560 return a % b;
561 }
562
563
564 /******************************************************************************
565 * _aulldiv (NTDLL.@)
566 *
567 * Divide two 64 bit unsigned integers.
568 *
569 * PARAMS
570 * a [I] Initial number.
571 * b [I] Number to multiply a by.
572 *
573 * RETURNS
574 * The dividend of a and b.
575 */
576 ULONGLONG WINAPI _aulldiv( ULONGLONG a, ULONGLONG b )
577 {
578 return a / b;
579 }
580
581
582 /******************************************************************************
583 * _aullrem (NTDLL.@)
584 *
585 * Calculate the remainder after dividing two 64 bit unsigned integers.
586 *
587 * PARAMS
588 * a [I] Initial number.
589 * b [I] Number to divide a by.
590 *
591 * RETURNS
592 * The remainder of a divided by b.
593 */
594 ULONGLONG WINAPI _aullrem( ULONGLONG a, ULONGLONG b )
595 {
596 return a % b;
597 }
598
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.