read_nextnano_inputfile.c

Go to the documentation of this file.

/*
** read_nextnano_inputfile.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:18:29 2008 Johnny Q. Hacker
*/

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

#include <libcommon/gcc_hints.h>
#include <libnextnano/read_nextnano_inputfile.h>
#include <libcommon/textfile_common.h>

#define DEFAULT_SECTION "default"
static void destroy_chunklist(gpointer data, gpointer user_data) {
  //fprintf(stderr, "destroying chunklist\n");
  g_hash_table_destroy(data);
}
static void destroy_section(gpointer data) {
  //fprintf(stderr, "destroying section (%p)\n", data);
  g_list_foreach(data, destroy_chunklist, NULL);
}
static void destroy_secname(gpointer data) {
  //fprintf(stderr, "destroying section name (%p)(%s0\n", data, (char*)data);
  /*Free the *line*, not just the string*/
  /*Casting to char* so that we make sure the right size is counted!
   *Thanks, little gcc pedant!*/
  free(((char*)data)-1);
}
static void free_nothing(gpointer data) {
  //fprintf(stderr, "freeing nothing\n");
}
static void free_esec(char* esec) {
  /*free the *line*, not just the string.*/
  //fprintf(stderr, "free_esec: Freeing line, not just char.\n");
  free(esec-5);
}
static void destroy_value(gpointer data, gpointer user_data) {
  //fprintf(stderr, "destroying value\n");
  //free(data);
}
static void destroy_values(gpointer data) {
  //fprintf(stderr, "destroying values\n");
  g_list_foreach(data, destroy_value, NULL);
}
static void destroy_keyword_section(gpointer data) {
  g_hash_table_destroy(((struct nextnano_keyword_section*)data)->keywords);
  free((struct nextnano_keyword_section*)data);
}
static void destroy_keyword(gpointer data) {
  free((struct nextnano_keyword*)data);
}
static void destroy_c_string(gpointer data) {
  free((char*)data);
}


/*If this is a section command, returns the section name.  Otherwise, NULL.
 *NOTE: this may be end_section.
 */
___always_inline char* is_section(char* str) {
  if (str[0] == '$') {
    return &(str[1]);
  }else{
    return NULL;
  }
}

__always_inline char* get_section_end(char* str) {
  if(strncmp(str, "$end_", 5) == 0)
    return &(str[5]);
  else
    return NULL;
}

/*Determines whether or not the key listed will start a new chunk.
 *ARGS:
 *  secname: the name of the section (not currently used, but probably
 *    important in the future when per-section customization is needed.
 *  chunk: the current chunk being worked on
 *  key: the key in question
 *RETURNS:
 * 0 if not a new chunk; 1 if a new chunk.
**/
static int starts_new_chunk(const char* secname, GHashTable* chunk, const char* key) {
  if(chunk == NULL) return 1;
  if(g_hash_table_lookup(chunk, key) != NULL) return 1;
  return 0;
}

/*!
 *\deprecated
 */
GHashTable *read_nextnano_inputfile(GInputStream *istream, GError **err) {
  GHashTable *h = read_nextnano_inputfile_stringy(istream, err);
  if((h == NULL) || (*err != NULL)) return NULL;
  fprintf(stderr, "WARNING: read_nextnano_inputfile: datatype conversion not yet implemented.  Returning stringy data.\n");
  return h;
}

static void print_key_value_item(gpointer data, gpointer userdata) {
  fprintf(stderr, "\t%s", (char*)data);
}

static void print_key_value_lists(gpointer data, gpointer userdata) {
  g_list_foreach(data, print_key_value_item, userdata);
  fprintf(stderr, "\n");
}


/*!
 *\brief this is the core function which processes a nextnano input file.
 *\param istream pointer to a GInputStream to read from
 *\param GError pointer to a GError to store the last error
 *\return GHashTable containing the (stringy) processed input file.
 */
