Revision 1.190 by

Revision 1.191 by

… | … | ||
---|---|---|---|

946 | 946 | ||

947 | return s | 0x7c00 | m | !m; | 947 | return s | 0x7c00 | m | !m; |

948 | } | 948 | } |

949 | 949 | ||

950 | /*******************************************************************************/ | 950 | /*******************************************************************************/ |

951 | /* fast integer to ascii */ | ||

952 | |||

953 | // simply return a mask with "bits" bits set | ||

954 | #define ecb_i2a_mask(type,bits) ((((type)1) << (bits)) - 1) | ||

955 | |||

956 | // oputput a single digit. maskvalue is 10**digitidx | ||

957 | #define ecb_i2a_digit(type,bits,digitmask,maskvalue,digitidx) \ | ||

958 | if (digitmask >= maskvalue) /* constant, used to decide how many digits to generate */ \ | ||

959 | { \ | ||

960 | char digit = x >> (bits - digitidx); /* calculate the topmost digit */ \ | ||

961 | *ptr = digit + '0'; /* output it */ \ | ||

962 | nz = (digitmask == maskvalue) || nz || digit; /* first term == always output last digit */ \ | ||

963 | ptr += nz; /* output digit only if non-zero digit seen */ \ | ||

964 | x = (x & ecb_i2a_mask (type, bits - digitidx)) * 5; /* *10, but shift decimal point right */ \ | ||

965 | } | ||

966 | |||

967 | // convert integer to fixed point format and multiply out digits, highest first | ||

968 | // requires magic constants: max. digits and number of bits after the decimal point | ||

969 | #define ecb_i2a_def(suffix,ptr,v,type,bits,digitmask,lz) \ | ||

970 | ecb_inline char *ecb_i2a_ ## suffix (char *ptr, uint32_t u) \ | ||

971 | { \ | ||

972 | char nz = lz; /* non-zero digit seen? */ \ | ||

973 | /* convert to x.bits fixed-point */ \ | ||

974 | type x = u * ((ecb_i2a_mask (type, bits) + digitmask) / digitmask); \ | ||

975 | /* output up to 10 digits */ \ | ||

976 | ecb_i2a_digit (type,bits,digitmask, 1, 0); \ | ||

977 | ecb_i2a_digit (type,bits,digitmask, 10, 1); \ | ||

978 | ecb_i2a_digit (type,bits,digitmask, 100, 2); \ | ||

979 | ecb_i2a_digit (type,bits,digitmask, 1000, 3); \ | ||

980 | ecb_i2a_digit (type,bits,digitmask, 10000, 4); \ | ||

981 | ecb_i2a_digit (type,bits,digitmask, 100000, 5); \ | ||

982 | ecb_i2a_digit (type,bits,digitmask, 1000000, 6); \ | ||

983 | ecb_i2a_digit (type,bits,digitmask, 10000000, 7); \ | ||

984 | ecb_i2a_digit (type,bits,digitmask, 100000000, 8); \ | ||

985 | ecb_i2a_digit (type,bits,digitmask, 1000000000, 9); \ | ||

986 | return ptr; \ | ||

987 | } | ||

988 | |||

989 | // predefined versions of the above, for various digits | ||

990 | // ecb_i2a_xN = almost N digits, limit defined by macro | ||

991 | // ecb_i2a_N = up to N digits, leading zeroes suppressed | ||

992 | // ecb_i2a_0N = exactly N digits, including leading zeroes | ||

993 | |||

994 | // non-leading-zero versions, limited range | ||

995 | #define ECB_I2A_MAX_X5 59074 // limit for ecb_i2a_x5 | ||

996 | #define ECB_I2A_MAX_X10 2932500665 // limit for ecb_i2a_x10 | ||

997 | ecb_i2a_def ( x5, ptr, v, uint32_t, 26, 10000, 0) | ||

998 | ecb_i2a_def (x10, ptr, v, uint64_t, 60, 1000000000, 0) | ||

999 | |||

1000 | // non-leading zero versions, all digits, 4 and 9 are optimal for 32/64 bit | ||

1001 | ecb_i2a_def ( 2, ptr, v, uint32_t, 10, 10, 0) | ||

1002 | ecb_i2a_def ( 3, ptr, v, uint32_t, 12, 100, 0) | ||

1003 | ecb_i2a_def ( 4, ptr, v, uint32_t, 26, 1000, 0) | ||

1004 | ecb_i2a_def ( 5, ptr, v, uint64_t, 30, 10000, 0) | ||

