textfile_common.c

Go to the documentation of this file.

/*
** textfile_common.c
** 
** Made by (Johnny Q. Hacker)
** Login   <solarion@borkborkbork>
** 

    Copyright (C) 2008 Joseph Pingenot

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program 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 Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

** Started on  Mon Sep 29 16:22:43 2008 Johnny Q. Hacker
** Last update Wed Oct  1 09:47:52 2008 Johnny Q. Hacker
*/

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "gimme_alpha_types.h"
#include "textfile_common.h"
#include "gcc_hints.h"

/*Removes leading and trailing whitespace, comments, and reduces
  redundant whitespace down to one tab, makes an empty line an empty string.*/
hotfunc void prettify_line(char *line, char comment) {
  register char *look;
  register char *write;
  register int in_whitespace;
  register int leading_whitespace;
  for(look=write=line, in_whitespace=0, leading_whitespace=1; *look != '\0'; look++) {
#ifdef DEBUG_2
    fprintf(stderr, " look=%d(%c) write=%d(%c) in_whitespace=%d leading_whitespace=%d: ", (look-line), *look, (write-line), *write, in_whitespace, leading_whitespace);
#endif
    if(*look == comment) {
#ifdef DEBUG_2
      fprintf(stderr, "comment\n");
#endif
      *write = '\0';
      break;
    }
    switch(*look) {
    case ' ':
    case '\n':
    case '\r':
    case '\t':
#ifdef DEBUG_2
      fprintf(stderr, "whitespace\n");
#endif
      if((!leading_whitespace) && (!in_whitespace)) *write++ = '\t';
      in_whitespace=1;
      break;
    default:
#ifdef DEBUG_2
      fprintf(stderr, "default\n");
#endif
      *write++ = *look;
      in_whitespace=leading_whitespace=0;
    }
  }
  *write='\0';
  for(look=write=line; *look != '\0'; look++) {
    switch(*look) {
    case ' ':
    case '\n':
    case '\t':
      if(*(look+1) == '\0') {
  *look = '\0';
      }
    }
  }
}

static void print_list(gpointer s, gpointer u) {
  printf("\t\t(%s)\n", (char*)s);
}
static void print_lists(gpointer s, gpointer u) {
  g_list_foreach(g_list_first(s), print_list, u);
  if(s == NULL) printf("[null list]\n");
  printf("\n");
}

/*Use strtok to split this string into a sublist*/
static void split_list_into_sublist(gpointer s, gpointer listlist) {
  GList *slist = NULL;
  GList **ll = (GList **)listlist;
  char *p;
  char *saveptr = NULL;
  //fprintf(stderr, "\tsplit_list_into_sublist: listlist=%p(%p), s=(%s)\n", listlist, (listlist==NULL)?NULL:(*ll), (char*)s);
  slist = g_list_append(slist, strtok_r((char*)s, "\t", &saveptr));
  while((p=strtok_r(NULL, "\t", &saveptr)) != NULL) {
    //fprintf(stderr, "\t\tp=(%s)\n", p);
    slist = g_list_append(slist, p);
  }
  *ll = g_list_append(*ll, slist);
}

/*Simple: if the key is not NULL, add it to the front of this list.
 *Then take the last item from our list and set key to it.
 *RETURNS:
 *  The new head of the sublist in list.
 */
static void pop_n_push_keys(void** l, GList** k) {
  if(unlikely((l == NULL) || (k == NULL))) return;
  GList **list = (GList**)l;
  /*
  fprintf(stderr, "\tpop_n_push_keys: list=%p(%p) key=%p(%p)\n", list, *list, k, *k);
  fprintf(stderr, "\t\tList status:\n");
  if(*list == NULL) {
    fprintf(stderr, "\t\t(nil)\n");
  }else{ 
    g_list_foreach(*list, print_list, NULL);
  }
  */
  if((*k) != NULL) {
    //fprintf(stderr, "\t\tkey=%s\n", (char*)((*k)->data));
    *list = g_list_concat(*k, g_list_first(*list));
    //fprintf(stderr, "\t\tafter prepend: list=%p key=%p (%s)\n", *list, *k, (char*)((*k)->data));
  }
  /*
  fprintf(stderr, "\t\tList status:\n");
  if(*list == NULL) {
    fprintf(stderr, "\t\t(nil)\n");
  }else{ 
    g_list_foreach(*list, print_list, NULL);
  }
  */
  *k = g_list_last(*list);
  /*
  fprintf(stderr, "\t\tafter setting k: list=%p key=%p (%s)\n", *list, *k, (char*)((*k)->data));
  fprintf(stderr, "\t\tList status:\n");
  if(*list == NULL) {
    fprintf(stderr, "\t\t(nil)\n");
  }else{ 
    g_list_foreach(*list, print_list, NULL);
  }
  */
  *list = g_list_remove_link(*list, *k);
  /*
  fprintf(stderr, "\t\tafter removing k: list=%p key=%p (%s)\n", *list, *k, (char*)((*k)->data));
  fprintf(stderr, "\t\tList status:\n");
  if(*list == NULL) {
    fprintf(stderr, "\t\t(nil)\n");
  }else{ 
    g_list_foreach(*list, print_list, NULL);
  }
  */
}