GHashTable *read_nextnano_inputfile_stringy_core(GInputStream *istream, GError **err) {
  GDataInputStream *in = g_data_input_stream_new(istream);
  GHashTable *sections = g_hash_table_new_full(g_str_hash, g_str_equal, destroy_secname, destroy_section);
  if(unlikely(sections == NULL)) return NULL;
  char *str;
  char *sname = NULL;
  gsize len;
  char *sec;
  char *esec;
  char *key;
  char *value;
  GList *def = NULL;
  int n;
  int goodclose;
  /*Current section*/
  GList *s = NULL;
  /*Current chunk*/
  GHashTable *chunk = NULL;
  char *saveptr;
  /*Current value list.*/
  GList *val = NULL;
  GList *tmp = NULL;
  
  while((str = g_data_input_stream_read_line(in, &len, NULL, err)) != NULL) {
    prettify_line(str, '!');
    if((strlen(str)) == 0) continue;
    //fprintf(stderr, "read_nextnano_inputfile: got line (%s)\n", str);
    if((sec = is_section(str)) == NULL) {
      //fprintf(stderr, "*is not a section(%s)\n", str);
      /*Not the beginning or end of a new section.*/
      GList *v = get_key_value_pairs(str, "=");
      /*
      fprintf(stderr, "key/value list for %s:\n", str);
      g_list_foreach(v, print_key_value_lists, NULL);
      printf("\n");
      */
      if(v == NULL) continue;
      GList *c;
      if((g_list_first(v)->data != NULL)) {
  //fprintf(stderr, "APPENDING APPENDED DATA\n");
  /*This ought to preserve the head of val.*/
  val = g_list_concat(val, g_list_first(v)->data);
      }
      /*Go through the list of key/value sets and add them to the list.*/
      for(c = g_list_next(v); c != NULL; c = g_list_next(c)) {
  GList *sl = c->data;
  GList *kl = g_list_first(sl);
  /*
  fprintf(stderr, "\tsl(%p)=%s\n", sl, (char*)((sl == NULL)?NULL:sl->data));
  fprintf(stderr, "*is a new value/key pair: ");
  */
  key = kl->data;
  //fprintf(stderr, "\tsl=%p\n", sl);
  sl = g_list_remove_link(g_list_first(sl), kl);
  //fprintf(stderr, "\tAfter remove_link, sl=%p\n", sl);
  //fprintf(stderr, "key=%s", key);
  if(sname == NULL) {
    fprintf(stderr, "WARNING in read_nextnano_inputfile: have data but does not belong to a section!  Assuming section \"%s\".\n", DEFAULT_SECTION);
    /*If there's no "default" section, create it, add it, then add
      the data.*/
    sname = DEFAULT_SECTION;
  }
  //fprintf(stderr, "*section is: %s\n", sname);
  /*Create a new chunk if we need one; save off the current
    chunk if we're starting a new one.*/
  if((chunk == NULL) || starts_new_chunk(sname, chunk, key)) {
    //fprintf(stderr, "*is a new chunk\n");
    /*We've not yet started a chunk.*/
    chunk = g_hash_table_new_full(g_str_hash, g_str_equal, free, destroy_values);
    /*Go ahead and add the chunk to the section now; 
     * we'll still have the pointer around later to add to the
     * chunk.
     */
    s = g_list_append(s, chunk);
  }
  val = sl;
  g_hash_table_replace(chunk, key, val);
      }
      //fprintf(stderr, "\n*done with key/value pair line.\n");
    }else{
      esec=get_section_end(str);
      if((esec != NULL) || ((sec != NULL) && (sname != NULL))) {
  if(esec != NULL){
    if(sname == NULL) {
      fprintf(stderr, "WARNING: got a request to end section (%s) but there was no section currently open!\n", esec);
      continue;
    }else if(strcmp(esec, sname) != 0) {
      fprintf(stderr, "WARNING: got a request to end section (%s) but a different section is currently open (%s)!\n", esec, sname);
    }     
  }else{
      fprintf(stderr, "WARNING: got a request to start a new section (%s) but a section is still open (%s)!\n", sec, sname);
  }
  /*Now close the section*/
  //fprintf(stderr, "\tinserting %s(%p) into hash table %p\n", sname, (void*)s, (void*)sections);
  if((tmp = g_hash_table_lookup(sections, sname)) == NULL) {
    g_hash_table_replace(sections, sname, g_list_append(NULL, s));
  }else{
    tmp = g_list_append(tmp, s);
  }
  s = NULL;
  sname = NULL;
      }else{
  sname=sec;
      }
      if(esec != NULL) free_esec(esec);
      esec = NULL;
      sec=NULL;
      s = NULL;
      val = NULL;
      chunk = NULL;
    }
  }

  if(sname != NULL) {
    fprintf(stderr, "WARNING: section (%s) wasn't ended before the end of the file.\n", sname);
    if((tmp = g_hash_table_lookup(sections, sname)) == NULL) {
      g_hash_table_replace(sections, sname, g_list_append(NULL, s));
    }else{
      tmp = g_list_append(tmp, s);
    }
    s = NULL;
    sname = NULL;
  }
  g_object_unref(in);
  return sections;
}

