| … | |
… | |
| 255 | |
255 | |
| 256 | *ptr = '-'; ptr += i < 0 ? 1 : 0; |
256 | *ptr = '-'; ptr += i < 0 ? 1 : 0; |
| 257 | uint32 u = i < 0 ? -i : i; |
257 | uint32 u = i < 0 ? -i : i; |
| 258 | |
258 | |
| 259 | if (expect_true (u < 10)) // we have a lot of single-digit numbers, so optimise |
259 | if (expect_true (u < 10)) // we have a lot of single-digit numbers, so optimise |
| 260 | fadd (char (u + '0')); |
260 | *ptr++ = u + '0'; |
|
|
261 | else if (expect_true (u < 100)) // we have a lot of double-digit numbers, too :) |
|
|
262 | { |
|
|
263 | // let the compiler figure out sth. efficient here |
|
|
264 | *ptr++ = u / 10 + '0'; |
|
|
265 | *ptr++ = u % 10 + '0'; |
|
|
266 | } |
| 261 | else if (expect_true (u < 1000000000)) // 9 0's |
267 | else if (expect_true (u < 1000000000)) // 9 0's |
| 262 | ptr = i2a_9 (ptr, u, false); |
268 | ptr = i2a_9 (ptr, u, false); |
| 263 | else |
269 | else |
| 264 | { |
270 | { |
| 265 | sint32 div = u / 1000000000; |
271 | uint32 div = u / 1000000000; |
| 266 | uint32 rem = u % 1000000000; |
272 | uint32 rem = u % 1000000000; |
| 267 | |
273 | |
| 268 | ptr = i2a_9 (ptr, div, false); |
274 | ptr = i2a_9 (ptr, div, false); |
| 269 | ptr = i2a_9 (ptr, rem, true); |
275 | ptr = i2a_9 (ptr, rem, true); |
| 270 | } |
276 | } |
| … | |
… | |
| 282 | // (#19) and two 9 digit parts (9..18 and 0..8) |
288 | // (#19) and two 9 digit parts (9..18 and 0..8) |
| 283 | |
289 | |
| 284 | // good compilers will only use multiplications here |
290 | // good compilers will only use multiplications here |
| 285 | |
291 | |
| 286 | if (u < 10) // we have a lot of single-digit numbers, so optimise |
292 | if (u < 10) // we have a lot of single-digit numbers, so optimise |
| 287 | fadd (char (u + '0')); |
293 | *ptr++ = u + '0'; |
| 288 | else if (expect_true (u < 1000000000)) // 9 0's |
294 | else if (expect_true (u < 1000000000)) // 9 0's |
| 289 | ptr = i2a_9 (ptr, u, false); |
295 | ptr = i2a_9 (ptr, u, false); |
| 290 | else if (expect_true (u < UINT64_C (1000000000000000000))) // 18 0's |
296 | else if (expect_true (u < UINT64_C (1000000000000000000))) // 18 0's |
| 291 | { |
297 | { |
| 292 | sint32 div = u / 1000000000; |
298 | uint32 div = u / 1000000000; |
| 293 | uint32 rem = u % 1000000000; |
299 | uint32 rem = u % 1000000000; |
| 294 | |
300 | |
| 295 | ptr = i2a_9 (ptr, div, false); |
301 | ptr = i2a_9 (ptr, div, false); |
| 296 | ptr = i2a_9 (ptr, rem, true); |
302 | ptr = i2a_9 (ptr, rem, true); |
| 297 | } |
303 | } |
| 298 | else |
304 | else |
| 299 | { |
305 | { |
| 300 | // a biggy |
306 | // a biggy, split off the topmost digit |
| 301 | sint32 div = u / UINT64_C (1000000000000000000); |
307 | uint32 div = u / UINT64_C (1000000000000000000); |
| 302 | uint64 rem = u % UINT64_C (1000000000000000000); |
308 | uint64 rem = u % UINT64_C (1000000000000000000); |
| 303 | |
309 | |
| 304 | fadd (char (div + '0')); |
310 | *ptr++ = div + '0'; |
|
|
311 | |
| 305 | u = rem; |
312 | u = rem; |
| 306 | |
313 | |
| 307 | { |
314 | { |
| 308 | sint32 div = u / 1000000000; |
315 | uint32 div = u / 1000000000; |
| 309 | uint32 rem = u % 1000000000; |
316 | uint32 rem = u % 1000000000; |
| 310 | |
317 | |
| 311 | ptr = i2a_9 (ptr, div, true); |
318 | ptr = i2a_9 (ptr, div, true); |
| 312 | ptr = i2a_9 (ptr, rem, true); |
319 | ptr = i2a_9 (ptr, rem, true); |
| 313 | } |
320 | } |
