parse.c

speech signal process tools

/* Copyright (c) 1995 Entropic Research Laboratory, Inc. */
/*
 * This material contains unpublished, proprietary software of 
 * Entropic Research Laboratory, Inc. Any reproduction, distribution, 
 * or publication of this work must be authorized in writing by Entropic 
 * Research Laboratory, Inc., and must bear the notice: 
 *
 *    "Copyright (c) 1987-1990  AT&T, Inc.
 *    "Copyright (c) 1986-1990  Entropic Speech, Inc. 
 *    "Copyright (c) 1990-1993  Entropic Research Laboratory, Inc. 
 *                   All rights reserved"
 *
 * The copyright notice above does not evidence any actual or intended 
 * publication of this source code.     
 *
 * Written by:  David Talkin
 *
 */
/* parse.c */
/*  string handling for keyword-value implementation */

#ifndef lint
static char *sccs_id = "@(#)parse.c	1.20	9/26/95	ATT/ERL";
#endif

#include <stdio.h>
#include <ctype.h>
#include <Methods.h>
#include <w_lengths.h>

#define TRUE 1
#define FALSE 0

extern int w_verbose;
extern int debug_level;

typedef struct list {
  char *str;
  struct list *next;
} List ;

char *read_all_types(), *malloc();

#define WhiteSpace(ch) ((ch) == ' ' || (ch) == '\t' || (ch) == '\n')

/***********************************************************************/
strnscan(src,dest,len)
     char *src, *dest;
{
  int i = 0;
  
  if (!src || !dest) return(0);		/* check pointers */
  while (WhiteSpace(*src)) src++;
  len--;			/* leave room for trailing NULL */
  while (i<len && *src && !WhiteSpace(*src)) {
    *dest++ = *src++;		/* don't copy whitespace or NULL */
    i++;
  }
  *dest = '\0';			/* end of string */
  if (i>=len && *src && !WhiteSpace(*src)) {
    fprintf(stderr,"strnscan: truncated word %s\n",dest);
  }
  return(i);			/* return # bytes copied */
}

/***********************************************************************/
char *
get_next_item(list)
     register char *list;
{
  while(*list && ((*list == ' ') || (*list == '\t'))) list++;
  while(*list && (*list != ' ') && (*list != '\t') && (*list != '\n')) list++;
  while(*list && ((*list == ' ') || (*list == '\t') ||
		  (*list == '\n')))
    list++;
  return(list);
}

/***********************************************************************/
char *
get_line_item(list)
     register char *list;
{
  while(*list && ((*list == ' ') || (*list == '\t'))) list++;
  while(*list && (*list != ' ') && (*list != '\t') ) list++;
  while(*list && ((*list == ' ') || (*list == '\t') ))  list++;
  return(list);
}

/***********************************************************************/
char *
get_next_line(list)
     register char *list;
{
  if (!list) return(NULL);
  for ( ; *list; ++list) {
    if (*list == '\n') return(++list);
  }
  return(list);
}

/***********************************************************************/
char *
basename(path)
     char *path;
{
  register char *p;
  register int i;

  if(path && *path) {
    p = path + (i = strlen(path)) - 1;
    while(--i)
      if(*--p == '/') return( ++p);
    return(p);
  }
  return(path);
}

/***********************************************************************/
char *
basename2(path)
     char *path;
{
  static char shold[NAMELEN];
  register char *p;
  register int i;

  if(!path)
    return(NULL);

  if(*path) {
    p = path + (i = strlen(path)) - 1;
    while(--i)
      if(*--p == '/') {
	p++;
	break;
      }
    strcpy(shold,p);
  } else
    *shold = 0;
  return(shold);
}

/***********************************************************************/
static Selector *changed_items[300];
static int items_changed = 0;
/***********************************************************************/
Selector **get_changed_items()
{
  return(changed_items);
}
     
/***********************************************************************/
was_changed(item)
     char *item;
{
  int i;
  for(i=0; (i < items_changed) && changed_items[i]; i++)
    if(!strcmp(item,changed_items[i]->name))
      return(TRUE);
  return(FALSE);
}

/***********************************************************************/
reset_changed_items()
{
  changed_items[0] = NULL;
  items_changed = 0;
}
  
/***********************************************************************/
get_args(alist, adscr)
     register char *alist;
     Selector *adscr;
{
  changed_items[0] = NULL;
  items_changed = 0;
  return(get_args_raw(alist, adscr));
}