void static print_valueitem(gpointer data, gpointer userdata) {
  printf("print_valueitem: data=%p userdata=%p\n", data, userdata);
  if(*((int*)userdata)) {
    printf("\t\t%s\n", (char*)data);
  }else{
    char *format;
    switch(((struct nextnano_value*)data)->t) {
    INT: format="\t\t%d\n"; break;
    DOUBLE: format="\t\t%g\n"; break;
    STRING: format="\t\t%s\n"; break;
    default:
      fprintf(stderr, "PROGRMMING ERROR: unable to recognize value type (%d).  Skipping.\n", ((struct nextnano_value*)data)->t);
      return;
    };
    printf(format, ((struct nextnano_value*)data)->store);
  }
}

void static print_value(gpointer key, gpointer data, gpointer userdata) {
  printf("print_value: key=%p data=%p userdata=%p\n", key, data, userdata);
  printf("\t(%s)\n", (char*)key);
  g_list_foreach(data, print_valueitem, userdata);
}

void static print_chunk(gpointer data, gpointer userdata){
  printf("print_chunk: data=%p userdata=%p\n", data, userdata);
  g_hash_table_foreach(data, print_value, userdata);
  printf("\n");
}

void static print_section(gpointer key, gpointer value, gpointer userdata){
  fprintf(stderr, "print_section: key=%p value=%p userdata=%p\n", key, value, userdata);
  printf("[%s]\n", (char*)key);
  g_list_foreach(value, print_chunk, userdata);
}

void print_stringy_inputfile(GHashTable *h) {
  int stringy = 1;
  g_hash_table_foreach(h, print_section, &stringy);
}

void print_finalized_inputfile(GHashTable *h) {
  int stringy = 0;
  g_hash_table_foreach(h, print_section, &stringy);
}

GHashTable *read_nextnano_dbfile(GInputStream *istream, GError **err) {
  GHashTable *ht = read_nextnano_inputfile_stringy_core(istream, err);
  if(ht == NULL) return ht;
  /*Convert the strings to numbers here.*/
  return ht;
}


static void stick_this_in_the_hash(gpointer key, gpointer data, gpointer hash) {
  g_hash_table_insert(hash, key, data);
}

/*!
 *\deprecated
 */