1005 | ecb_i2a_def ( 6, ptr, v, uint64_t, 36, 100000, 0) | ||

1006 | ecb_i2a_def ( 7, ptr, v, uint64_t, 44, 1000000, 0) | ||

1007 | ecb_i2a_def ( 8, ptr, v, uint64_t, 50, 10000000, 0) | ||

1008 | ecb_i2a_def ( 9, ptr, v, uint64_t, 56, 100000000, 0) | ||

1009 | |||

1010 | // leading-zero versions, all digits, 04 and 09 are optimal for 32/64 bit | ||

1011 | ecb_i2a_def (02, ptr, v, uint32_t, 10, 10, 1) | ||

1012 | ecb_i2a_def (03, ptr, v, uint32_t, 12, 100, 1) | ||

1013 | ecb_i2a_def (04, ptr, v, uint32_t, 26, 1000, 1) | ||

1014 | ecb_i2a_def (05, ptr, v, uint64_t, 30, 10000, 1) | ||

1015 | ecb_i2a_def (06, ptr, v, uint64_t, 36, 100000, 1) | ||

1016 | ecb_i2a_def (07, ptr, v, uint64_t, 44, 1000000, 1) | ||

1017 | ecb_i2a_def (08, ptr, v, uint64_t, 50, 10000000, 1) | ||

1018 | ecb_i2a_def (09, ptr, v, uint64_t, 56, 100000000, 1) | ||

1019 | |||

1020 | ecb_inline char * | ||

1021 | ecb_i2a_u32 (char *ptr, uint32_t u) | ||

1022 | { | ||

1023 | #if ECB_64BIT_NATIVE | ||

1024 | if (ecb_expect_true (u <= ECB_I2A_MAX_X10)) | ||

1025 | ptr = ecb_i2a_x10 (ptr, u); | ||

1026 | else // x10 almost, but not fully, covers 32 bit | ||

1027 | { | ||

1028 | uint32_t u1 = u % 1000000000; | ||

1029 | uint32_t u2 = u / 1000000000; | ||

1030 | |||

1031 | *ptr++ = u2 + '0'; | ||

1032 | ptr = ecb_i2a_09 (ptr, u1); | ||

1033 | } | ||

1034 | #else | ||

1035 | if (ecb_expect_true (u <= ECB_I2A_MAX_X5)) | ||

1036 | ecb_i2a_x5 (ptr, u); | ||

1037 | else if (ecb_expect_true (u <= ECB_I2A_MAX_X5 * 10000)) | ||

1038 | { | ||

1039 | uint32_t u1 = u % 10000; | ||

1040 | uint32_t u2 = u / 10000; | ||

1041 | |||

1042 | ptr = ecb_i2a_x5 (ptr, u2); | ||

1043 | ptr = ecb_i2a_04 (ptr, u1); | ||

1044 | } | ||

1045 | else | ||

1046 | { | ||

1047 | uint32_t u1 = u % 10000; | ||

1048 | uint32_t ua = u / 10000; | ||

1049 | uint32_t u2 = ua % 10000; | ||

1050 | uint32_t u3 = ua / 10000; | ||

1051 | |||

1052 | ptr = ecb_i2a_2 (ptr, u3); | ||

1053 | ptr = ecb_i2a_04 (ptr, u2); | ||

1054 | ptr = ecb_i2a_04 (ptr, u1); | ||

1055 | } | ||

1056 | #endif | ||

1057 | |||

1058 | return ptr; | ||

1059 | } | ||

1060 | |||

1061 | ecb_inline char * | ||

1062 | ecb_i2a_i32 (char *ptr, int32_t v) | ||

1063 | { | ||

1064 | *ptr = '-'; ptr += v < 0; | ||

1065 | uint32_t u = v < 0 ? -(uint32_t)v : v; | ||

1066 | |||

1067 | #if ECB_64BIT_NATIVE | ||

1068 | ptr = ecb_i2a_x10 (ptr, u); // x10 fully covers 31 bit | ||

1069 | #else | ||

1070 | ptr = ecb_i2a_u32 (ptr, u); | ||

1071 | #endif | ||

1072 | |||

1073 | return ptr; | ||

1074 | } | ||

1075 | |||

1076 | ecb_inline char * | ||

1077 | ecb_i2a_u64 (char *ptr, uint64_t u) | ||