/***********************************************************************/
get_args_raw_orig(alist, adscr)
     register char *alist;
     Selector *adscr;
{
  register int gotsome = 0, gotone, n;
  char name[NAMELEN], junk[MES_BUF_SIZE];
  char *parsed_as;
  register Selector *ad, *ad2;


  if(alist && *alist && adscr) {
    while((*alist == ' ') || (*alist == '\t'))
      alist++;			/* skip initial blanks */
    while(*alist && (*alist != '\n')) {
      strnscan(alist,name,sizeof(name));
      if(! *(alist = get_line_item(alist))) {
	fprintf(stderr,"No argument for selector %s\n",name);
	if (debug_level > 1 || w_verbose > 1)
	    fprintf(stderr,"Got %d args\n", gotsome);
	if(items_changed < 300)
	  changed_items[items_changed] = NULL;
	return(gotsome);
      }
      n = strlen(name);
      ad = adscr;
      gotone = 0;
      while(ad) {
	if(!strncmp(name,ad->name,n)) {
	  parsed_as = ad->name;
	  if(strlen(ad->name) != n) {
	    ad2 = ad->next;		/* check for uniqueness */
	    while(ad2) {
	      if(!strncmp(name,ad2->name,n)) /* found another match... */
		break;
	      ad2 = ad2->next;
	    }
	  } else
	    ad2 = NULL;
	  if(!ad2) {		/* reached end with no dups. */
	    alist = (char*)read_all_types(alist,ad->format,ad->dest);
	    if(items_changed < 300)
	      changed_items[items_changed++] = ad;
	    gotsome++;
	    gotone = 1;
	  }
	  break;
	} else
	  ad = ad->next;
      }

      if (debug_level > 1 || w_verbose > 1) {
	if(gotone)
	  fprintf(stderr,"Parsed attribute %s as %s (raw)\n", name, parsed_as);
	else
	  fprintf(stderr,"Attribute %s not found in Selector list (raw).\n", name);
      }
	
      if(! gotone) {		/* keyword not found in adscr list */
	strnscan(alist,junk,sizeof(junk));
	if((*junk == '%') || (*junk == '#')) { /* looks like a format spec. */
	  alist = get_line_item(alist);	/* skip the non-standard item */
	  alist = (char*)read_all_types(alist,junk,NULL);
	} else {		/* punt */
	  fprintf(stderr,"Unknown or non-unique selector %s; argument %s ignored\n",name,junk);
	  alist = get_line_item(alist);
	}
      }
    }
  }
  if (debug_level > 1 || w_verbose > 1) 
        fprintf(stderr,"Got %d args\n", gotsome);

  if(items_changed < 300)
    changed_items[items_changed] = NULL;
  return(gotsome);
}

/***********************************************************************/
Selector *create_new_variable(sl, input, name)
     Selector *sl;
     char **input, *name;
{
  char *str;

  if(sl && (str = *input) && *str && name && *name) {
    char *mb, *nn, *nf, *nv, *savestring();
    Selector *s;
    int i;
    
    mb = get_line_item(str);
    if((strlen(str) < MES_BUF_SIZE) ||((mb - str) < MES_BUF_SIZE)) {
      s = (Selector*)malloc(sizeof(Selector));
      if(s && (nn = savestring(name))) {
	nf = savestring("#qstr");
	if(nf && (nv = malloc(MES_BUF_SIZE+1))) {
	  s->name = nn;
	  s->format = nf;
	  s->dest = nv;
	  s->next = NULL;
	  mb = (char*)read_all_types(str,s->format,s->dest);
	  while(sl->next) sl = sl->next;
	  sl->next = s;
	  *input = mb;
	  return(s);
	} else
	  fprintf(stderr,"Allocation problems (1) in create_new_variable\n");
	if(nf)
	  free(nf);
	free(nn);
	free(s);
      } else
	fprintf(stderr,"Allocation problems (2) in create_new_variable\n");
    } else
      fprintf(stderr,"Questionable args passed to create_new_variable (%s)\n",str);
  } else
    fprintf(stderr,"Bad args passed to create_new_variable\n");
  *input = get_line_item(*input);
  return(NULL);
}

/***********************************************************************/
get_args_raw(alist, adscr)
     char *alist;
     Selector *adscr;
{
  register int gotsome = 0, gotone, n;
  char name[NAMELEN], junk[MES_BUF_SIZE];
  char *parsed_as;
  register Selector *ad, *ad2;


  if(alist && *alist && adscr) {
    while((*alist == ' ') || (*alist == '\t'))
      alist++;			/* skip initial blanks */
    while(*alist && (*alist != '\n')) {
      strnscan(alist,name,sizeof(name));
      if(! *(alist = get_line_item(alist))) {
	fprintf(stderr,"No argument for selector %s\n",name);
	if (debug_level > 1 || w_verbose > 1)
	    fprintf(stderr,"Got %d args\n", gotsome);
	if(items_changed < 300)
	  changed_items[items_changed] = NULL;
	return(gotsome);
      }