GHashTable *read_nextnano_inputfile_stringy(GInputStream *istream, GError **err) {
  GHashTable *ht = read_nextnano_inputfile_stringy_core(istream, err);
  GHashTableIter hit;
  g_hash_table_iter_init(&hit, ht);
  gpointer key, value;
  GHashTable *tempt = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, NULL);
  while(g_hash_table_iter_next(&hit, &key, &value)) {
    if(unlikely(g_list_length(((GList*) value)) != 1)) {
      if(unlikely(g_list_length(((GList*) value)) < 1)) {
  fprintf(stderr, "WARNING: PROGRAMMING ERROR: the list for section %s was empty!  This should never happen!\n", (char*)key);
  continue;
      }
      fprintf(stderr, "WARNING: there are duplicate definitions of section %s.  Will be assuming the last definition of the section.\n", (char*)key);
    }
    g_hash_table_iter_steal(&hit);
    g_hash_table_replace(tempt, key, (g_list_last((GList*)value))->data);
      /*Free the list structures for the top-level list.  They're no
      longer needed.*/
    g_list_free((GList*)value);
    //fprintf(stderr, "Raised chunklist to top-level for %s\n", (char*)key);
  }
  g_hash_table_foreach(tempt, stick_this_in_the_hash, ht);
  g_hash_table_steal_all(tempt);
  return ht;
}

/*!
 *\brief Returns the list for a specific part of the input file.
 *\param section     name of the section you want
 *\param secnum      There may be multiple sections that match the name.
 *                This specifies which one you want (in order of
 *                occurrance)
 *\param chunknum    There may be multiple chunks of key/value lists within
 *                each section.  This specifies which which one you
 *                want (in order of occurrance) (NOTE: first chunk is
 *                chunk 0)
 *\param key         Specifies the key within the section.
 *\return
 *  The list associated with the requested key.
 *  NULL if the key wasn't found.
 */
GList* read_nextnano_extract_list_db(GHashTable *input, char* section, int secnum, int chunknum, char* key) {
  return NULL;
}

/*Same as read_nextnano_extract_list_db, but does not allow for
  multiple sections with the same name (for input puts, not db puts)
  * ERROR CODES:
  *  0: if returned non-NULL, success
  *  0: if returned NULL, there was no such key.
  *  1: section doesn't exist.
  *  2: there was no such chunknum (key/value set)
*/

GList* read_nextnano_extract_list(GHashTable *input, char* section, int chunknum, char* key, int *err) {
  GList *chunk = g_hash_table_lookup(input, section);
  if(chunk == NULL) {
    //fprintf(stderr, "chunk was NULL\n");
    *err = 1;
    return NULL;
  }
  GHashTable *kv_set = g_list_nth_data(g_list_first(chunk), chunknum);
  if(kv_set == NULL) {
    //fprintf(stderr, "kv_set was NULL\n");
    *err = 2;
    return NULL;
  }
  //if(g_hash_table_lookup(kv_set, key) == NULL) {fprintf(stderr, "Unable to find key %s in chunk.\n", key);}
  /*g_hash_table_lookup returns NULL if not found, which is a valid
   * 0-length list. */
  *err = 0;
  return g_list_first(g_hash_table_lookup(kv_set, key));
}

/*Same as read_nextnano_extract_list, but converts to type.
 *Same error codes, but
 *  10:   couldn't convert to type.
*/
GList* read_nextnano_extract_list_typed(GHashTable *input, char* section, int chunknum, char* key, int *err, enum data_types type) {
  GList *c;
  GList *l = NULL;
  if(unlikely((c=read_nextnano_extract_list(input, section, chunknum, key, err)) == NULL)) {
    return NULL;
  }
  void *v;
  for(l = c; l != NULL; l = g_list_next(l)) {
    v = string_to_data(c->data, type);
    if(unlikely(v == NULL)) {
      *err = 10;
    }
    l->data = v;
  }
  return c;
}

/*Returns the first value in the key/value list.  If there are
 *  multiple key/value lists, err is set to 1.
 *ARGS:
 *  same as read_nextnano_extract_list
 *  err          pointer to an int to store the error.
 *RETURNS:
 *  the item, or NULL if it wasn't found.
 *ERR VALUES:
 *  Same as read_nextnano_extract_list, except
 *  20: List had incorrect (likely more than 1; could be 0?) number of items.
 */
