#include <stdlib.h>		// for exit
#include <unistd.h>		// for getopt
#include <stdio.h>		// for printf, fprintf, fflush
#include <string.h>		// for strtok, memset, memcpy
#include <ctype.h>		// for isdigit

//
// Purpose:	Homework 1, Problem 4
// Usage:	hw1-4 [-v] [-{0|1|2}] [-d] < Command
//			-v	verbose mode (include hex output of buf[])
//			-0	method 0 (ptr casting)
//			-1	method 1 (union)
//			-2	method 2 (variable struct) [ not ANSI-C ]
//			-d	debug mode (output some details)
// Comment:
//   o This is a pedagogic version that illustrates several approaches.
// History:
//	4 sep 2007	kenw, creation
//

// --| constants |--
const int	MAX_LINE = 50;
const int	BUFSZ = 100;
const char	*WHITE = " \t\n";       // white space characters

// --| prototypes |--
void getArgs(int argc, char *argv[]);
int getTokens(char *cmnd, char *word[], const char *delim);
void pkbuf0(int seqnum, int nwords, char *word[]);
void pkbuf1(int seqnum, int nwords, char *word[]);
void pkbuf2(int seqnum, int nwords, char *word[]);

// --| globals |--
int	verbose = 0;
int	method = 0;
int	debug = 0;

// --| defines |--
#define DEBUG(arglst)	if (debug) { fprintf arglst; }

int
main (int argc, char *argv[]) {
  char	cmnd[MAX_LINE];	// command-line
  char	*word[BUFSZ];	// word[k] points to kth word
  int	nwords;		// #words in command line
  int	seqnum = 0;
  int	i;

  getArgs(argc, argv);

  while (fgets(cmnd, MAX_LINE, stdin) != NULL) {
    if (cmnd[strlen(cmnd)-1] != '\n') {
      fprintf(stderr, "*** Ooops, line too long\n");
      exit(1);
    }
    // for (i=0; (i<MAX_LINE) && (cmnd[i] != '\0'); i++) {
    //   printf(" %02x", cmnd[i]);
    // }
    // printf("\n");
    printf("%s", cmnd);		fflush(stdout);
    nwords = getTokens(cmnd, word, WHITE);

    switch(method) {
      case 0:	pkbuf0(seqnum, nwords, word);	break;
      case 1:	pkbuf1(seqnum, nwords, word);	break;
      case 2:	pkbuf2(seqnum, nwords, word);	break;
      default:
      		fprintf(stderr, "*** Bad method = %d\n", method);
		exit(1);
      		break;
    }

    printf("\n"); fflush(stdout);
    ++seqnum;
    if (strcmp(word[0], "quit") == 0)	break;
  }
  return 0;

}

void
getArgs(int argc, char *argv[]) {
  int	c;
  int	ok = 1;
       
  while ((c = getopt(argc, argv, "012dv")) != -1) {
    switch(c) {
      case 'd':
        debug = 1;
      	break;
      case 'v':
        verbose = 1;
      	break;
      case '0':
        method = 0;
      	break;
      case '1':
        method = 1;
      	break;
      case '2':
        method = 2;
      	break;
      default:	
        ok = 0;
	DEBUG( (stderr, "getArgs:  Unknown flag %c\n", c) );
        break;
    }
  }
  if (!ok) {
    fprintf(stderr, "Usage:  hw1-2 [-v] [-{0|1|2}] [-d] < Command\n");
    exit(1);
  }
}

// --| get tokens |--
int
getTokens(char *cmnd, char *word[], const char *delim) {
  int	nwords = 0;
  char	*p = cmnd;
  char	*token;

  while ((token=strtok(p,delim)) != NULL) {
    word[nwords] = token;
    DEBUG( (stderr, "\tword[%d] = %s\n", nwords, token) );
    nwords++;
    p = NULL;
  }
  word[nwords] = NULL;
  return nwords;
}

