/*
 * Copyright 2011 Steven Gribble
 *
 *  This file is the solution to an exercise problem posed during
 *  one of the UW CSE 333 lectures (333exercises).
 *
 *  333exercises is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  333exercises is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with 333exercises.  If not, see <http://www.gnu.org/licenses/>.
 */

// Lecture 6 exercise 1
//
// Write a program that:
// - prompts the user to input a string (use fgets())
//   - assume the string is a sequence of whitespace-separated integers
//   - e.g., "5555 1234 4 5543"
// - converts the string into an array of integers
// - converts an array of integers into an array of strings
//    - where each element of the string array is the binary representation
//      of the associated integer
// - prints out the array of strings

#include <stdio.h>    // for NULL
#include <stdlib.h>   // for malloc(), realloc(), free()
#include <assert.h>   // for assert()
#include <string.h>   // for string manipulation functions

// Reads a line of input from stdin using fgets(), or
// NULL on error.  Caller is responsible for free()'ing the
// returned string.  Does not include a newline at the
// end of the string.
char *GetNextLine(void);

// Converts the string to an array of integers, and returns
// the array and the array length.  (Array length is returned
// through the output parameter "retarraylen".)
//
// Caller is responsible for free()'ing the returned array.
//
// Returns NULL on error.
int *ToIntArray(char *string, int *retarraylen);

// Converts an integer array into an array of strings,
// where each string is the binary representation of the
// associated integer.
//
// Returns the array of strings, or NULL on error.
// Caller is responsible for free()'ing each string in
// the returned array, as well as the array itself.
char **ToBitStrArray(int *intarray, int arrlen);

int main(int argc, char **argv) {
  while (1) {
    char *nextline;
    int arraylen, i;
    int *integerarray;
    char **outstring;

    // Read the next line of input.
    nextline = GetNextLine();
    assert(nextline != NULL);

    // Convert to an integer array.
    integerarray = ToIntArray(nextline, &arraylen);
    assert(integerarray != NULL);
    free(nextline);

    // Convert to an array of strings.
    outstring = ToBitStrArray(integerarray, arraylen);
    assert(outstring != NULL);
    free(integerarray);

    // Print out, also free()'ing as we go.
    for (i = 0; i < arraylen; i++) {
      if (i == (arraylen-1))
        printf("%s\n", outstring[i]);
      else
        printf("%s ", outstring[i]);
      free(outstring[i]);
    }
    free(outstring);
  }
  // Never gets here. :)
  return EXIT_SUCCESS;
}


// It would have been easier to implement this using the C
// "getline()" function, but we were told to implement it using
// fgets(), i.e., stream reads from stdin.  Oh well!
char *GetNextLine(void) {
  char *linestr = NULL;
  int count = 0;

  // Initialize linestr to contain a NULL-terminated
  // string.  We'll grow it one character at a time
  // using realloc().  ("man realloc")
  linestr = (char *) malloc(1 * sizeof(char));
  if (linestr == NULL)
    return NULL;
  linestr[0] = '\0';

  fprintf(stdout, "Enter next array of integers:\n");
  while (1) {
    // Allocate space for the next character + NULL. Yes, this
    // is not the most elegant use of realloc(), but it gets the
    // job done. ;)
    linestr = realloc(linestr, count+2);
    if (linestr == NULL) {
      free(linestr);
      return NULL;
    }

    // Read in the next character.  Note fgets reads (size-1)
    // characters and adds a '\0', so we need size=2.
    if (fgets(&(linestr[count]), 2, stdin) == NULL) {
      // We hit the end of stdin. Return our string.
      return linestr;
    }
    if (linestr[count] == '\n') {
      // We hit the end of a line.  Return our string, but overwrite
      // the newline with '\0'.
      linestr[count] = '\0';
      return linestr;
    }
    // fall through to next loop.
    count++;
  }
}

int *ToIntArray(char *string, int *retarraylen) {
  int *retarray = NULL;
  char *nexttok = NULL;
  int arrlen = 0;

  // We'll use strtok to split up the string into
  // whitespace-separated tokens.  "man strtok"
  nexttok = strtok(string, " \t");
  while (nexttok != NULL) {
    // Convert the token into an integer using sscanf.
    // "man sscanf"
    int nextint, res;
    res = sscanf(nexttok, "%d", &nextint);
    if (res == 0) {
      // bogus string (not an integer), so return failure.
      if (retarray != NULL)
        free(retarray);
      return NULL;
    }

    // Got it! realloc the array and add the integer in.
    arrlen++;
    retarray = realloc(retarray, arrlen * sizeof(int));
    if (retarray == NULL) {
      // out of memory.
      return NULL;
    }
    retarray[arrlen-1] = nextint;

    // Parse the next token and loop around.
    nexttok = strtok(NULL, " \t");
  }

  // Return our results.
  *retarraylen = arrlen;
  return retarray;
}

char **ToBitStrArray(int *intarray, int arrlen) {
  assert(arrlen != 0);

  // We know we have a valid array of integers,
  // and we know an integer is sizeof(int) bytes
  // long.  So, we know exactly how much memory
  // we need to allocate.  Allocate it all up front.
  int i;

  // Allocate the string array.
  char **stringarray = (char **) malloc(arrlen*sizeof(char *));

  if (stringarray == NULL)
    return NULL;

  // Loop through to malloc each string in the string array.
  for (i = 0; i < arrlen; i++) {
    int j, mallocsize, nextbyte;

    // need 8*sizeof(int) bytes for the bit rep, plus 1 byte for null
    mallocsize = 8 * sizeof(int) + 1;
    stringarray[i] = (char *) malloc(mallocsize * sizeof(char));
    if (stringarray[i] == NULL) {
      // out of memory.  Free everything, then return NULL.
      for (j = 0; j < i; j++)
        free(stringarray[j]);
      free(stringarray);
      return NULL;
    }

    // Do the bit-by-bit string build up.  We'll go right-to-left.
    nextbyte = intarray[i];
    for (j = 0; j < (mallocsize - 1); j++) {
      int nextbit;

      // Mask out all but the last bit of the integer.
      nextbit = nextbyte & 0x01;
      if (nextbit == 0)
        stringarray[i][mallocsize - 2 - j] = '0';
      else
        stringarray[i][mallocsize - 2 - j] = '1';

      // shift the int to the right by 1 bit
      nextbyte = nextbyte >> 1;
    }
    // Add the null terminator for this string, then loop
    // back up to do the next string in the string array.
    stringarray[i][mallocsize-1] = '\0';
  }

  // All done!
  return stringarray;
}