char* read_nextnano_extract_item(GHashTable *input, char* section, int chunknum, char* key, int* err) {
  GList *values = read_nextnano_extract_list(input, section, chunknum, key, err);
  if(values == NULL) {
    return NULL;
  }
  if(g_list_length(g_list_first(values)) != 1) {
    *err = 20;
    return NULL;
  }
  *err = 0;
  return g_list_first(values)->data;
}

/*Same as above, but now converts types, as requested.
 *ERROR CODES:
 * Same as above, but with:
 * 10: Failed to convert data type from string
 */
void* read_nextnano_extract_item_typed(GHashTable *input, char* section, int chunknum, char* key, int* err, enum data_types type) {
  char *c;
  if(unlikely((c=read_nextnano_extract_item(input, section, chunknum, key, err)) == NULL)) {
    return NULL;
  }
  void *v = string_to_data(c, type);
  if(unlikely(v == NULL)) {
    *err = 10;
  }
  return v;
}


/*!
 *\brief gets the type from a string specifying the type.
 *\param s string to convert to a type
 *\returns enum data_types representing the type.(see gimme_alpha_types.h)
 *\warning assumes s to be null-terminated.
 *\note grep -v '^ *\!' keywords.in | grep -v '^ *\$' | sed 's/ *!.*$//g' | sed 's/ +/ /g' | grep -v '^$' | sed 's/_array//g' | awk '{print $2;}' | sort | uniq -c | less
 *   13 
 *  232 character
 *  654 double
 *  195 integer
 *    1 logical
 *\attetion default is to be a string type, i.e. unconverted.
 */
enum data_types get_type_from_string(const char* s) {
  if(!(strcasecmp(s, "double"))) {
    return DOUBLE_TYPE;
  }else if(!(strcasecmp(s, "double_array"))) {
    return DOUBLE_TYPE;
  }else if(!(strcasecmp(s, "character"))) {
    return STRING_TYPE;
  }else if(!(strcasecmp(s, "integer"))) {
    return INT_TYPE;
  }else if(!(strcasecmp(s, "integer_array"))) {
    return INT_TYPE;
  }else if(!(strcasecmp(s, "logical"))) {
    return BOOLEAN_TYPE;
  }else if(!(strcasecmp(s, "logical_array"))) {
    return BOOLEAN_TYPE;
  }else{
    g_warning("didn't recognize type %s; assuming string to preserve the information", s);
    return STRING_TYPE;
  }
}

/*!
 *\brief determines if a keyword or section is required or optional.
 *\param s string containing either "optional" or "required"
 *\return 0 if optional, 1 if required, 2 if uncertain what was meant.
 *\note 
 *   13 
 *  955 optional
 *  127 required
 */
short int is_required(const char* s) {
  if(!(strcasecmp(s, "optional"))) {
    return 0;
  }else if(!(strcasecmp(s, "required"))) {
    return 1;
  }
  g_warning("read_nextnano_inputfile.c::is_required: got unknown requirement string (%s)", s);
  return 2;
}

/*!
 *\brief processes a line which contains a keyword, and outputs a keyword structure and key name.
 *\param line line of input
 *\param key pointer to a pointer to a string to hold the key name
 *\return pointer to struct nextnano_keyword which has the keyword information.
 */
struct nextnano_keyword* get_keyword_from_line(const char* line, char** key, int seqnum) {
  struct nextnano_keyword* keyword = malloc(sizeof(struct nextnano_keyword));
  *key = NULL;
  if(unlikely(keyword == NULL)) return NULL;
  gchar **set = g_strsplit_set(line, " \t", 4);
  if(unlikely(set[0] == NULL)) {free(keyword); return NULL;}
  if(unlikely(set[1] == NULL)) {free(keyword); free(set[0]); return NULL;}
  if(unlikely(set[2] == NULL)) {free(keyword); free(set[0]); free(set[1]); return NULL;}
  /*if we have 4 sections, we have too many!*/
  if(unlikely(set[3] != NULL)) {free(keyword); free(set[0]); free(set[1]); free(set[2]); free(set[3]); return NULL;}
  keyword->t = get_type_from_string(set[1]);
  if(unlikely((keyword->required = is_required(set[2])) == 2)) {
    free(keyword);
    free(set[0]);
    free(set[1]);
    free(set[2]);
    free(set[3]);
    return NULL;
  }
  *key = set[0];
  keyword->seqnum = seqnum;
  return keyword;
}

