C语言 32位 和 64位数 之间 位数 的加减乘除运算

#ifndef __INC_PUBLHEAD_H__
    #define __INC_PUBLHEAD_H__
//-----------------------------------------------------------------------------
#include <stdio.h>
#include "PublType.h"
//-----------------------------------------------------------------------------
#endif

#ifndef __INC_PUBLTYPE_H__
    #define __INC_PUBLTYPE_H__
//-----------------------------------------------------------------------------
typedef char                String;         // 字符串型
typedef unsigned int        Boolean;        // 布尔型

typedef unsigned char       UFix08;         // 无符号  8 位
typedef unsigned short int  UFix16;         // 无符号 16 位
typedef unsigned long int   UFix32;         // 无符号 32 位

typedef signed char         SFix08;         // 带符号  8 位
typedef signed short int    SFix16;         // 带符号 16 位
typedef signed long int     SFix32;         // 带符号 32 位

typedef unsigned int        UAuto08;        // 无符号 至少  8 位
typedef unsigned int        UAuto16;        // 无符号 至少 16 位
typedef unsigned long       UAuto32;        // 无符号 至少 32 位

typedef signed char         SAuto08;        // 带符号 至少  8 位
typedef signed int          SAuto16;        // 带符号 至少 16 位
typedef signed long         SAuto32;        // 带符号 至少 32 位
//-----------------------------------------------------------------------------
#endif

#include "PublHead.h"

#include "PublHead.h"

typedef struct
{
    UFix32   high;
    UFix32   low;
} STR_UFix64;

// 函数功能:    *retv = a + b;
// 输入:  a , b
// 输出:  *retv
static void Cal_U32_Add_U32(UFix32 a, UFix32 b, STR_UFix64 *retv)
{
	retv->low = a + b;
	retv->high = (retv->low < a) ? 1 : 0;
}

// 函数功能:  *a += *b;
// 输入:  *a , *b
// 输出:  *a
static void Cal_U64_Add_U64(STR_UFix64 *a, STR_UFix64 const *b)
{
#if 1
	UFix32 t;

	t = a->high;
	Cal_U32_Add_U32(a->low, b->low, a);
	a->high += (t + b->high);
#elif 0
	STR_UFix64 low = {0};

	Cal_U32_Add_U32(a->low, b->low, &low);
	a->high = a->high + b->high + low.high;
	a->low = low.low;
#else
	UFix32 low_temp = a->low;
	a->low += b->low;
	if (a->low < low_temp || a->low < b->low) {
		a->high = a->high + b->high + 1;
	} else {
		a->high += b->high;
	}
#endif

}

// 函数功能:  *retv = a * b
//                = (aH * 0x10000 + aL) * (bH * 0x10000 + bL)
//                = ((aH * bH * 0x100000000) + (aL * bL)) + (aH * bL + aL * bH) * 0x10000
// 输入:  a , b
// 输出:  *retv
static void Cal_U32_Mul_U32(UFix32 a, UFix32 b, STR_UFix64 *retv)
{

#if 1
	UFix32 aH, bH;
	STR_UFix64 mid;

	aH = a >> 16;
	a &= 0x0000ffff;
	bH = b >> 16;
	b &= 0x0000ffff;
	retv->high = aH * bH;
	retv->low = a * b;
	Cal_U32_Add_U32(aH * b, a * bH, &mid);

	mid.high = (mid.high << 16) + (mid.low >> 16);
	mid.low = mid.low << 16;
	Cal_U64_Add_U64(retv, &mid);


#else
	UFix32 i = 0;
	UFix32 big_number = 0;
	UFix32 small_number = 0;

//	big_number = a > b ? a:b;
//	small_number = a < b ? a:b;
//	retv->low = 0;
//	retv->high = 0;
//
//
//	for (i = 0; i < small_number; i++) {
//		retv->low += big_number;
//		if (retv->low < big_number) {
//			retv->high += 1;
//		}
//	}


#endif

}

// 函数功能:  *a /= b
//				= (aH + aL) / b
// 输入:  *a , b
// 输出:  *a
static void Cal_U64_Div_U16(STR_UFix64 *a, UFix16 b)
{
#if 1
	UFix32 H, L;

	H = a->high;
	L = a->low;
	a->high = H / b;
	H = ((H % b) << 16) | (L >> 16);
	a->low = (H / b) << 16;
	H = ((H % b) << 16) | (L & 0xffff);
	a->low |= (H / b);
#else
	UAuto32 j = 0;
	UFix32 remainder = 0;
	UFix32 temp = 0;

	remainder = a->high % b;
	a->high /= b;

	temp = (remainder << 16) + (a->low >> 16);
	remainder = temp % b;
	j = temp / b;
	a->low = (j << 16) | (((a->low & 0x0000ffff) + (remainder << 16)) / b) ;
#endif

}