home *** CD-ROM | disk | FTP | other *** search
/ Between Heaven & Hell 2 / BetweenHeavenHell.cdr / 500 / 471 / rccl130 < prev    next >
Text File  |  1987-03-02  |  5KB  |  442 lines
  1. /*
  2.  *                            Author :  Vincent Hayward
  3.  *                                      School of Electrical Engineering
  4.  *                                      Purdue University
  5.  *      Dir     : uti
  6.  *      File    : bcv.c
  7.  *      Remarks : interactive number represention convertions
  8.  *      Usage   : cc bcv.c -o mybin/bcv
  9.  */
  10.  
  11.  
  12. main()
  13. {
  14.     char line[80], *c, *f, *o, *n;
  15.     static int i;
  16.  
  17.     for (; ; ) {
  18.         c = line;
  19.         f = o = n = "";
  20.         if (0 == gets(line)) {
  21.             exit(0);
  22.         }
  23.         while (*c == ' ') ++c;
  24.         if (*c != '\0') {
  25.             f = c++;
  26.             while(*c == ' ') ++c;
  27.             if (*c != '\0') {
  28.                 o = c++;
  29.                 while(*c == ' ') ++c;
  30.                 if (*c != '\0') {
  31.                     n = c++;
  32.                 }
  33.             }
  34.         }
  35.         switch (*f) {
  36.         case 'b' :
  37.             if (*n != '\0') {
  38.                 i = btoi(n);
  39.             }
  40.             if (*o == '\0') {
  41.                 printb(i, 1);
  42.                 break;
  43.             }
  44.             switch (*o) {
  45.             case 'b' :
  46.                 printb(i, 1);
  47.                 break;
  48.  
  49.             case 'o' :
  50.                 printo(i);
  51.                 break;
  52.  
  53.             case 'x' :
  54.                 printx(i);
  55.                 break;
  56.  
  57.             case 'd' :
  58.                 printd(i);
  59.                 break;
  60.  
  61.             case 'u' :
  62.                 printu(i);
  63.                 break;
  64.  
  65.             case 'c' :
  66.                 printc(i);
  67.                 break;
  68.  
  69.             default :
  70.                 err();
  71.                 break;
  72.             }
  73.             break;
  74.  
  75.         case 'o' :
  76.             if (*n != '\0') {
  77.                 i = otoi(n);
  78.             }
  79.             if (*o == '\0') {
  80.                 printo(i);
  81.                 break;
  82.             }
  83.             switch (*o) {
  84.             case 'b' :
  85.                 printb(i, 3);
  86.                 break;
  87.  
  88.             case 'o' :
  89.                 printo(i);
  90.                 break;
  91.  
  92.             case 'x' :
  93.                 printx(i);
  94.                 break;
  95.  
  96.             case 'd' :
  97.                 printd(i);
  98.                 break;
  99.  
  100.             case 'u' :
  101.                 printu(i);
  102.                 break;
  103.  
  104.             case 'c' :
  105.                 printc(i);
  106.                 break;
  107.  
  108.             default :
  109.                 err();
  110.                 break;
  111.             }
  112.             break;
  113.  
  114.         case 'x' :
  115.             if (*n != '\0') {
  116.                 i = xtoi(n);
  117.             }
  118.             if (*o == '\0') {
  119.                 printx(i);
  120.                 break;
  121.             }
  122.             switch (*o) {
  123.             case 'b' :
  124.                 printb(i, 4);
  125.                 break;
  126.  
  127.             case 'o' :
  128.                 printo(i);
  129.                 break;
  130.  
  131.             case 'x' :
  132.                 printx(i);
  133.                 break;
  134.  
  135.             case 'd' :
  136.                 printd(i);
  137.                 break;
  138.  
  139.             case 'u' :
  140.                 printu(i);
  141.                 break;
  142.  
  143.             case 'c' :
  144.                 printc(i);
  145.                 break;
  146.  
  147.             default :
  148.                 err();
  149.                 break;
  150.             }
  151.             break;
  152.  
  153.         case 'd' :
  154.             if (*n != '\0') {
  155.                 i = dtoi(n);
  156.             }
  157.             if (*o == '\0') {
  158.                 printd(i);
  159.                 break;
  160.             }
  161.             switch (*o) {
  162.             case 'b' :
  163.                 printb(i, 1);
  164.                 break;
  165.  
  166.             case 'o' :
  167.                 printo(i);
  168.                 break;
  169.  
  170.             case 'x' :
  171.                 printx(i);
  172.                 break;
  173.  
  174.             case 'd' :
  175.                 printd(i);
  176.                 break;
  177.  
  178.             case 'u' :
  179.                 printu(i);
  180.                 break;
  181.  
  182.             case 'c' :
  183.                 printc(i);
  184.                 break;
  185.  
  186.             default :
  187.                 err();
  188.                 break;
  189.             }
  190.             break;
  191.  
  192.         case 'u' :
  193.             if (*n != '\0') {
  194.                 i = utoi(n);
  195.             }
  196.             if (*o == '\0') {
  197.                 printu(i);
  198.                 break;
  199.             }
  200.             switch (*o) {
  201.             case 'b' :
  202.                 printb(i, 1);
  203.                 break;
  204.  
  205.             case 'o' :
  206.                 printo(i);
  207.                 break;
  208.  
  209.             case 'x' :
  210.                 printx(i);
  211.                 break;
  212.  
  213.             case 'd' :
  214.                 printd(i);
  215.                 break;
  216.  
  217.             case 'u' :
  218.                 printu(i);
  219.                 break;
  220.  
  221.             case 'c' :
  222.                 printc(i);
  223.                 break;
  224.  
  225.             default :
  226.                 err();
  227.                 break;
  228.             }
  229.             break;
  230.  
  231.         case 'c' :
  232.             if (*n != '\0') {
  233.                 i = ctoi(n);
  234.             }
  235.             if (*o == '\0') {
  236.                 printc(i);
  237.                 break;
  238.             }
  239.             switch (*o) {
  240.             case 'b' :
  241.                 printb(i, 1);
  242.                 break;
  243.  
  244.             case 'o' :
  245.                 printo(i);
  246.                 break;
  247.  
  248.             case 'x' :
  249.                 printx(i);
  250.                 break;
  251.  
  252.             case 'd' :
  253.                 printd(i);
  254.                 break;
  255.  
  256.             case 'u' :
  257.                 printu(i);
  258.                 break;
  259.  
  260.             case 'c' :
  261.                 printc(i);
  262.                 break;
  263.  
  264.             default :
  265.                 err();
  266.                 break;
  267.             }
  268.             break;
  269.  
  270.         case '<' :
  271.             if (*o != '\0') {
  272.                 int l = dtoi(o);
  273.                 i <<= l;
  274.             }
  275.             else {
  276.                 err();
  277.             }
  278.             break;
  279.  
  280.         case '>' :
  281.             if (*o != '\0') {
  282.                 int l = dtoi(o);
  283.                 i >>= l;
  284.             }
  285.             else {
  286.                 err();
  287.             }
  288.             break;
  289.  
  290.         case '?' :
  291.             help();
  292.             break;
  293.  
  294.         default :
  295.             err();
  296.             break;
  297.         }
  298.     }
  299. }
  300.  
  301.  
  302.  
  303. btoi(b)
  304. char *b;
  305. {
  306.     int i = 0;
  307.  
  308.     while (*b == '0' || *b == '1') {
  309.         if (*b == '1') {
  310.             i |= 01;
  311.         }
  312.         ++b;
  313.         i <<= 1;
  314.     }
  315.     return(i >> 1);
  316. }
  317.  
  318.  
  319. otoi(o)
  320. char *o;
  321. {
  322.     int k;
  323.  
  324.     sscanf(o, "%o", &k);
  325.     return(k);
  326. }
  327.  
  328.  
  329. xtoi(x)
  330. char *x;
  331. {
  332.     int k;
  333.  
  334.     sscanf(x, "%x", &k);
  335.     return(k);
  336. }
  337.  
  338.  
  339. dtoi(d)
  340. char *d;
  341. {
  342.     int k;
  343.  
  344.     sscanf(d, "%d", &k);
  345.     return(k);
  346. }
  347.  
  348.  
  349. utoi(d)
  350. char *d;
  351. {
  352.     int k;
  353.  
  354.     sscanf(d, "%u", &k);
  355.     return(k);
  356. }
  357.  
  358.  
  359. ctoi(d)
  360. char *d;
  361. {
  362.     int k;
  363.  
  364.     sscanf(d, "%c", &k);
  365.     return(k & 0xff);
  366. }
  367.  
  368.  
  369. printb(i, g)
  370. int i, g;
  371. {
  372.     short n = 32;
  373.  
  374.     for (; n--; i <<= 1) {
  375.         if (n != 31 && n % g == g - 1)
  376.             putchar(' ');
  377.         if (i < 0) {
  378.             putchar('1');
  379.         }
  380.         else {
  381.             putchar('0');
  382.         }
  383.     }
  384.     putchar('\n');
  385. }
  386.  
  387.  
  388. printo(i)
  389. int i;
  390. {
  391.     printf("%o\n", i);
  392. }
  393.  
  394.  
  395. printx(i)
  396. int i;
  397. {
  398.     printf("%x\n", i);
  399. }
  400.  
  401.  
  402. printd(i)
  403. int i;
  404. {
  405.     printf("%d\n", i);
  406. }
  407.  
  408.  
  409. printu(i)
  410. int i;
  411. {
  412.     printf("%u\n", i);
  413. }
  414.  
  415.  
  416. printc(i)
  417. int i;
  418. {
  419.     printf("%c\n", i);
  420. }
  421.  
  422.  
  423. err()
  424. {
  425.     printf("?\n");
  426. }
  427.  
  428.  
  429. static char msg[] =
  430. "\
  431. b/o/x/d/u/c b/o/x/d/u/c number\n\
  432. b/o/x/d/u/c b/o/x/d/u/c\n\
  433. b/o/x/d/u/c\n\
  434. < n\n\
  435. > n\n\
  436. ";
  437.  
  438. help()
  439. {
  440.     printf("%s", msg);
  441. }
  442.