1078 | { | ||

1079 | #if ECB_64BIT_NATIVE | ||

1080 | if (ecb_expect_true (u <= ECB_I2A_MAX_X10)) | ||

1081 | ptr = ecb_i2a_x10 (ptr, u); | ||

1082 | else if (ecb_expect_false (u <= ECB_I2A_MAX_X10 * 1000000000)) | ||

1083 | { | ||

1084 | uint64_t u1 = u % 1000000000; | ||

1085 | uint64_t u2 = u / 1000000000; | ||

1086 | |||

1087 | ptr = ecb_i2a_x10 (ptr, u2); | ||

1088 | ptr = ecb_i2a_09 (ptr, u1); | ||

1089 | } | ||

1090 | else | ||

1091 | { | ||

1092 | uint64_t u1 = u % 1000000000; | ||

1093 | uint64_t ua = u / 1000000000; | ||

1094 | uint64_t u2 = ua % 1000000000; | ||

1095 | uint64_t u3 = ua / 1000000000; | ||

1096 | |||

1097 | ptr = ecb_i2a_2 (ptr, u3); | ||

1098 | ptr = ecb_i2a_09 (ptr, u2); | ||

1099 | ptr = ecb_i2a_09 (ptr, u1); | ||

1100 | } | ||

1101 | #else | ||

1102 | if (ecb_expect_true (u <= ECB_I2A_MAX_X5)) | ||

1103 | ptr = ecb_i2a_x5 (ptr, u); | ||

1104 | else | ||

1105 | { | ||

1106 | uint64_t u1 = u % 10000; | ||

1107 | uint64_t u2 = u / 10000; | ||

1108 | |||

1109 | ptr = ecb_i2a_u64 (ptr, u2); | ||

1110 | ptr = ecb_i2a_04 (ptr, u1); | ||

1111 | } | ||

1112 | #endif | ||

1113 | |||

1114 | return ptr; | ||

1115 | } | ||

1116 | |||

1117 | ecb_inline char * | ||

1118 | ecb_i2a_i64 (char *ptr, int64_t v) | ||

1119 | { | ||

1120 | *ptr = '-'; ptr += v < 0; | ||

1121 | uint64_t u = v < 0 ? -(uint64_t)v : v; | ||

1122 | |||

1123 | #if ECB_64BIT_NATIVE | ||

1124 | if (ecb_expect_true (u <= ECB_I2A_MAX_X10)) | ||

1125 | ptr = ecb_i2a_x10 (ptr, u); | ||

1126 | else if (ecb_expect_false (u <= ECB_I2A_MAX_X10 * 1000000000)) | ||

1127 | { | ||

1128 | uint64_t u1 = u % 1000000000; | ||

1129 | uint64_t u2 = u / 1000000000; | ||

1130 | |||

1131 | ptr = ecb_i2a_x10 (ptr, u2); | ||

1132 | ptr = ecb_i2a_09 (ptr, u1); | ||

1133 | } | ||

1134 | else | ||

1135 | { | ||

1136 | uint64_t u1 = u % 1000000000; | ||

1137 | uint64_t ua = u / 1000000000; | ||

1138 | uint64_t u2 = ua % 1000000000; | ||

1139 | uint64_t u3 = ua / 1000000000; | ||

1140 | |||

1141 | // 2**31 is 19 digits, so the top is exactly one digit | ||

1142 | *ptr++ = u3 + '0'; | ||

1143 | ptr = ecb_i2a_09 (ptr, u2); | ||

1144 | ptr = ecb_i2a_09 (ptr, u1); | ||

1145 | } | ||

1146 | #else | ||

1147 | ptr = ecb_i2a_u64 (ptr, u); | ||

1148 | #endif | ||

1149 | |||

1150 | return ptr; | ||

1151 | } | ||

1152 | |||

1153 | /*******************************************************************************/ | ||

951 | /* floating point stuff, can be disabled by defining ECB_NO_LIBM */ | 1154 | /* floating point stuff, can be disabled by defining ECB_NO_LIBM */ |

952 | 1155 | ||

953 | /* basically, everything uses "ieee pure-endian" floating point numbers */ | 1156 | /* basically, everything uses "ieee pure-endian" floating point numbers */ |

954 | /* the only noteworthy exception is ancient armle, which uses order 43218765 */ | 1157 | /* the only noteworthy exception is ancient armle, which uses order 43218765 */ |

955 | #if 0 \ | 1158 | #if 0 \ |

– |
Removed lines |

+ |
Added lines |

< |
Changed lines |

> |
Changed lines |