/**
 * interpret: Given a serquence of eight bits (given on the command line),
 *   print out interpretations of that sequence in lots of different forms.
 */

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

// +-------+----------------------------------------------------------
// | Notes |
// +-------+

/*
  We'll pass around the bits as arrays of 0's and 1's.
 */

// +---------+--------------------------------------------------------
// | Helpers |
// +---------+

int
interpret_unsigned (int bits[])
{
  int result;
  int pos;
  int i;

  for (result = 0, pos = 1, i = 7; i >= 0; i--, pos *= 2)
    {
      result += bits[i] * pos;
    }

  return result;
} // interpret_unsigned

int
interpret_signed (int bits[])
{
  int result;
  int sign = bits[0];

  bits[0] = 0;
  result = interpret_unsigned (bits);
  bits[0] = sign;

  if (sign)
    return -result;
  else
    return result;
} // interpret_signed

int
interpret_ones_complement (int bits[])
{
  int newbits[8];
  int i;

  if (bits[0])
    {
      // Flip all the bits
      for (i = 0; i < 8; i++)
        newbits[i] = 1 - bits[i];
      return -1 * interpret_unsigned (newbits);
    }
  else
    {
      return interpret_unsigned (bits);
    }
} // interpret_ones_complement

int
interpret_twos_complement (int bits[])
{
  if (bits[0])
    {
      return interpret_ones_complement (bits) - 1;
    }
  else
    return interpret_unsigned (bits);
} 

int
interpret_news_complement (int bits[])
{
  int i;
  int newbits[8];
  int carry;

  if (bits[0])
    {
      // Flip all the bits
      for (i = 0; i < 8; i++)
        newbits[i] = 1 - bits[i];
      // Add 1
      carry = 1;
      for (i = 7; (carry == 1) && (i > 0); i--)
        {
          if (newbits[i])
            newbits[i] = 0;
          else
            {
              newbits[i] = 1;
              carry = 0;
            }
        } // for
      // And negate
      return -1 * interpret_unsigned (newbits);
    }
  else
    return interpret_unsigned (bits);
} // interpret_twos_complement

int
interpret_excess_128 (int bits[])
{
  return interpret_unsigned (bits) - 128;
} // interpret_excess_128


// +------+-----------------------------------------------------------
// | Main |
// +------+

int
main (int argc, char *argv[])
{
  int bits[8];          // The bits we'll interpret
  int i;                // Counter variable
  int errors = 0;       // Count of errors

  // Check parameters
  if (argc != 9)
    {
      printf ("Usage: bits b7 b6 b5 b4 b3 b2 b1 b0\n");
      return EXIT_FAILURE;
    }

  // Convert parameters
  for (i = 0; i < 8; i++)
    {
      if (strcmp (argv[i+1], "0") == 0)
        bits[i] = 0;
      else if (strcmp (argv[i+1], "1") == 0)
        bits[i] = 1;
      else
        {
          printf ("Invalid parameter: %s\n", argv[i+1]);
          ++errors;
        }
    } // for
  if (errors)
    {
      printf ("Usage: bits b7 b6 b5 b4 b3 b2 b1 b0\n");
      return EXIT_FAILURE;
    }

  printf ("Unsigned:         %4d\n", interpret_unsigned (bits));
  printf ("Signed magnitude: %4d\n", interpret_signed (bits));
  printf ("One's complement: %4d\n", interpret_ones_complement (bits));
  printf ("Two's complement: %4d\n", interpret_twos_complement (bits));
  printf ("Excess 128:       %4d\n", interpret_excess_128 (bits));

  return EXIT_SUCCESS;
} // main