/*!
 *\brief processes a line which contains the start of a keyword section, and outputs a keyword structure and key name.
 *\param line line of input
 *\param secname pointer to a pointer to a string to hold the key name
 *\return pointer to struct nextnano_keyword_section which has the keyword information.
 */
struct nextnano_keyword_section* get_keyword_section_from_line(const char* line, char** secname) {
  struct nextnano_keyword_section* keyword_section = malloc(sizeof(struct nextnano_keyword_section));
  *secname = NULL;
  if(unlikely(keyword_section == NULL)) return NULL;
  gchar **set = g_strsplit_set(line, " \t", 3);
  //fprintf(stderr, "set[0]=%s set[1]=%s set[2]=%s\n", (set[0]==NULL)?"(null)":set[0], (set[1]==NULL)?"(null)":set[1], (set[2]==NULL)?"(null)":set[2]);
  if(unlikely(set[0] == NULL)) {free(keyword_section); return NULL;}
  if(unlikely(set[1] == NULL)) {free(keyword_section); free(set[0]); return NULL;}
  /*if we have 3 sections, we have too many!*/
  if(unlikely(set[2] != NULL)) {free(keyword_section); free(set[0]); free(set[1]); free(set[2]); return NULL;}
  if(unlikely((keyword_section->required = is_required(set[1])) == 2)) {
    free(keyword_section);
    free(set[0]);
    free(set[1]);
    return NULL;
  }
  /*We're done with the optional/required keyword*/
  free(set[1]);
  keyword_section->keywords = g_hash_table_new_full(g_str_hash, g_str_equal, destroy_c_string, destroy_keyword);
  *secname = set[0];
  return keyword_section;
}

/*!\brief struct for the keyword_sequence_search_foreach_callback
 */
struct keyword_sequence_search_foreach_info {
  int sought;
  char* found;
};
/*!\brief Static helper function for 
 */
void keyword_sequence_search_foreach_callback(gpointer key, gpointer value, gpointer data) {
  /*wordy, but straightforward; if seqnum = sought, found = key)*/
  if((((struct nextnano_keyword*)value)->seqnum) == (((struct keyword_sequence_search_foreach_info*)data)->sought)) {
      (((struct keyword_sequence_search_foreach_info*)data)->found) = key;
    fprintf(stderr, "Y: key=%s seqnum=%d sought=%d\n", (char*)key, ((struct nextnano_keyword*)value)->seqnum, (((struct keyword_sequence_search_foreach_info*)data)->sought));
  }else{
    fprintf(stderr, "N: key=%s seqnum=%d sought=%d\n", (char*)key, ((struct nextnano_keyword*)value)->seqnum, (((struct keyword_sequence_search_foreach_info*)data)->sought));
  }
}

/*!
 *\brief reads in a nextnano inputfile, as it should be.
 *\param basedir pointer to GFile with the project base directory
 *\param keys ptr to GHashTable containing the processed keywords file
 *\param inputfile integer, "sequence number" of the input file to postprocess
 *\param err ptr to ptr to GError for file read errors
 *\return GHashTable containing the fully postprocessed input file
 *\attention use this version; the original (GInputStream) version is deprecated.
 */
