encounter
/
MWCC
mirror of https://git.wuffs.org/MWCC
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
MWCC/CInt64.c

894 lines
20 KiB
C
Raw Blame History

#include <MacHeadersMach-O>
#include "CInt64.h"
const CInt64 cint64_negone = {0xFFFFFFFF, 0xFFFFFFFF};
const CInt64 cint64_zero = {0, 0};
const CInt64 cint64_one = {0, 1};
const CInt64 cint64_max = {0x7FFFFFFF, 0xFFFFFFFF};
const CInt64 cint64_min = {0x80000000, 0};
#define SHIFT_LEFT_ONE(a, b) do { a <<= 1; if (b & 0x80000000) { a |= 1; } b <<= 1; } while(0)
void CInt64_Init() {
}
CInt64 CInt64_Not(CInt64 input) {
CInt64 output;
unsigned char c;
c = (input.a == 0 && input.b == 0);
CInt64_SetLong(&output, c);
return output;
}
CInt64 CInt64_Inv(CInt64 input) {
CInt64 output;
output.a = ~input.a;
output.b = ~input.b;
return output;
}
CInt64 CInt64_Add(CInt64 lhs, CInt64 rhs) {
if (lhs.b & 0x80000000) {
if (rhs.b & 0x80000000) {
lhs.b += rhs.b;
lhs.a += 1;
} else {
lhs.b += rhs.b;
if (!(lhs.b & 0x80000000))
lhs.a += 1;
}
} else {
if (rhs.b & 0x80000000) {
lhs.b += rhs.b;
if (!(lhs.b & 0x80000000))
lhs.a += 1;
} else {
lhs.b += rhs.b;
}
}
lhs.a += rhs.a;
return lhs;
}
CInt64 CInt64_Neg(CInt64 input) {
CInt64 result;
result = CInt64_Add(CInt64_Inv(input), cint64_one);
return result;
}
CInt64 CInt64_Sub(CInt64 lhs, CInt64 rhs) {
lhs = CInt64_Add(lhs, CInt64_Neg(rhs));
return lhs;
}
CInt64 CInt64_MulU(CInt64 lhs, CInt64 rhs) {
CInt64 result;
CInt64 work1;
unsigned long aaaa;
unsigned long bbbb;
unsigned long cccc;
unsigned long dddd;
unsigned long eeee;
aaaa = rhs.b;
result.a = result.b = 0;
bbbb = lhs.b;
cccc = rhs.a;
dddd = rhs.b;
while (bbbb != 0) {
if (bbbb & 1) {
work1.a = cccc;
work1.b = dddd;
result = CInt64_Add(result, work1);
}
cccc <<= 1;
if (dddd & 0x80000000)
cccc |= 1;
dddd <<= 1;
bbbb >>= 1;
}
eeee = lhs.a;
while (eeee != 0 && aaaa != 0) {
if (eeee & 1)
result.a += aaaa;
aaaa <<= 1;
eeee >>= 1;
}
return result;
}
CInt64 CInt64_Mul(CInt64 lhs, CInt64 rhs) {
if (CInt64_IsNegative(&rhs)) {
if (CInt64_IsNegative(&lhs)) {
return CInt64_MulU(CInt64_Neg(lhs), CInt64_Neg(rhs));
}
return CInt64_Neg(CInt64_MulU(lhs, CInt64_Neg(rhs)));
}
if (CInt64_IsNegative(&lhs)) {
return CInt64_Neg(CInt64_MulU(CInt64_Neg(lhs), rhs));
}
return CInt64_MulU(lhs, rhs);
}
void CInt64_DivMod(const CInt64 *lhs, const CInt64 *rhs, CInt64 *pDiv, CInt64 *pMod) {
unsigned char bad;
unsigned long workA;
unsigned long workB;
unsigned long leftA;
unsigned long leftB;
unsigned long rightA;
unsigned long rightB;
unsigned long outA;
unsigned long outB;
CInt64 work;
int counter;
bad = (rhs->a == 0) && (rhs->b == 0);
if (!bad) {
workA = 0;
workB = 0;
leftA = lhs->a;
leftB = lhs->b;
rightA = rhs->a;
rightB = rhs->b;
outA = 0;
outB = 0;
counter = 0;
do {
workA <<= 1;
if (workB & 0x80000000)
workA |= 1;
workB <<= 1;
if (leftA & 0x80000000)
workB |= 1;
leftA <<= 1;
if (leftB & 0x80000000)
leftA |= 1;
leftB <<= 1;
outA <<= 1;
if (outB & 0x80000000)
outA |= 1;
outB <<= 1;
if (workA <= rightA) {
if (workA != rightA)
continue;
if (workB < rightB)
continue;
}
outB |= 1;
work.a = workA;
work.b = workB;
work = CInt64_Sub(work, *rhs);
workA = work.a;
workB = work.b;
} while (++counter < 64);
if (pDiv) {
pDiv->a = outA;
pDiv->b = outB;
}
if (pMod) {
pMod->a = workA;
pMod->b = workB;
}
}
}
CInt64 CInt64_Div(CInt64 lhs, CInt64 rhs) {
CInt64 result;
if (CInt64_IsNegative(&rhs)) {
rhs = CInt64_Neg(rhs);
if (CInt64_IsNegative(&lhs)) {
lhs = CInt64_Neg(lhs);
CInt64_DivMod(&lhs, &rhs, &result, 0);
return result;
} else {
CInt64_DivMod(&lhs, &rhs, &result, 0);
return CInt64_Neg(result);
}
} else {
if (CInt64_IsNegative(&lhs)) {
lhs = CInt64_Neg(lhs);
CInt64_DivMod(&lhs, &rhs, &result, 0);
return CInt64_Neg(result);
} else {
CInt64_DivMod(&lhs, &rhs, &result, 0);
return result;
}
}
}
CInt64 CInt64_DivU(CInt64 lhs, CInt64 rhs) {
CInt64 result;
CInt64_DivMod(&lhs, &rhs, &result, 0);
return result;
}
CInt64 CInt64_Mod(CInt64 lhs, CInt64 rhs) {
CInt64 result;
if (CInt64_IsNegative(&lhs)) {
lhs = CInt64_Neg(lhs);
if (CInt64_IsNegative(&rhs))
rhs = CInt64_Neg(rhs);
CInt64_DivMod(&lhs, &rhs, 0, &result);
return CInt64_Neg(result);
} else {
if (CInt64_IsNegative(&rhs))
rhs = CInt64_Neg(rhs);
CInt64_DivMod(&lhs, &rhs, 0, &result);
return result;
}
}
CInt64 CInt64_ModU(CInt64 lhs, CInt64 rhs) {
CInt64 result;
CInt64_DivMod(&lhs, &rhs, 0, &result);
return result;
}
CInt64 CInt64_Shl(CInt64 lhs, CInt64 rhs) {
int counter;
unsigned long a;
unsigned long b;
if (rhs.a == 0 && rhs.b < 64) {
a = lhs.a;
b = lhs.b;
for (counter = rhs.b; counter != 0; --counter) {
a <<= 1;
if (b & 0x80000000)
a |= 1;
b <<= 1;
}
lhs.a = a;
lhs.b = b;
} else {
lhs.a = 0;
lhs.b = 0;
}
return lhs;
}
CInt64 CInt64_Shr(CInt64 lhs, CInt64 rhs) {
int counter;
long a;
unsigned long b;
if (rhs.a == 0 && rhs.b < 64) {
a = lhs.a;
b = lhs.b;
for (counter = rhs.b; counter != 0; --counter) {
b >>= 1;
if (a & 1)
b |= 0x80000000;
a >>= 1;
}
lhs.a = a;
lhs.b = b;
} else {
if (lhs.a & 0x80000000) {
lhs.a = 0xFFFFFFFF;
lhs.b = 0xFFFFFFFF;
} else {
lhs.a = 0;
lhs.b = 0;
}
}
return lhs;
}
CInt64 CInt64_ShrU(CInt64 lhs, CInt64 rhs) {
int counter;
unsigned long a;
unsigned long b;
if (rhs.a == 0 && rhs.b < 64) {
a = lhs.a;
b = lhs.b;
for (counter = rhs.b; counter != 0; --counter) {
b >>= 1;
if (a & 1)
b |= 0x80000000;
a >>= 1;
}
lhs.a = a;
lhs.b = b;
} else {
lhs.a = 0;
lhs.b = 0;
}
return lhs;
}
int CInt64_UnsignedCompare(const CInt64 *lhs, const CInt64 *rhs) {
if (lhs->a == rhs->a) {
if (lhs->b < rhs->b)
return -1;
else
return lhs->b > rhs->b;
} else {
return ((unsigned long) lhs->a < rhs->a) ? -1 : 1;
}
}
int CInt64_SignedCompare(const CInt64 *lhs, const CInt64 *rhs) {
CInt64 lhs_;
CInt64 rhs_;
lhs_ = CInt64_Xor(*lhs, cint64_min);
rhs_ = CInt64_Xor(*rhs, cint64_min);
return CInt64_UnsignedCompare(&lhs_, &rhs_);
}
unsigned char CInt64_Less(CInt64 lhs, CInt64 rhs) {
return CInt64_SignedCompare(&lhs, &rhs) < 0;
}
unsigned char CInt64_LessU(CInt64 lhs, CInt64 rhs) {
return CInt64_UnsignedCompare(&lhs, &rhs) < 0;
}
unsigned char CInt64_Greater(CInt64 lhs, CInt64 rhs) {
return CInt64_SignedCompare(&lhs, &rhs) > 0;
}
unsigned char CInt64_GreaterU(CInt64 lhs, CInt64 rhs) {
return CInt64_UnsignedCompare(&lhs, &rhs) > 0;
}
unsigned char CInt64_LessEqual(CInt64 lhs, CInt64 rhs) {
return CInt64_SignedCompare(&lhs, &rhs) <= 0;
}
unsigned char CInt64_LessEqualU(CInt64 lhs, CInt64 rhs) {
return CInt64_UnsignedCompare(&lhs, &rhs) <= 0;
}
unsigned char CInt64_GreaterEqual(CInt64 lhs, CInt64 rhs) {
return CInt64_SignedCompare(&lhs, &rhs) >= 0;
}
unsigned char CInt64_GreaterEqualU(CInt64 lhs, CInt64 rhs) {
return CInt64_UnsignedCompare(&lhs, &rhs) >= 0;
}
unsigned char CInt64_Equal(CInt64 lhs, CInt64 rhs) {
return lhs.a == rhs.a && lhs.b == rhs.b;
}
unsigned char CInt64_NotEqual(CInt64 lhs, CInt64 rhs) {
return lhs.a != rhs.a || lhs.b != rhs.b;
}
unsigned char CInt64_IsInRange(CInt64 value, short len) {
CInt64 bound;
if (value.a & 0x80000000) {
switch (len) {
case 1:
bound.b = 0xFFFFFF80;
bound.a = 0xFFFFFFFF;
break;
case 2:
bound.b = 0xFFFF8000;
bound.a = 0xFFFFFFFF;
break;
case 4:
bound.b = 0x80000000;
bound.a = 0xFFFFFFFF;
break;
case 8:
return 1;
default:
return 0;
}
return CInt64_GreaterEqual(value, bound);
} else {
switch (len) {
case 1:
bound.b = 0x7F;
bound.a = 0;
break;
case 2:
bound.b = 0x7FFF;
bound.a = 0;
break;
case 4:
bound.b = 0x7FFFFFFF;
bound.a = 0;
break;
case 8:
return 1;
default:
return 0;
}
return CInt64_LessEqual(value, bound);
}
}
unsigned char CInt64_IsInURange(CInt64 value, short len) {
switch (len) {
case 1:
return value.a == 0 && (value.b & 0xFFFFFF00) == 0;
case 2:
return value.a == 0 && (value.b & 0xFFFF0000) == 0;
case 4:
return value.a == 0;
case 8:
return 1;
default:
return 0;
}
}
CInt64 CInt64_And(CInt64 lhs, CInt64 rhs) {
lhs.a &= rhs.a;
lhs.b &= rhs.b;
return lhs;
}
CInt64 CInt64_Xor(CInt64 lhs, CInt64 rhs) {
lhs.a ^= rhs.a;
lhs.b ^= rhs.b;
return lhs;
}
CInt64 CInt64_Or(CInt64 lhs, CInt64 rhs) {
lhs.a |= rhs.a;
lhs.b |= rhs.b;
return lhs;
}
void CInt64_ConvertInt32(CInt64 *i) {
CInt64_Extend32(i);
}
void CInt64_ConvertUInt32(CInt64 *i) {
CInt64_SetULong(i, (unsigned long) i->b);
}
void CInt64_ConvertInt16(CInt64 *i) {
i->b = (short) i->b;
CInt64_Extend32(i);
}
void CInt64_ConvertUInt16(CInt64 *i) {
CInt64_SetULong(i, (unsigned short) i->b);
}
void CInt64_ConvertInt8(CInt64 *i) {
i->b = (char) i->b;
CInt64_Extend32(i);
}
void CInt64_ConvertUInt8(CInt64 *i) {
CInt64_SetULong(i, (unsigned char) i->b);
}
void CInt64_ConvertUFromLongDouble(CInt64 *pResult, double value) {
union { float f; unsigned long l; } cvt;
unsigned long a, b;
float threshold;
int bits;
if (value <= 0.0) {
pResult->a = 0;
pResult->b = 0;
return;
}
cvt.l = 0x5F800000;
if (value >= cvt.f) {
pResult->a = 0xFFFFFFFF;
pResult->b = 0xFFFFFFFF;
return;
}
a = b = 0;
for (bits = 63; bits >= 0; bits--) {
a <<= 1;
if (b & 0x80000000)
a |= 1;
b <<= 1;
if ((short) bits == 0) {
threshold = 1.0f;
} else {
cvt.l = (((short) bits + 127) & 255) << 23;
threshold = cvt.f;
}
if (threshold <= value) {
b |= 1;
value -= threshold;
}
}
pResult->a = a;
pResult->b = b;
}
void CInt64_ConvertFromLongDouble(CInt64 *pResult, double value) {
if (value < 0.0) {
CInt64_ConvertUFromLongDouble(pResult, -value);
*pResult = CInt64_Neg(*pResult);
} else {
CInt64_ConvertUFromLongDouble(pResult, value);
}
}
double CInt64_ConvertUToLongDouble(const CInt64 *value) {
unsigned char bad;
unsigned long work;
int counter;
double result;
bad = (value->a == 0) && (value->b == 0);
if (bad) {
return 0.0;
} else {
result = 0.0;
work = value->a;
if (work != 0) {
for (counter = 0; counter < 32; counter++) {
result += result;
if (work & 0x80000000)
result += 1.0;
work <<= 1;
}
}
counter = 0;
work = value->b;
for (; counter < 32; counter++) {
result += result;
if (work & 0x80000000)
result += 1.0;
work <<= 1;
}
return result;
}
}
double CInt64_ConvertToLongDouble(const CInt64 *value) {
CInt64 tmp;
if (value->a & 0x80000000) {
tmp = CInt64_Neg(*value);
return -CInt64_ConvertUToLongDouble(&tmp);
} else {
return CInt64_ConvertUToLongDouble(value);
}
}
char *CInt64_ScanOctString(CInt64 *pResult, char *str, unsigned char *pFail) {
int ch;
CInt64 tmp;
unsigned long a;
unsigned long b;
*pFail = 0;
pResult->a = pResult->b = 0;
while ((ch = *str) >= '0' && *str <= '7') {
a = pResult->a;
b = pResult->b;
if (a & 0xE0000000)
*pFail = 1;
SHIFT_LEFT_ONE(a, b);
SHIFT_LEFT_ONE(a, b);
SHIFT_LEFT_ONE(a, b);
pResult->a = a;
pResult->b = b;
CInt64_SetLong(&tmp, ch - '0');
*pResult = CInt64_Add(*pResult, tmp);
++str;
}
return str;
}
char *CInt64_ScanDecString(CInt64 *pResult, char *str, unsigned char *pFail) {
int ch;
CInt64 tmp;
unsigned long a;
unsigned long b;
*pFail = 0;
pResult->a = pResult->b = 0;
while ((ch = *str) >= '0' && *str <= '9') {
a = pResult->a;
b = pResult->b;
if (a & 0xE0000000)
*pFail = 1;
SHIFT_LEFT_ONE(a, b);
tmp.a = a;
tmp.b = b;
SHIFT_LEFT_ONE(a, b);
SHIFT_LEFT_ONE(a, b);
pResult->a = a;
pResult->b = b;
if (CInt64_IsNegative(pResult)) {
*pResult = CInt64_Add(*pResult, tmp);
if (!CInt64_IsNegative(pResult))
*pFail = 1;
} else {
*pResult = CInt64_Add(*pResult, tmp);
}
CInt64_SetLong(&tmp, ch - '0');
if (CInt64_IsNegative(pResult)) {
*pResult = CInt64_Add(*pResult, tmp);
if (!CInt64_IsNegative(pResult))
*pFail = 1;
} else {
*pResult = CInt64_Add(*pResult, tmp);
}
++str;
}
return str;
}
char *CInt64_ScanHexString(CInt64 *pResult, char *str, unsigned char *pFail) {
/* NOT MATCHING */
int digit;
CInt64 tmp;
unsigned long a;
unsigned long b;
*pFail = 0;
pResult->a = pResult->b = 0;
for (;;) {
if ((digit = str[0]) >= '0' && digit <= '9')
digit = digit - '0';
else if (digit >= 'A' && digit <= 'F')
digit = digit - 'A' + 10;
else if (digit >= 'a' && digit <= 'f')
digit = digit - 'a' + 10;
else
break;
a = pResult->a;
b = pResult->b;
++str;
if (a & 0xF0000000)
*pFail = 1;
SHIFT_LEFT_ONE(a, b);
SHIFT_LEFT_ONE(a, b);
SHIFT_LEFT_ONE(a, b);
SHIFT_LEFT_ONE(a, b);
pResult->a = a;
pResult->b = b;
CInt64_SetLong(&tmp, (char) digit);
*pResult = CInt64_Add(*pResult, tmp);
}
return str;
}
char *CInt64_ScanBinString(CInt64 *pResult, char *str, unsigned char *pFail) {
char digit;
unsigned long a;
unsigned long b;
*pFail = 0;
pResult->a = pResult->b = 0;
for (;;) {
if (*str == '0')
digit = 0;
else if (*str == '1')
digit = 1;
else
break;
a = pResult->a;
b = pResult->b;
++str;
if (a & 0x80000000)
*pFail = 1;
SHIFT_LEFT_ONE(a, b);
pResult->a = a;
pResult->b = b;
if (digit == 1)
*pResult = CInt64_Add(*pResult, cint64_one);
}
return str;
}
char *CInt64_ScanAsmNumber(CInt64 *pResult, char *str, unsigned char *pFail) {
unsigned char isMaybeBin;
unsigned char isOct;
unsigned char isMaybeDec;
unsigned char isBin;
char *p;
isMaybeBin = 1;
isOct = *str == '0';
isMaybeDec = 1;
isBin = 0;
p = str;
for (;;) {
if (*p == 0)
break;
if (strchr("01", p[0])) {
if (isBin)
isMaybeBin = 0;
} else if (strchr("bB", p[0])) {
isBin = 1;
isMaybeDec = 0;
isOct = 0;
} else if (strchr("234567", p[0])) {
isMaybeBin = 0;
} else if (strchr("89", p[0])) {
isOct = 0;
isMaybeBin = 0;
} else if (strchr("acdefACEDF", p[0])) {
isMaybeDec = 0;
isMaybeBin = 0;
} else {
break;
}
++p;
}
if (isMaybeBin && isBin) {
return CInt64_ScanBinString(pResult, str, pFail) + 1;
} else if (p[0] == 'h' || p[0] == 'H') {
return CInt64_ScanHexString(pResult, str, pFail) + 1;
} else if (isOct) {
return CInt64_ScanOctString(pResult, str, pFail);
} else if (isMaybeDec) {
return CInt64_ScanDecString(pResult, str, pFail);
} else {
*pFail = 1;
return p;
}
}
int CInt64_PrintDec(char *output, CInt64 value) {
int length;
CInt64 rem;
CInt64 divisor;
char buf[40];
char *bufp;
length = 0;
if (CInt64_IsNegative(&value)) {
value = CInt64_Neg(value);
*output = '-';
length++;
output++;
}
if (!CInt64_IsZero(&value)) {
divisor.b = 10;
divisor.a = 0;
bufp = buf;
for (;;) {
rem = CInt64_ModU(value, divisor);
*(bufp++) = rem.b + '0';
value = CInt64_DivU(value, divisor);
if (CInt64_IsZero(&value) != 0)
break;
}
while (--bufp >= buf) {
*(output++) = *bufp;
length++;
}
} else {
*(output++) = '0';
length++;
}
*output = 0;
return length;
}
int CInt64_PrintHex(char *output, CInt64 value) {
int length;
CInt64 rem;
CInt64 shift;
CInt64 mask;
char buf[32];
char *bufp;
length = 0;
if (!CInt64_IsZero(&value)) {
shift.b = 4;
shift.a = 0;
mask.b = 0xF;
mask.a = 0;
bufp = buf;
for (;;) {
rem = CInt64_And(value, mask);
if ((long) rem.b >= 10)
*(bufp++) = rem.b + 'A';
else
*(bufp++) = rem.b + '0';
value = CInt64_ShrU(value, shift);
if (CInt64_IsZero(&value) != 0)
break;
}
while (--bufp >= buf) {
*(output++) = *bufp;
length++;
}
} else {
*(output++) = '0';
length++;
}
*output = 0;
return length;
}
int CInt64_PrintBin(char *output, CInt64 value) {
int length;
CInt64 rem;
char buf[64];
char *bufp;
length = 0;
if (!CInt64_IsZero(&value)) {
bufp = buf;
for (;;) {
rem = CInt64_And(value, cint64_one);
if (CInt64_Equal(rem, cint64_one))
*(bufp++) = '1';
else
*(bufp++) = '0';
value = CInt64_ShrU(value, cint64_one);
if (CInt64_IsZero(&value) != 0)
break;
}
while (--bufp >= buf) {
*(output++) = *bufp;
length++;
}
} else {
*(output++) = '0';
length++;
}
*output = 0;
return length;
}
Reference in New Issue View Git Blame Copy Permalink