number.h

Go to the documentation of this file.

#pragma once

 
/* Storage capacities in elements; text buffers include the terminating NUL. */
#define UTIL_NUMBER_TEMP_BUFFER_SIZE 10
 
#include <stdint.h>
#include <stddef.h>
 
/* ============================================================================
 * Digit Counting
 * ============================================================================
 */

static inline int digits_u32(uint32_t v) {
  if (v >= 1000000000u)
    return 10;
  if (v >= 100000000u)
    return 9;
  if (v >= 10000000u)
    return 8;
  if (v >= 1000000u)
    return 7;
  if (v >= 100000u)
    return 6;
  if (v >= 10000u)
    return 5;
  if (v >= 1000u)
    return 4;
  if (v >= 100u)
    return 3;
  if (v >= 10u)
    return 2;
  return 1;
}

static inline int digits_u16(uint16_t v) {
  if (v >= 10000u)
    return 5;
  if (v >= 1000u)
    return 4;
  if (v >= 100u)
    return 3;
  if (v >= 10u)
    return 2;
  return 1;
}

static inline int digits_u8(uint8_t v) {
  if (v >= 100u)
    return 3;
  if (v >= 10u)
    return 2;
  return 1;
}
 
/* ============================================================================
 * Decimal Conversion
 * ============================================================================
 */

static inline size_t write_decimal(int value, char *dst) {
  if (value == 0) {
    *dst = '0';
    return 1;
  }
 
  if (value < 0) {
    // For negative numbers, just return without writing
    // (not typically used in this codebase but handle gracefully)
    return 0;
  }
 
  char temp[UTIL_NUMBER_TEMP_BUFFER_SIZE]; // Enough for 32-bit int
  int pos = 0;
  int v = value;
 
  while (v > 0) {
    temp[pos++] = '0' + (v % 10);
    v /= 10;
  }
 
  // Reverse digits into dst
  for (int i = 0; i < pos; i++) {
    dst[i] = temp[pos - 1 - i];
  }
 
  return (size_t)pos;
}
 
/* ============================================================================
 * Byte Formatting (for ANSI sequences)
 * ============================================================================
 */

static inline char *write_u8(char *p, uint8_t n) {
  if (n < 10) {
    *p++ = '0' + n;
  } else if (n < 100) {
    *p++ = '0' + (n / 10);
    *p++ = '0' + (n % 10);
  } else {
    *p++ = '0' + (n / 100);
    *p++ = '0' + ((n / 10) % 10);
    *p++ = '0' + (n % 10);
  }
  return p;
}

static inline char *write_u16(char *p, uint16_t n) {
  char temp[5];
  int pos = 0;
  uint16_t v = n;
 
  if (v == 0) {
    *p++ = '0';
    return p;
  }
 
  while (v > 0) {
    temp[pos++] = '0' + (v % 10);
    v /= 10;
  }
 
  // Reverse digits
  for (int i = pos - 1; i >= 0; i--) {
    *p++ = temp[i];
  }
 
  return p;
}

static inline char *write_u32(char *p, uint32_t n) {
  char temp[UTIL_NUMBER_TEMP_BUFFER_SIZE];
  int pos = 0;
  uint32_t v = n;
 
  if (v == 0) {
    *p++ = '0';
    return p;
  }
 
  while (v > 0) {
    temp[pos++] = '0' + (v % 10);
    v /= 10;
  }
 
  // Reverse digits
  for (int i = pos - 1; i >= 0; i--) {
    *p++ = temp[i];
  }
 
  return p;
}