GHashTable *read_nextnano_inputfile2(GFile *basedir, GHashTable *keys, int inputfile, GError **err, char** filename) {
  *filename = NULL;
  if(unlikely((keys == NULL) || (basedir == NULL) || (err == NULL))) return NULL;
  struct keyword_sequence_search_foreach_info kssfi = {.sought = inputfile, .found = NULL};
  g_hash_table_foreach(g_hash_table_lookup(keys, "input_filename"), keyword_sequence_search_foreach_callback, &kssfi);
  if(kssfi.found == NULL) return NULL;
  GFile* infile = g_file_get_child(basedir, kssfi.found);
  GFileInputStream *istream = g_file_read(infile, NULL, err);
  if(*err != NULL) return NULL;
  GHashTable *ht = read_nextnano_inputfile(G_INPUT_STREAM(istream), err);
  GError *e = NULL;
  g_input_stream_close(G_INPUT_STREAM(istream), NULL, &e);
  /*If we fail to close the stream, we almost certainly have bigger
   *issues to worry about! Let the user know of *those* errors, not
   *the close failure*/
  if(e != NULL) g_error_free(e);
  g_object_unref(infile);
  *filename = kssfi.found;
  return ht;
}
/*!
 *\attention Use this variant; the normal version is DEPRECATED*/
GHashTable *read_nextnano_inputfile_stringy2(GFile* basedir, GHashTable *keys, int inputfile, GError **err) {
  if(unlikely((keys == NULL) || (basedir == NULL) || (err == NULL))) return NULL;
  struct keyword_sequence_search_foreach_info kssfi = {.sought = inputfile, .found = NULL};
  g_hash_table_foreach(keys, keyword_sequence_search_foreach_callback, &kssfi);
  if(kssfi.found == NULL) return NULL;
  GFile* infile = g_file_get_child(basedir, kssfi.found);
  GFileInputStream *istream = g_file_read(infile, NULL, err);
  if(*err != NULL) return NULL;
  GHashTable *ht = read_nextnano_inputfile_stringy(G_INPUT_STREAM(istream), err);
  GError *e = NULL;
  g_input_stream_close(G_INPUT_STREAM(istream), NULL, &e);
  /*If we fail to close the stream, we almost certainly have bigger
   *issues to worry about! Let the user know of *those* errors, not
   *the close failure*/
  if(e != NULL) g_error_free(e);
  g_object_unref(infile);
  return ht;
}
GHashTable *read_nextnano_dbfile2(GFile* basedir, GError **err) {
  GFile* dbfile = g_file_get_child(basedir, "database.in");
  GFileInputStream *dbstream = g_file_read(dbfile, NULL, err);
  if(*err != NULL) return NULL;
  GHashTable *ht = read_nextnano_dbfile(G_INPUT_STREAM(dbstream), err);
  GError *e = NULL;
  g_input_stream_close(G_INPUT_STREAM(dbstream), NULL, &e);
  /*If we fail to close the stream, we almost certainly have bigger
   *issues to worry about! Let the user know of *those* errors, not
   *the close failure*/
  if(e != NULL) g_error_free(e);
  g_object_unref(dbfile);
  return ht;
}
/*!
 *\brief reads in a keywords.in file from an istream
 *\param basedir directory in which the project is based
 *\param GError pointer to a pointer to use to store the last i/o error.
 *\return a GHashTable containing the sections of the inputfile.
 */