// --| pack buffer using ptr casting |--
//
// Buffer Structure:
//	  int	seqnum;
//	  char	*str_ptr[nwords];
//	  char	str[BUFSZ-sizeof(seqnum)-nwords*sizeof(char *)];
//
void
pkbuf0(int seqnum, int nwords, char *word[]) {
  char	buf[BUFSZ];	// our buffer
  int	*sn_ptr;	// ptr to seqnum
  char	**str_ptr, **str_ptr_save;	// ptr to char ptr
  char	*str;		// ptr to char str
  int	str_offset;	// index to beginning of strings
  int	i;

  str_offset = sizeof(seqnum) + (nwords+1)*sizeof(char *);
  str = buf + str_offset;
  str_ptr_save = str_ptr = (char **) (buf + sizeof(seqnum));
  sn_ptr = (int *)buf;

  memset(buf, 0x0, BUFSZ);			// zero buffer
  *sn_ptr = seqnum;
  for (i=0; i<nwords; i++) {
    strcpy(str, word[i]);
    *(str_ptr) = str;
    str += (1+strlen(word[i]));
    ++str_ptr;
  }
  *(str_ptr) = 0;		// null ptr
  
  if (debug) {
    printf("buf (debug):\n");
    printf("\t%x\n", *sn_ptr);
    str_ptr = str_ptr_save;
    for (i=0; i<nwords; i++) {
      str = *str_ptr;
      printf("\t%p\t", str);
      while (*str != 0)	printf("%02x ", (u_char) *str++);
      printf("%x", (u_char) *str);
      printf("\n");
      ++str_ptr;
    }
    printf("\t%p\t", *str_ptr);
    printf("\n");
    fflush(stdout);
  }
  if (verbose) {
    printf("buf (verbose):\n");
    printf("%3d ", *sn_ptr);
    str_ptr = str_ptr_save;
    for (i=0; i<nwords; i++) {
      printf("%p ", *str_ptr);
      ++str_ptr;
    }
    printf("%p ", *str_ptr);

    str_ptr = str_ptr_save;
    for (i=0; i<nwords; i++) {
      str = *str_ptr;
      while (*str != 0)	printf("%02x ", (u_char) *str++);
      printf("%x ", (u_char) *str);
      ++str_ptr;
    }
    printf("\n");
    fflush(stdout);
  }
}

// --| pack buffer using union |--
void
pkbuf1(int seqnum, int nwords, char *word[]) {
  struct {
    int	seqnum;
    union {
      char	*str_ptr[BUFSZ/sizeof(char *)];
      char	str[BUFSZ];
    } str_union;
  } buf;			// our buffer
  char	*str_ptr;	// ptr to char str
  int	i;

  str_ptr = &(buf.str_union.str[(nwords+1)*sizeof(char *)]);
  for (i=0; i<nwords; i++) {
    strcpy(str_ptr, word[i]);
    buf.str_union.str_ptr[i] = str_ptr;
    str_ptr += (1+strlen(word[i]));
  }
  *(str_ptr) = 0;		// null ptr
  
  if (debug) {
    printf("buf (debug):\n");
    printf("\t%x\n", buf.seqnum);
    for (i=0; i<nwords; i++) {
      printf("\t%p\t", buf.str_union.str_ptr[i]);
      str_ptr = buf.str_union.str_ptr[i];
      while (*str_ptr != 0)	printf("%02x ", (u_char) *str_ptr++);
      printf("%x", (u_char) *str_ptr);
      printf("\n");
    }
    printf("\t%p\t", buf.str_union.str_ptr[nwords]);
    printf("\n");
    fflush(stdout);
  }
  if (verbose) {
    printf("buf (verbose):\n");
    printf("%3d ", buf.seqnum);
    for (i=0; i<nwords; i++) {
      printf("%p ", buf.str_union.str_ptr[i]);
    }
    printf("%p ", buf.str_union.str_ptr[nwords]);

    for (i=0; i<nwords; i++) {
      str_ptr = buf.str_union.str_ptr[i];
      while (*str_ptr != 0)	printf("%02x ", (u_char) *str_ptr++);
      printf("%x ", (u_char) *str_ptr);
    }
    printf("\n");
    fflush(stdout);
  }
}

// --| pack buffer using variable struct |--
// >>> This approach uses a non-ANSI-C feature <<<
//
void
pkbuf2(int seqnum, int nwords, char *word[]) {
  struct {
    int		seqnum;
    char	*str_ptr[nwords];
    char	str[BUFSZ-nwords*sizeof(char *)];
  } buf;			// our buffer
  char	*str_ptr;	// ptr to char str
  int	i;

  str_ptr = &(buf.str[(nwords+1)*sizeof(char *)]);
  for (i=0; i<nwords; i++) {
    strcpy(str_ptr, word[i]);
    buf.str_ptr[i] = str_ptr;
    str_ptr += (1+strlen(word[i]));
  }
  *(str_ptr) = 0;		// null ptr
  
  if (debug) {
    printf("buf (debug):\n");
    for (i=0; i<nwords; i++) {
      printf("\t%x\n", buf.seqnum);
      printf("\t%p\t", buf.str_ptr[i]);
      str_ptr = buf.str_ptr[i];
      while (*str_ptr != 0)	printf("%02x ", (u_char) *str_ptr++);
      printf("%x", (u_char) *str_ptr);
      printf("\n");
    }
    printf("\t%p\t", buf.str_ptr[nwords]);
    printf("\n");
    fflush(stdout);
  }
  if (verbose) {
    printf("buf (verbose):\n");
    printf("%3d ", buf.seqnum);
    for (i=0; i<nwords; i++) {
      printf("%p ", buf.str_ptr[i]);
      str_ptr = buf.str_ptr[i];
    }
    printf("\t%p\t", buf.str_ptr[nwords]);

    for (i=0; i<nwords; i++) {
      str_ptr = buf.str_ptr[i];
      while (*str_ptr != 0)	printf("%02x ", (u_char) *str_ptr++);
      printf("%x ", (u_char) *str_ptr);
    }
    printf("\n");
    fflush(stdout);
  }
}