Index: ossp-pkg/uuid/Makefile.in RCS File: /v/ossp/cvs/ossp-pkg/uuid/Attic/Makefile.in,v rcsdiff -q -kk '-r1.2' '-r1.3' -u '/v/ossp/cvs/ossp-pkg/uuid/Attic/Makefile.in,v' 2>/dev/null --- Makefile.in 2004/01/06 20:20:12 1.2 +++ Makefile.in 2004/01/09 11:32:06 1.3 @@ -50,7 +50,7 @@ POD2MAN = pod2man LIB_NAME = libuuid.la -LIB_OBJS = uuid.lo +LIB_OBJS = uuid.lo uuid_ui64.lo PRG_NAME = uuid PRG_OBJS = uuid_cli.o Index: ossp-pkg/uuid/uuid.c RCS File: /v/ossp/cvs/ossp-pkg/uuid/Attic/uuid.c,v rcsdiff -q -kk '-r1.5' '-r1.6' -u '/v/ossp/cvs/ossp-pkg/uuid/Attic/uuid.c,v' 2>/dev/null --- uuid.c 2004/01/09 11:28:56 1.5 +++ uuid.c 2004/01/09 11:32:06 1.6 @@ -36,6 +36,7 @@ #include "config.h" #include "uuid.h" +#include "uuid_ui64.h" /* determine types of 8-bit size */ #if SIZEOF_CHAR == 1 Index: ossp-pkg/uuid/uuid_ui64.c RCS File: /v/ossp/cvs/ossp-pkg/uuid/Attic/uuid_ui64.c,v co -q -kk -p'1.1' '/v/ossp/cvs/ossp-pkg/uuid/Attic/uuid_ui64.c,v' | diff -u /dev/null - -L'ossp-pkg/uuid/uuid_ui64.c' 2>/dev/null --- ossp-pkg/uuid/uuid_ui64.c +++ - 2024-05-17 08:20:03.419694994 +0200 @@ -0,0 +1,582 @@ +/* +** OSSP ui64 - 64-Bit Arithmetic +** Copyright (c) 2002-2004 Ralf S. Engelschall +** Copyright (c) 2002-2004 The OSSP Project +** +** This file is part of OSSP ui64, a 64-bit arithmetic library +** which can be found at http://www.ossp.org/pkg/lib/ui64/. +** +** Permission to use, copy, modify, and distribute this software for +** any purpose with or without fee is hereby granted, provided that +** the above copyright notice and this permission notice appear in all +** copies. +** +** THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED +** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +** MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +** IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR +** CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +** USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +** OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +** SUCH DAMAGE. +** +** ui64.c: implementation of 64-bit unsigned integer arithmetic +*/ + +#include +#include + +#include "uuid_ui64.h" + +#define UI64_BASE 256 /* 2^8 */ +#define UI64_DIGITS 8 /* 8*8 = 64 bit */ +#define UIXX_T(n) struct { unsigned char x[n]; } + +/* fill an ui64_t with a sequence of a particular digit */ +#define ui64_fill(__x, __n) \ + do { int __i; \ + for (__i = 0; __i < UI64_DIGITS; __i++) \ + (__x).x[__i] = (__n); \ + } while(0) + +/* the value zero */ +ui64_t ui64_zero(void) +{ + ui64_t z; + + ui64_fill(z, 0); + return z; +} + +/* the maximum value */ +ui64_t ui64_max(void) +{ + ui64_t z; + + ui64_fill(z, UI64_BASE-1); + return z; +} + +/* convert ISO-C "unsigned long" into internal format */ +ui64_t ui64_n2i(unsigned long n) +{ + ui64_t z; + int i; + + i = 0; + do { + z.x[i++] = (n % UI64_BASE); + } while ((n /= UI64_BASE) > 0 && i < UI64_DIGITS); + for ( ; i < UI64_DIGITS; i++) + z.x[i] = 0; + return z; +} + +/* convert internal format into ISO-C "unsigned long"; + truncates if sizeof(unsigned long) is less than UI64_DIGITS! */ +unsigned long ui64_i2n(ui64_t x) +{ + unsigned long n; + int i; + + n = 0; + i = (int)sizeof(n); + if (i > UI64_DIGITS) + i = UI64_DIGITS; + while (--i >= 0) { + n = (n * UI64_BASE) + x.x[i]; + } + return n; +} + +/* convert string representation of arbitrary base into internal format */ +ui64_t ui64_s2i(const char *str, char **end, int base) +{ + ui64_t z; + const char *cp; + int carry; + static char map[] = { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, /* 0...9 */ + 36, 36, 36, 36, 36, 36, 36, /* illegal chars */ + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, /* A...M */ + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, /* N...Z */ + 36, 36, 36, 36, 36, 36, /* illegal chars */ + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, /* a...m */ + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35 /* m...z */ + }; + + ui64_fill(z, 0); + if (str == NULL || (base < 2 || base > 36)) + return z; + cp = str; + while (*cp != '\0' && isspace((int)(*cp))) + cp++; + while ( *cp != '\0' + && isalnum((int)(*cp)) + && map[(int)(*cp)-'0'] < base) { + z = ui64_muln(z, base, &carry); + if (carry) + break; + z = ui64_addn(z, map[(int)(*cp)-'0'], &carry); + if (carry) + break; + cp++; + } + if (end != NULL) + *end = (char *)cp; + return z; +} + +/* convert internal format into string representation of arbitrary base */ +char *ui64_i2s(ui64_t x, char *str, size_t len, int base) +{ + static char map[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + char c; + int r; + int n; + int i, j; + + if (str == NULL || len < 2 || (base < 2 || base > 36)) + return NULL; + n = ui64_len(x); + i = 0; + do { + x = ui64_divn(x, base, &r); + str[i++] = map[r]; + while (n > 1 && x.x[n-1] == 0) + n--; + } while (i < (len-1) && (n > 1 || x.x[0] != 0)); + str[i] = '\0'; + for (j = 0; j < --i; j++) { + c = str[j]; + str[j] = str[i]; + str[i] = c; + } + return str; +} + +/* addition of two ui64_t */ +ui64_t ui64_add(ui64_t x, ui64_t y, ui64_t *ov) +{ + ui64_t z; + int carry; + int i; + + carry = 0; + for (i = 0; i < UI64_DIGITS; i++) { + carry += (x.x[i] + y.x[i]); + z.x[i] = (carry % UI64_BASE); + carry /= UI64_BASE; + } + if (ov != NULL) + *ov = ui64_n2i((unsigned long)carry); + return z; +} + +/* addition of an ui64_t and a single digit */ +ui64_t ui64_addn(ui64_t x, int y, int *ov) +{ + ui64_t z; + int i; + + for (i = 0; i < UI64_DIGITS; i++) { + y += x.x[i]; + z.x[i] = (y % UI64_BASE); + y /= UI64_BASE; + } + if (ov != NULL) + *ov = y; + return z; +} + +/* subtraction of two ui64_t */ +ui64_t ui64_sub(ui64_t x, ui64_t y, ui64_t *ov) +{ + ui64_t z; + int borrow; + int i; + int d; + + borrow = 0; + for (i = 0; i < UI64_DIGITS; i++) { + d = ((x.x[i] + UI64_BASE) - borrow - y.x[i]); + z.x[i] = (d % UI64_BASE); + borrow = (1 - (d/UI64_BASE)); + } + if (ov != NULL) + *ov = ui64_n2i((unsigned long)borrow); + return z; +} + +/* subtraction of an ui64_t and a single digit */ +ui64_t ui64_subn(ui64_t x, int y, int *ov) +{ + ui64_t z; + int i; + int d; + + for (i = 0; i < UI64_DIGITS; i++) { + d = (x.x[i] + UI64_BASE) - y; + z.x[i] = (d % UI64_BASE); + y = (1 - (d/UI64_BASE)); + } + if (ov != NULL) + *ov = y; + return z; +} + +/* + 7 3 2 + * 9 4 2 8 + --------- + 5 8 5 6 + + 1 4 6 4 + + 2 9 2 8 + + 6 5 8 8 + --------------- + = 6 9 0 1 2 9 6 +*/ + +ui64_t ui64_mul(ui64_t x, ui64_t y, ui64_t *ov) +{ + UIXX_T(UI64_DIGITS+UI64_DIGITS) zx; + ui64_t z; + int carry; + int i, j; + + /* clear temporary result buffer */ + for (i = 0; i < (UI64_DIGITS+UI64_DIGITS); i++) + zx.x[i] = 0; + + /* perform multiplication operation */ + for (i = 0; i < UI64_DIGITS; i++) { + /* calculate partial product and immediately add to z */ + carry = 0; + for (j = 0; j < UI64_DIGITS; j++) { + carry += (x.x[i] * y.x[j]) + zx.x[i+j]; + zx.x[i+j] = (carry % UI64_BASE); + carry /= UI64_BASE; + } + /* add carry to remaining digits in z */ + for ( ; j < UI64_DIGITS + UI64_DIGITS - i; j++) { + carry += zx.x[i+j]; + zx.x[i+j] = (carry % UI64_BASE); + carry /= UI64_BASE; + } + } + + /* provide result by splitting zx into z and ov */ + memcpy(z.x, zx.x, UI64_DIGITS); + if (ov != NULL) + memcpy((*ov).x, &zx.x[UI64_DIGITS], UI64_DIGITS); + + return z; +} + +ui64_t ui64_muln(ui64_t x, int y, int *ov) +{ + ui64_t z; + int carry; + int i; + + carry = 0; + for (i = 0; i < UI64_DIGITS; i++) { + carry += (x.x[i] * y); + z.x[i] = (carry % UI64_BASE); + carry /= UI64_BASE; + } + if (ov != NULL) + *ov = carry; + return z; +} + +/* + = 2078 [q] + 0615367 [x] : 296 [y] + -0592 [dq] + ----- + = 0233 + -0000 [dq] + ----- + = 2336 + -2072 [dq] + ----- + = 2647 + -2308 [dq] + ----- + = 279 [r] + */ +ui64_t ui64_div(ui64_t x, ui64_t y, ui64_t *ov) +{ + ui64_t q; + ui64_t r; + int i; + int n, m; + int ovn; + + /* determine actual number of involved digits */ + n = ui64_len(x); + m = ui64_len(y); + + if (m == 1) { + /* simple case #1: reduceable to ui64_divn() */ + if (y.x[0] == 0) { + /* error case: division by zero! */ + ui64_fill(q, 0); + ui64_fill(r, 0); + } + else { + q = ui64_divn(x, y.x[0], &ovn); + ui64_fill(r, 0); + r.x[0] = (unsigned char)ovn; + } + + } else if (n < m) { + /* simple case #2: everything is in the remainder */ + ui64_fill(q, 0); + r = x; + + } else { /* n >= m, m > 1 */ + /* standard case: x[0..n] / y[0..m] */ + UIXX_T(UI64_DIGITS+1) rx; + UIXX_T(UI64_DIGITS+1) dq; + ui64_t t; + int km; + int k; + int qk; + unsigned long y2; + unsigned long r3; + int borrow; + int d; + + /* rx is x with a leading zero in order to make + sure that n > m and not just n >= m */ + memcpy(rx.x, x.x, UI64_DIGITS); + rx.x[UI64_DIGITS] = 0; + + for (k = n - m; k >= 0; k--) { + /* efficiently compute qk by guessing + qk := rx[k+m-2...k+m]/y[m-2...m-1] */ + km = k + m; + y2 = (y.x[m-1]*UI64_BASE) + y.x[m-2]; + r3 = (rx.x[km]*(UI64_BASE*UI64_BASE)) + + (rx.x[km-1]*UI64_BASE) + rx.x[km-2]; + qk = r3 / y2; + if (qk >= UI64_BASE) + qk = UI64_BASE - 1; + + /* dq := y*qk (post-adjust qk if guessed incorrectly) */ + t = ui64_muln(y, qk, &ovn); + memcpy(dq.x, t.x, UI64_DIGITS); + dq.x[m] = (unsigned char)ovn; + for (i = m; i > 0; i--) + if (rx.x[i+k] != dq.x[i]) + break; + if (rx.x[i+k] < dq.x[i]) { + t = ui64_muln(y, --qk, &ovn); + memcpy(dq.x, t.x, UI64_DIGITS); + dq.x[m] = (unsigned char)ovn; + } + + /* store qk */ + q.x[k] = (unsigned char)qk; + + /* rx := rx - dq*(b^k) */ + borrow = 0; + for (i = 0; i < m+1; i++) { + d = ((rx.x[k+i] + UI64_BASE) - borrow - dq.x[i]); + rx.x[k+i] = (d % UI64_BASE); + borrow = (1 - (d/UI64_BASE)); + } + } + memcpy(r.x, rx.x, m); + + /* fill out results with leading zeros */ + for (i = n-m+1; i < UI64_DIGITS; i++) + q.x[i] = 0; + for (i = m; i < UI64_DIGITS; i++) + r.x[i] = 0; + } + + /* provide results */ + if (ov != NULL) + *ov = r; + return q; +} + +ui64_t ui64_divn(ui64_t x, int y, int *ov) +{ + ui64_t z; + unsigned int carry; + int i; + + carry = 0; + for (i = (UI64_DIGITS - 1); i >= 0; i--) { + carry = (carry * UI64_BASE) + x.x[i]; + z.x[i] = (carry / y); + carry %= y; + } + if (ov != NULL) + *ov = carry; + return z; +} + +ui64_t ui64_and(ui64_t x, ui64_t y) +{ + ui64_t z; + int i; + + for (i = 0; i < UI64_DIGITS; i++) + z.x[i] = (x.x[i] & y.x[i]); + return z; +} + +ui64_t ui64_or(ui64_t x, ui64_t y) +{ + ui64_t z; + int i; + + for (i = 0; i < UI64_DIGITS; i++) + z.x[i] = (x.x[i] | y.x[i]); + return z; +} + +ui64_t ui64_xor(ui64_t x, ui64_t y) +{ + ui64_t z; + int i; + + for (i = 0; i < UI64_DIGITS; i++) + z.x[i] = ((x.x[i] & ~(y.x[i])) | (~(x.x[i]) & (y.x[i]))); + return z; +} + +ui64_t ui64_not(ui64_t x) +{ + ui64_t z; + int i; + + for (i = 0; i < UI64_DIGITS; i++) + z.x[i] = ~(x.x[i]); + return z; +} + +ui64_t ui64_rol(ui64_t x, int s, ui64_t *ov) +{ + UIXX_T(UI64_DIGITS+UI64_DIGITS) zx; + ui64_t z; + int i; + int carry; + + if (s <= 0) { + /* no shift at all */ + if (ov != NULL) + *ov = ui64_zero(); + return x; + } + else if (s > 64) { + /* too large shift */ + if (ov != NULL) + *ov = ui64_zero(); + return ui64_zero(); + } + else if (s == 64) { + /* maximum shift */ + if (ov != NULL) + *ov = x; + return ui64_zero(); + } + else { /* regular shift */ + /* shift (logically) left by s/8 bytes */ + for (i = 0; i < UI64_DIGITS+UI64_DIGITS; i++) + zx.x[i] = 0; + for (i = 0; i < UI64_DIGITS; i++) + zx.x[i+(s/8)] = x.x[i]; + /* shift (logically) left by remaining s%8 bits */ + s %= 8; + if (s > 0) { + carry = 0; + for (i = 0; i < UI64_DIGITS+UI64_DIGITS; i++) { + carry += (zx.x[i] * (1 << s)); + zx.x[i] = (carry % UI64_BASE); + carry /= UI64_BASE; + } + } + memcpy(z.x, zx.x, UI64_DIGITS); + if (ov != NULL) + memcpy((*ov).x, &zx.x[UI64_DIGITS], UI64_DIGITS); + } + return z; +} + +ui64_t ui64_ror(ui64_t x, int s, ui64_t *ov) +{ + UIXX_T(UI64_DIGITS+UI64_DIGITS) zx; + ui64_t z; + int i; + int carry; + + if (s <= 0) { + /* no shift at all */ + if (ov != NULL) + *ov = ui64_zero(); + return x; + } + else if (s > 64) { + /* too large shift */ + if (ov != NULL) + *ov = ui64_zero(); + return ui64_zero(); + } + else if (s == 64) { + /* maximum shift */ + if (ov != NULL) + *ov = x; + return ui64_zero(); + } + else { /* regular shift */ + /* shift (logically) right by s/8 bytes */ + for (i = 0; i < UI64_DIGITS+UI64_DIGITS; i++) + zx.x[i] = 0; + for (i = 0; i < UI64_DIGITS; i++) + zx.x[UI64_DIGITS+i-(s/8)] = x.x[i]; + /* shift (logically) right by remaining s%8 bits */ + s %= 8; + if (s > 0) { + carry = 0; + for (i = (UI64_DIGITS+UI64_DIGITS - 1); i >= 0; i--) { + carry = (carry * UI64_BASE) + zx.x[i]; + zx.x[i] = (carry / (1 << s)); + carry %= (1 << s); + } + } + memcpy(z.x, &zx.x[UI64_DIGITS], UI64_DIGITS); + if (ov != NULL) + memcpy((*ov).x, zx.x, UI64_DIGITS); + } + return z; +} + +int ui64_cmp(ui64_t x, ui64_t y) +{ + int i; + + i = UI64_DIGITS - 1; + while (i > 0 && x.x[i] == y.x[i]) + i--; + return (x.x[i] - y.x[i]); +} + +int ui64_len(ui64_t x) +{ + int i; + + for (i = UI64_DIGITS; i > 1 && x.x[i-1] == 0; i--) + ; + return i; +} + Index: ossp-pkg/uuid/uuid_ui64.h RCS File: /v/ossp/cvs/ossp-pkg/uuid/Attic/uuid_ui64.h,v co -q -kk -p'1.1' '/v/ossp/cvs/ossp-pkg/uuid/Attic/uuid_ui64.h,v' | diff -u /dev/null - -L'ossp-pkg/uuid/uuid_ui64.h' 2>/dev/null --- ossp-pkg/uuid/uuid_ui64.h +++ - 2024-05-17 08:20:03.422547300 +0200 @@ -0,0 +1,113 @@ +/* +** OSSP ui64 - 64-Bit Arithmetic +** Copyright (c) 2002-2004 Ralf S. Engelschall +** Copyright (c) 2002-2004 The OSSP Project +** +** This file is part of OSSP ui64, a 64-bit arithmetic library +** which can be found at http://www.ossp.org/pkg/lib/ui64/. +** +** Permission to use, copy, modify, and distribute this software for +** any purpose with or without fee is hereby granted, provided that +** the above copyright notice and this permission notice appear in all +** copies. +** +** THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED +** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +** MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +** IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR +** CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +** USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +** OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +** SUCH DAMAGE. +** +** ui64.h: API declaration +*/ + +#ifndef __UI64_H__ +#define __UI64_H__ + +#include + +#define UI64_PREFIX uuid_ + +/* embedding support */ +#ifdef UI64_PREFIX +#if defined(__STDC__) || defined(__cplusplus) +#define __UI64_CONCAT(x,y) x ## y +#define UI64_CONCAT(x,y) __UI64_CONCAT(x,y) +#else +#define __UI64_CONCAT(x) x +#define UI64_CONCAT(x,y) __UI64_CONCAT(x)y +#endif +#define ui64_t UI64_CONCAT(UI64_PREFIX,ui64_t) +#define ui64_zero UI64_CONCAT(UI64_PREFIX,ui64_zero) +#define ui64_max UI64_CONCAT(UI64_PREFIX,ui64_max) +#define ui64_n2i UI64_CONCAT(UI64_PREFIX,ui64_n2i) +#define ui64_i2n UI64_CONCAT(UI64_PREFIX,ui64_i2n) +#define ui64_s2i UI64_CONCAT(UI64_PREFIX,ui64_s2i) +#define ui64_i2s UI64_CONCAT(UI64_PREFIX,ui64_i2s) +#define ui64_add UI64_CONCAT(UI64_PREFIX,ui64_add) +#define ui64_addn UI64_CONCAT(UI64_PREFIX,ui64_addn) +#define ui64_sub UI64_CONCAT(UI64_PREFIX,ui64_sub) +#define ui64_subn UI64_CONCAT(UI64_PREFIX,ui64_subn) +#define ui64_mul UI64_CONCAT(UI64_PREFIX,ui64_mul) +#define ui64_muln UI64_CONCAT(UI64_PREFIX,ui64_muln) +#define ui64_div UI64_CONCAT(UI64_PREFIX,ui64_div) +#define ui64_divn UI64_CONCAT(UI64_PREFIX,ui64_divn) +#define ui64_and UI64_CONCAT(UI64_PREFIX,ui64_and) +#define ui64_or UI64_CONCAT(UI64_PREFIX,ui64_or) +#define ui64_xor UI64_CONCAT(UI64_PREFIX,ui64_xor) +#define ui64_not UI64_CONCAT(UI64_PREFIX,ui64_not) +#define ui64_rol UI64_CONCAT(UI64_PREFIX,ui64_rol) +#define ui64_ror UI64_CONCAT(UI64_PREFIX,ui64_ror) +#define ui64_len UI64_CONCAT(UI64_PREFIX,ui64_len) +#define ui64_cmp UI64_CONCAT(UI64_PREFIX,ui64_cmp) +#endif + +typedef struct { + unsigned char x[8]; /* x_0, ..., x_7 */ +} ui64_t; + +#define ui64_cons(x7,x6,x5,x4,x3,x2,x1,x0) \ + { { 0x##x0, 0x##x1, 0x##x2, 0x##x3, 0x##x4, 0x##x5, 0x##x6, 0x##x7 } } + +/* particular values */ +extern ui64_t ui64_zero (void); +extern ui64_t ui64_max (void); + +/* import and export via ISO-C "unsigned long" */ +extern ui64_t ui64_n2i (unsigned long n); +extern unsigned long ui64_i2n (ui64_t x); + +/* import and export via ISO-C string of arbitrary base */ +extern ui64_t ui64_s2i (const char *str, char **end, int base); +extern char * ui64_i2s (ui64_t x, char *str, size_t len, int base); + +/* arithmetical operations */ +extern ui64_t ui64_add (ui64_t x, ui64_t y, ui64_t *ov); +extern ui64_t ui64_addn (ui64_t x, int y, int *ov); +extern ui64_t ui64_sub (ui64_t x, ui64_t y, ui64_t *ov); +extern ui64_t ui64_subn (ui64_t x, int y, int *ov); +extern ui64_t ui64_mul (ui64_t x, ui64_t y, ui64_t *ov); +extern ui64_t ui64_muln (ui64_t x, int y, int *ov); +extern ui64_t ui64_div (ui64_t x, ui64_t y, ui64_t *ov); +extern ui64_t ui64_divn (ui64_t x, int y, int *ov); + +/* bit operations */ +extern ui64_t ui64_and (ui64_t x, ui64_t y); +extern ui64_t ui64_or (ui64_t x, ui64_t y); +extern ui64_t ui64_xor (ui64_t x, ui64_t y); +extern ui64_t ui64_not (ui64_t x); +extern ui64_t ui64_rol (ui64_t x, int s, ui64_t *ov); +extern ui64_t ui64_ror (ui64_t x, int s, ui64_t *ov); + +/* other operations */ +extern int ui64_len (ui64_t x); +extern int ui64_cmp (ui64_t x, ui64_t y); + +#endif /* __UI64_H__ */ +