GHashTable *read_nextnano_keyfile2(GFile* basedir, GError **err) {
  GFile* keyfile = g_file_get_child(basedir, "keywords.in");
  GFileInputStream *keystream = g_file_read(keyfile, NULL, err);
  if(*err != NULL) return NULL;
  GDataInputStream *in = g_data_input_stream_new((GInputStream*)keystream);
  GHashTable *sections = g_hash_table_new_full(g_str_hash, g_str_equal, destroy_c_string, destroy_keyword_section);
  if(unlikely(sections == NULL)) return NULL;
  char *str;
  char *sname = NULL;
  gsize len;
  char *sec;
  char *esec;
  char *key;
  GList *def = NULL;
  int n;
  int goodclose;
  /*Current chunk*/
  char *saveptr;
  /*Current value list.*/
  GList *val = NULL;
  GList *tmp = NULL;
  int seqnum = 1;
  struct nextnano_keyword_section *section = NULL;
  struct nextnano_keyword *keyword;
  while((str = g_data_input_stream_read_line(in, &len, NULL, err)) != NULL) {
    prettify_line(str, '!');
    if((strlen(str)) == 0) continue;
    //fprintf(stderr, "read_nextnano_inputfile: got line (%s)\n", str);
    if((sec = is_section(str)) == NULL) {
      if(section == NULL) {
  *err = g_error_new_literal(DOMAIN_READ_NEXTNANO_INPUTFILE, ERR_NO_START_SECTION, "read_nextnano_inputfile.c::read_nextnano_keyfile2: Error reading keywords.in: there was no section given for these keywords!");
  g_hash_table_destroy(sections);
  return NULL;
      }
      keyword = get_keyword_from_line(str, &key, seqnum++);
      if(keyword == NULL) {
  /*Note that the seqnum won't get decrement if we fail to parse
   *the line; it's still a line, valid or not*/
  *err = g_error_new(DOMAIN_READ_NEXTNANO_INPUTFILE, ERR_BAD_KEYWORD_LINE, "read_nextnano_inputfile.c::read_nextnano_keyfile2: Error reading keywords.in: failed to parse malformed keyword line (%s)", str);
  g_hash_table_destroy(sections);
  return NULL;
      }
      g_hash_table_replace(section->keywords, key, keyword);
    }else{
      esec=get_section_end(str);
      if((esec != NULL) || ((sec != NULL) && (sname != NULL))) {
  if(esec != NULL){
    char *tesec;
    struct nextnano_keyword_section *tmps = get_keyword_section_from_line(esec, &tesec);
    g_hash_table_destroy(tmps->keywords);
    free(tmps);
    if(sname == NULL) {
      g_warning("read_nextnano_inputfile.c::read_nextnano_keyfile2: got a request to end section (%s) but there was no section currently open!\n", esec);
      free(tesec);
      continue;
    }else if(strcmp(tesec, sname) != 0) {
      g_warning("read_nextnano_inputfile.c::read_nextnano_keyfile2: got a request to end section (%s) but a different section is currently open (%s)!\n", esec, sname);
    }     
    free(tesec);
  }else{
    g_warning("read_nextnano_inputfile.c::read_nextnano_keyfile2: got a request to start a new section (%s) but a section is still open (%s)!\n", sec, sname);
  }
  /*Now close the section*/
  //fprintf(stderr, "\tinserting %s(%p) into hash table %p\n", sname, (void*)s, (void*)sections);
  g_hash_table_replace(sections, sname, section);
  sname = NULL;
      }else{
  /*New section*/
  if(unlikely((section = get_keyword_section_from_line(sec, &sname)) == NULL)) {
    g_warning("read_nextnano_inputfile.c::read_nextnano_keyfile2: failed to parse section name (%s)!", sec);
    /*Sequence numbers start at 1.*/
  }
  seqnum=1;
      }
      if(esec != NULL) free_esec(esec);
      esec = NULL;
      sec=NULL;
      seqnum=1;
    }
  }

  if(sname != NULL) {
    g_warning("read_nextnano_inputfile.c::read_nextnano_keyfile2: section (%s) wasn't ended before the end of the file.\n", sname);
    g_hash_table_replace(sections, sname, section);
    sname = NULL;
  }
  GError *e = NULL;
  g_input_stream_close(G_INPUT_STREAM(keystream), NULL, &e);
  /*If we fail to close the stream, we almost certainly have bigger
   *issues to worry about! Let the user know of *those* errors, not
   *the close failure*/
  if(e != NULL) 
    g_error_free(e);
  g_object_unref(in);
  return sections;
}