convert_num_system.c

/******************************************************************************
* convert between numeric systems                                     BnGhTz  *
*                                                                             *
* Usage: convert_num_system number from [to]                                  *
*  number: number to convert                                                  *
*  from:   base radix (int 2 - 36)                                            *
*  to:     target radix (int 2 - 36); The default is 10.                      *
*                                                                             *
* Examples:                                                                   *
*                                                                             *
* ./convert_num_system foo 25                                                 *
* 9999                                                                        *
*                                                                             *
* ./convert_num_system 301 36 7                                               *
* 14224                                                                       *
*                                                                             *
******************************************************************************/

/*  gcc -lm  this.c -o convert_num_system  */

/*
    The unsigned long long integer cannot handle bigger number as
    36:zzzzzzzzzzq which is DEC: 131 621 703 842 267 126.
*/


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#define MaxLen 255
#define MaxRadix 36
#define MinRadix 2
#define BaseRadix 10

#define TYPE unsigned long long int

void usage(char * name)
{
  fprintf(stderr, "Usage: %s number from [to]\n\n");
  fprintf(stderr, "  number: number to convert\n");
  fprintf(stderr, "  from:   base radix (int: %d - %d)\n", MinRadix, MaxRadix);
  fprintf(stderr, "  to:     target radix (int: %d - %d);", MinRadix, MaxRadix);
  fprintf(stderr, " The default is %d.\n\n", BaseRadix);

  exit(-2);
}

TYPE powInt(TYPE x, int y)
{
  return (TYPE) pow((float)x,(float)y);
}

// gets the length of coverted number
int toLen(TYPE x, int to)
{
  return (int)(log(x) / log(to)) + 1;
}

// char -> numeric value; example F->15; A->10->A; 9->9
int chr_to_dec(char c)
{
   int ret;

   if (c >= 'A' && c <= 'Z')
     ret = c - 'A' + 10;
   else if (c >= 'a' && c <= 'z')
     ret = c - 'a' + 10;
   else if (c >= '0' && c <= '9')
     ret = c - '0';

   return ret;
}

// value --> char; example 15->F; 10->A; 9->9
char dec_to_chr(int x)
{
  char ret;

  if (x > 9)
    ret = x - 10 + 'A';
  else
    ret = x + '0';

  return ret;
}

// serch for minimal radix in a number (maximal value + 1)
int serchMinRadix(char *num)
{
  int i, val, ret;
  ret = 0;

  for (i = 0; i < strlen(num); i++)
  {
    val = chr_to_dec(num[i]) + 1;
    if (val > ret)
      ret = val;
  }

  return ret;
}

// numeric system converter
char * scale_to_any(char * num, int from, int to)
{
  TYPE dec, temp;
  int i, len, to_len, min_radix;
  char *ret = NULL;

  // checking
  min_radix = serchMinRadix(num);

  if (min_radix > from)
  {
    fprintf(stderr, "Invalid radix '%d'. Minimal radix is '%d'\n",\
        from, min_radix);
    exit(-1);
  }

  // convert to dec  (right to left)
  dec = 0;
  len = strlen(num);

  for (i = 0; i < len; i++)
  {
    dec += chr_to_dec(num[len - i - 1]) * powInt(from,i);
  }

  // convert to oth
  to_len = toLen(dec,to);
  ret = (char *) malloc(sizeof(char) * (to_len + 1));
  bzero(ret, (sizeof(char) * to_len));
  i = 0;

  while (dec > 0)
  {
    temp = (int) (dec % (TYPE)to);
    dec = (dec - (TYPE)temp) / (TYPE)to;
    ret[to_len - 1 - i] = dec_to_chr(temp);
    i++;
  }

  return ret;
}

void checkRadix(int x, char * item)
{
  if (x < MinRadix)
  {
    fprintf(stderr, "ERROR in '%s' minimal radix is %d\n", item, MinRadix);
    exit(-1);
  }
  else if (x > MaxRadix)
  {
    fprintf(stderr, "ERROR in '%s' maximal radix is %d\n", item, MaxRadix);
    exit(-1);
  }
}

int main(int argc, char * argv[])
{
  int i, from = 0, to = BaseRadix;
  char *num = NULL;
  char *ret = NULL;
  int size = sizeof(char) * MaxLen;
  num = (char *) malloc(size);
  ret = (char *) malloc(size);
  bzero(num, size);
  bzero(ret, size);

  // INPUT
  if (argc < 3)
    usage(argv[0]);

  if (argc > 1)
    sprintf(num, "%s", argv[1]);
  if (argc > 2)
    from = atoi(argv[2]);
  if (argc > 3)
    to = atoi(argv[3]);

  checkRadix(from, "from");
  checkRadix(to, "to");

  // convert
  ret = scale_to_any(num, from, to);
  printf("%2d: %s = %2d: %s\n", from, num, to, ret);

  return 0;
}