Example #1
0
static void loadnode (vpnode *node, int bsize, FILE *f)

{   char hoja;
    hoja = getc(f);
    node->hoja = (hoja == '1');
    if (node->hoja)
    {   fread (&node->u.hoja.size,sizeof(int),1,f);
        node->u.hoja.bucket = loadbucket (node->u.hoja.size,f);
    }
    else
    {   fread(&node->u.interno.query, sizeof(int), 1, f);
        fread (&node->u.interno.dist,sizeof(Tdist),1,f);
        node->u.interno.child1 = malloc (sizeof(vpnode));
        loadnode (node->u.interno.child1,bsize,f);
        node->u.interno.child2 = malloc (sizeof(vpnode));
        loadnode (node->u.interno.child2,bsize,f);
    }
}
Example #2
0
Index loadIndex (char *fname)

{   char str[1024];
    char *ptr = str;
    FILE *f = fopen(fname,"r");
    vpt *tree = malloc (sizeof(vpt));

    while ((*ptr++ = getc(f)));
    tree->descr = malloc (ptr-str);
    strcpy (tree->descr,str);
    tree->np=openDB (str);
    fread (&tree->bsize,sizeof(int),1,f);
    loadnode (&tree->node,tree->bsize,f);
    fclose (f);
    return (Index)tree;
}
Example #3
0
/*
  load newick tree from an opened stream
  Params: fp - input stream
          error - return for error
  Returns: pointer to object, 0 on fail
  Error codes -1 out of memory
              -2 parse error
  Notes: format allows several trees to be stroed in a file 
 */
NEWICKTREE *floadnewicktree(FILE *fp, int *error)
{
  NEWICKTREE *answer;
  int err;
  int ch;

  answer = malloc(sizeof(NEWICKTREE));
  if(!answer)
  {
    err = -1;
    goto error_exit;
  }
  skipspace(fp);
  ch = fgetc(fp);
  if(ch == '(' )
  {
    answer->root = loadnode(fp, &err);
    if(!answer->root || err != 0)
      goto error_exit;
  }
  skipspace(fp);
  ch = fgetc(fp);
  if(ch != ';')
  {
    err = -2;
    goto error_exit;    
  }
  
  if(error)
    *error = 0;
  return answer;

 error_exit:
  killnewicktree(answer);
  if(error)
    *error = err;
  return 0;

}
Example #4
0
/*
  load a node from the file
  Params: fp - the input stream
          error - return for error
  Returns: node loaded.
  Notes: recursive. Expects the opening parenthesis to have been eaten
 */
static NEWICKNODE *loadnode(FILE *fp, int *error)
{
  NEWICKNODE *answer;
  int err;
  NEWICKNODE *child = 0;
  int ch;

  answer = malloc(sizeof(NEWICKNODE));
  if(!answer)
  {
    err = -1;
    goto error_exit;
  }

  answer->Nchildren = 0;
  answer->label = 0;
  answer->child = 0;
  answer->hv1 = 0;
  answer->hv2 = 0;

  skipspace(fp);
  do
  {
    ch = fgetc(fp);
    if(ch == '(')
    {
      child = loadnode(fp, &err);
      if(!child)
        goto error_exit;

      if( addchild(answer, child ) == -1)
      {
        err = -1;
        goto error_exit;
      }
      child = 0;
    }
    else
    {
      ungetc(ch, fp);
      child = loadleaf(fp, &err);
      if(!child)
        goto error_exit;

      if(addchild(answer, child) == -1)
      {
        err = -1;
        goto error_exit;
      }
      child = 0;
    }
    skipspace(fp);
    ch = fgetc(fp);
  } while(ch == ',');

  if(ch == ')')
  {
    answer->label = readlabelandweight(fp, &answer->weight, &err);
    if(err)
      goto error_exit;
  }
  else
  {
    err = -2;
    goto error_exit;
  }
  
  if(error)
    *error = 0;
  return answer;
 error_exit:
  if(child)
    killnoder(child);
  killnoder(answer);
  if(error)
    *error = err;
  return 0;
}