/* $Id: ubf_a.c,v 1.4 2003/11/13 20:16:37 hal Exp $ */

#include <stdio.h>
#include <stdlib.h>
#include "ubf_a.h"


/*********************
 * allocate a ubf_a term
 * return NULL on failure
 * pass in type (will set this in the new struct)
 *********************/
ubfa_term_t *
new_ubfa_term(ubfa_type_t t) {
  ubfa_term_t * r;
  r = (ubfa_term_t *)malloc(sizeof(ubfa_term_t));
  if(r) {
    r->t = t;
    r->g = NULL;
  }
  return r;
}

/*********************
 * allocate a ubf_a term
 * return NULL on failure
 * pass in type (will set this in the new struct)
 * and buf_len
 * if buf_len > 0, allocate that many bytes as well
 *********************/

ubfa_term_t *
new_ubfa_term_buf(ubfa_type_t t, int buf_len) {
  ubfa_term_t * r;
  r = (ubfa_term_t *)malloc(sizeof(ubfa_term_t));
  if(r) {
    r->t = t;
    if(buf_len > 0) {
      r->d.buf = (unsigned char *)malloc(buf_len);
      if(r->d.buf == NULL) {
        free(r);
        r = NULL;
      }
    }
  }
  return r;
}

ubfa_term_t *
new_ubfa_empty(void) {
  return new_ubfa_term(ubfa_empty);
}

#define PAD ".."
static void
i(int level) {
  int i;
  for (i = 0; i < level; i++)
    printf("%s", PAD);
}

#define MAXBLEN 1024
unsigned char bf[MAXBLEN];

/* XXX not reentrant */
/* replace nul's with '*' and append nul byte */
unsigned char *
bin_data_to_str(unsigned char * c, int len) {
  int lim = len;
  unsigned char * cp;
  int i;

  if(lim >= MAXBLEN)
    lim = MAXBLEN - 1;
  cp = bf;
  for(i = 0;i < lim; i++) {
    if (*c)
      *cp = *c;
    else
      *cp = '*';
    cp++; c++;
  }
  *cp = '\0';
  return bf;
}

#define INIT_LEVEL 1

static void
ubfa_print_indent(ubfa_term_t * u, int level) {
  ubfa_list_node_t *w;

  i(level);
  if(u == NULL) {
    printf("NULL\n");
  } else {
    printf("type ");
    switch(u->t) {
    case ubfa_integer:
      printf("integer\n");
      i(level);
      printf("value %ld\n", u->d.i);
      if (u->g) {
        i(level);
        printf("tag %s\n", u->g);
      }
      break;
    case ubfa_string:
      printf("string length %d\n", u->len);
      i(level);
      printf("value %s\n", u->d.buf);
      if (u->g) {
        i(level);
        printf("tag %s\n", u->g);
      }
      break;
    case ubfa_binary:
      printf("binary length %d\n", u->len);
      i(level);
      printf("value %s\n",bin_data_to_str(u->d.buf,u->len));
      if (u->g) {
        i(level);
        printf("tag %s\n", u->g);
      }
      break;
    case ubfa_const:
      printf("const length %d\n", u->len);
      i(level);
      printf("value %s\n", u->d.buf);
      if (u->g) {
        i(level);
        printf("tag %s\n", u->g);
      }
      break;
    case ubfa_struct:
      printf("struct arity %d\n", u->len);
      w = u->d.list.first;
      while(w) {
        ubfa_print_indent(&(w->term), level + 1);
        w = w->next;
      }
      break;
    case ubfa_list:
      printf("list arity %d\n", u->len);
      w = u->d.list.first;
      while(w) {
        ubfa_print_indent(&(w->term), level + 1);
        w = w->next;
      }
      break;
    case ubfa_empty:
      if(level > INIT_LEVEL)
        printf("OOOPS ");
      printf("empty\n");
      break;
    case ubfa_tag:
      printf("OOOPS tag\n");
      i(level);
      printf("value %s\n", u->d.buf);
      break;
    case ubfa_bin_data:
      printf("OOOPS bin_data\n");
      break;
    default:
      printf("UNK!!!\n");
    }
  }
  printf("\n");
}

void
ubfa_print(ubfa_term_t * u) {
  ubfa_print_indent(u, INIT_LEVEL);
}

ubfa_list_node_t *
new_ubfa_list_node(void) {
  ubfa_list_node_t * r;
 
  r = (ubfa_list_node_t *)malloc(sizeof(ubfa_list_node_t));
  return r;
}