/*gets all of the key/value pairs on a line.
 *ARGS:
 *  s the string to parse
 *  delim key/value delimiter(s)
 *  space space character(s)
 *RETURNS:
 *  A list of list of key/value pairs, with the first entry in each
 *being the key for that value.
 *  The *first* list in the list returned, however, is any initial
 *values that may be present on the line (i.e. values which came
 *before the first key).  This may be (and hopefully is) an empty list.
 */
GList *get_key_value_pairs(char* s, const char *delim) {
  GList *l = NULL;
  GList *slist = NULL;
  char *p;
  char *saveptr;
  //fprintf(stderr, "get_key_value_pairs: got string (%s) and delim=(%s)\n", s, delim);
  slist = g_list_append(slist, strtok_r(s, delim, &saveptr));
  while((p=strtok_r(NULL, delim, &saveptr)) != NULL) {
    slist = g_list_append(slist, p);
  }
  g_list_foreach(slist, split_list_into_sublist, &l);
  GList *key = NULL;
  /*
  fprintf(stderr, "\tafter splitting into sublists:\n");
  g_list_foreach(l, print_lists, NULL);
  */
  GList *i;
  for(i = g_list_first(l); i != NULL; i = g_list_next(i)) {
    pop_n_push_keys(&(i->data), &key);
  }
  g_list_last(l)->data = g_list_concat(g_list_first(g_list_last(l)->data), key);
  /*
  fprintf(stderr, "\tafter appending the popped key:\n");
  g_list_foreach(g_list_first(l), print_lists, NULL);
  */
  g_list_free(slist);
  return l;
}

static void free_if_not_null(gpointer data) {
  if(data != NULL) free(data);
}


/*Return a list contaning hashes with the column titles as keys.
 *ARGS:
 *  istream   input stream to read data from (the first line is the
 *              title line, which provides titles to be used in the
 *              hashes.  The columns are separated by whitespace.
 *              Multiple whitespaces are ignored (i.e. all columns
 *              MUST have a value in them.
 *  err       pointer to a pointer to hold any error that might occur
 *  titles    pointer to a pointer to a GList where the list of titles
 *              will be kept.  These are required to get the data out
 *              of the hashes.  If titles already exists, it will be
 *              used and the first line will be considered to be
 *              ordinary data.
 *  comment   the character that represents the start of a comment
 *RETURNS:
 *  a pointer to a GList of hashes which contain the values (double
 *     precision float); the keys are the respective column title.
 * OR
 *  NULL if reading failed.
 */
GList* read_titled_whitespaced_data(GInputStream *istream, GError **err, GList **titles, char comment, enum data_types t) {
  GDataInputStream *in = g_data_input_stream_new(istream);
  GList *l = NULL, *slist=NULL;
  char *str, *p, *saveptr;
  GList *ct, *cs;
  int got_title=0;
  GHashTable *h=NULL;
  gsize len;
  //void *ptr;

  if(*titles != NULL) {
    got_title=1;
    /*We have to invert the list because it needs to be inverted for
      the later logic. and also because it'll be re-inverted at the end.*/
    *titles = g_list_reverse(*titles);
  }

  /*Note: although ordering will be reversed (for speed) from what's
   * in the file, since both title and row lists are reversed, they
   * work out to be the same.  Ordering in the hash is irrelevant.
   * However, beacuse the user probably wants the titles to be in the
   * same order as in the file, we'll reverse the order of that before
   * returning.
   */
  int i = -1;;
  while((str = g_data_input_stream_read_line(in, &len, NULL, err)) != NULL) {
    //fprintf(stderr, "got line: %s\n", str);
    prettify_line(str, comment);
    if((strlen(str)) == 0) continue;
    slist = g_list_prepend(NULL, strtok_r(str, "\t", &saveptr));
    while((p=strtok_r(NULL, "\t", &saveptr)) != NULL) {
      slist = g_list_prepend(slist, p);
    }
    if(unlikely(!got_title)) {
      //fprintf(stderr, "Got titles\n");
      *titles = slist;
      got_title=1;
    }else{
      i++;
      //fprintf(stderr, "Got row\n");
      h = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, free_if_not_null);
      //fprintf(stderr, "%d\t", i);
      for(ct=g_list_first(*titles), cs=g_list_first(slist); 
    (ct != NULL) && (cs != NULL); 
    ct = g_list_next(ct), cs=g_list_next(cs)) {
  /*
  ptr = string_to_data(cs->data, t);
  fprintf(stderr, "\tdata=%s\tp=%p\ttitle=%s\n", (char*)cs->data, ptr, (char*)ct->data);
  g_hash_table_replace(h, ct->data, ptr);
  char s[128];
  sprintf(s, "%%s -> %s\t", format_string_for_type_print(t));
  fprintf(stderr, s, cs->data,
  *(double*)string_to_data(cs->data, t));
  */
  g_hash_table_replace(h, ct->data, string_to_data(cs->data, t));
      }
      //fprintf(stderr, "\n");
      l = g_list_prepend(l, h);
      h = NULL;
      //Free the temporary row storage list.
      g_list_free(slist);
      if(unlikely((ct != NULL) || (cs != NULL))) {
  if(ct != NULL)
    fprintf(stderr, "WARNING: there are more titles than columns in this row (%s)!\n", str);
  else
    fprintf(stderr, "WARNING: there are more columns than titles in this row (%s)!\n", str);
      }
    }
  }

  /*Reverse the ordering of rows (they were prepended for performance)*/
  l = g_list_reverse(l);
  /*And also for titles.*/
  *titles = g_list_reverse(*titles);
  return l;
}