num.c

At can be given its arguments in a file. You can comment out lines by preceding them with either #

/* =========================================================
*
*  NUM.C --- Numerical conversions.
*
*  Version 1.0
*
*  CREATED        :  21.3.1992
*  LAST UPDATE    :
*/
static char *VERSION="Version  1.0. Copyright(c) Martti Ylikoski, 1992. " ;
/*
*
* ==========================================================*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define INCL_DOS
#include <os2.h>
#include <param.h>
#include <paramstd.h>
ParamEntry pentry[12] = {
     "P", &ParamSetPause, 0,
     "F", &ParamSetFold, 0,
     "V", &ParamSetVerbose, 1,
     "R", &ParamSetReport, 1,
     "S", &ParamSetSubDirs, 0,
     "?", &ParamSetHelp, 1,
     "H", &ParamSetHelp, 0,
     "NOD", &ParamSetNoDefault, 0,
     "TEST", &ParamSetTest, 0,
     "Y", &ParamSetYes, 0,
     "N", &ParamSetTest, 0,
     "\0", NULL, 0
} ;

ParamBlock params = {
    "/-",   IGNORECASE | NOPRIORITY | NOTRIGGERSALLOWED ,
    pentry
} ;

static char *progname ;
extern unsigned long pflags ; /* needed because of paramstd */

/* local prototypes */
static void usage( void ) ;
static long bintodec(char *binstr) ;
static char * octtobin(char *octstr, char *binstr, int binlen) ;

/* used to conver octal numbers to binary and vice versa */
static char *convtbl[] = {
"000",
"001",
"010",
"011",
"100",
"101",
"110",
"111",
} ;

main( int argc, char *argv[] )
{
long num ;
USHORT ret ;
int i ;
char *radix, wrkbuf[30], octstr[30] ;

   progname = argv[0] ;

   if (argc != 3)
   {
      usage() ;
      return( 1 ) ;

   }
   ParamHandle(&params, &argc, argv) ;

   if (pflags & PA_HELP)
   {
      usage() ;
      return( 0 ) ;
   }

   if (strcmpi(argv[1], "/H") == 0 || strcmpi(argv[1], "-H") == 0)
   {
      sscanf(argv[2],"%lx", &num) ;
      radix = "hexadecimal" ;
   }

   if (strcmpi(argv[1], "/D") == 0 || strcmpi(argv[1], "-D") == 0)
   {
      sscanf(argv[2],"%ld", &num) ;
      radix = "decimal" ;
   }

   if (strcmpi(argv[1], "/O") == 0 || strcmpi(argv[1], "-O") == 0)
   {
      sscanf(argv[2],"%lo", &num) ;
      radix = "octal" ;
   }

   if (strcmpi(argv[1], "/B") == 0 || strcmpi(argv[1], "-B") == 0)
   {
      sscanf(argv[2],"%s", wrkbuf) ;
      num = bintodec(wrkbuf) ;
      radix = "binary" ;
   }

   sprintf(octstr,"%lo",num) ;

   printf("%s (%s) is:\n",argv[2], radix) ;   
   printf(" decimal:      %ld\n", num) ;
   printf(" octal:        %lo\n", num) ;
   printf(" hexadecimal:  %lx\n", num) ;      
   printf(" binary:       %s\n", octtobin(octstr, wrkbuf, sizeof(wrkbuf)));
   return( 0 ) ;
} 

static void usage( void )
{

   fprintf(stderr,"NUM - Numerical conversions.\n") ;
   fprintf(stderr, VERSION) ;
   fprintf(stderr, "\nUsage: %s [/D | /O | /H ] [/B] [/?] num \n", progname) ;
   fprintf(stderr,"Where:\n") ;
   fprintf(stderr,"   /D = input is a decimal integer.\n") ;   
   fprintf(stderr,"   /O = octal integer.\n" ) ;
   fprintf(stderr,"   /H = hexadecimal integer.\n" ) ;
   fprintf(stderr,"   /B = binary integer.\n" ) ;      
}

/*********************************************************
*
* octtobin - convert octal representation to a binary format.
*
*********************************************************/
static char * octtobin(char *octstr, char *binstr, int binlen) 
{
int i ;

   memset(binstr, (int) '\0', (size_t) binlen) ;
   if (strlen(octstr) == 0)
      return "-";

   for (i=0; i <strlen(octstr); i++)
   {
      
      if (strlen(binstr) + strlen(convtbl[0]) > binlen) /* overflow */
      {
         memset(binstr, (int) '\0', (size_t) binlen) ;
         return "-";
      }
      strcat(binstr,convtbl[octstr[i]-'0']) ;
   }
   return(binstr) ;
}

/*********************************************************
*
* bintodec - convert binary representation to a decimal number.
*
*********************************************************/

static long bintodec(char *binstr) 
{
int i ;
char buf[20], wrk[4], tmpbuf[3] ;
long res ;

   memset(buf, (int) '\0', (size_t) sizeof(buf) ) ;

   strrev(binstr) ;
   
   while( strlen(binstr) > 0 )
   {
      if (strlen(binstr) < 3)
      {
         strcpy(wrk, binstr) ;
         strncat(wrk, "00", (size_t) 3-strlen(binstr)) ;
         wrk[3] = '\0' ;
         strrev(wrk) ;
         for (i=0; i < sizeof(convtbl)/sizeof(convtbl[0]) ; i++)
         {
            if (strcmp(convtbl[i], wrk) == 0)
            {
               strcat(buf, itoa(i, tmpbuf, 8)) ;
               break ;
            }
         }
         break ;
      }
      else
      {
         strncpy(wrk, binstr, 3) ;
         wrk[3] = '\0' ;
         binstr += 3 ;
         strrev(wrk) ;
         for (i=0; i < sizeof(convtbl)/sizeof(convtbl[0]) ; i++)
         {
            if (strcmp(convtbl[i], wrk) == 0)
            {
               strcat(buf, itoa(i, tmpbuf, 8 )) ;
               break ;
            }
         }
      } /* else */
   } /* while */

   strrev(buf) ;
   sscanf(buf, "%lo", &res) ;

   return(res) ;
}