fea_print.c

speech signal process tools

	   /* component field_name[<element_range>] found */

	    component_found = YES;

	    /* Components must be preceded by keywords. */

	    if	(keyword_found == NO)
		    {
		    fprintf(stderr,
"%s: error in style file %s:\n\tcomponent name %s on line %d precedes layout keywords.\n",
			    ProgName, sfstr, field_line, line_num);
		    exit(1);
		    }

	    ++n_deriv;
	    if	(n_deriv > MAXPRINTVARS)
		    {
		    Fprintf(stderr,
			    "%s: more than %d elements to print per record.\n",
			    ProgName, MAXPRINTVARS);
		    exit(1);
		    }

	    /* get rid of the trailing newline character, if there is one. */

	    if	(field_line[ strlen(field_line) - 1 ] == '\n')
		    field_line[ strlen(field_line) - 1 ] = '\0';

	    /* Remove format string. */

	    s = strpbrk(field_line, " ");
	    if	(s == NULL)
		    {
		    Fprintf(stderr, "%s: couldn't find format string in %s.\n",
			    ProgName, field_line);
		    exit(1);
		    }
	    format = s+1;
	    *s = '\0';

	    /* Store the trimmed string. */

	    vvec[n_deriv-1] = (char *)NULL;
	    REALLOC(char **, n_deriv, srcfields)
	    srcfields[n_deriv-1] = NULL;
	    REALLOC(char *, 2, srcfields[n_deriv-1])
	    srcfields[n_deriv-1][0] = savestring (field_line);
	    srcfields[n_deriv-1][1] = NULL;

	    /* See if remaining string is a valid field name. */

	    component_error = NO;

	    if (!isalpha (field_line[0]) && (field_line[0] != '_'))
		    component_error = YES;

	    /* check all elements as well */

	    for (i = 1; i < strlen(field_line) - 1; i++)
		    if (!isspace (field_line[i]) && !isalnum (field_line[i])
			&& (field_line[i] != '_')
			&& (field_line[i] != '=')
			&& (field_line[i] != '[')
			&& (field_line[i] != ',')
			&& (field_line[i] != ':')
			&& (field_line[i] != ']')) {
			    component_error = YES;
			    break;
	     }

	    if ((s=strpbrk (field_line, "[")) == NULL)
		component_error = YES;
	    if (strpbrk (field_line, "]") == NULL)
		component_error = YES;

	    
	    /* If the "component" specification doesn't look like a component,
	     * mark the type as UNDEF and (later) treat the component string
	     * as an "immediate" string variable.
	     */

	    if	(component_error == NO)
		    {
		    *s = '\0';
		    i = get_fea_type(field_line, ih);
                    field_names[n_deriv-1] = savestring(field_line);
                    if (debug_level > 10) 
                       Fprintf(stderr, "%s: new field name = %s\n", 
			       field_names[n_deriv-1], ProgName);
		    if (is_field_complex(ih, field_line)) {
		      Fprintf(stderr, "%s: can't handle complex fields (%s)\n",
			      ProgName, field_line);
		      exit(1);
		    }
		    *s = '[';
		    }
	    else    i = UNDEF;
	    data_type[n_deriv-1] = i;
	    formats[n_deriv-1] = savestring(format);


	    if (debug_level > 10) {
		    Fprintf(stderr, "component %d: %s; format: %s\n",
			n_deriv, srcfields[n_deriv-1][0], formats[n_deriv-1]);
		Fprintf (stderr, "\n");
		Fflush (stderr);
	    }

	}   /* end if ((new_field_name = strchr (field_line, ...) */

    }	/* end while (fgets (field_line, 80, sfp)) */

    /* If no keyword found print error and die */

    if (!keyword_found) {
	Fprintf (stderr,
	"%s: layout %s not found in style file %s.\n", ProgName, lstr, sfstr);
	exit(1);
    }

    if (!component_found) {
	Fprintf (stderr,
	"%s: no component fields found for field name %s.\n",
	ProgName, new_field_name);
	exit(1);
    }

    if (debug_level > 5)
	Fprintf (stderr,
	"%s: total number of fields to print is %d\n",
	ProgName, n_deriv);

    /* Scan headers and format strings for escaped characters. */

    Escape(header1);
    Escape(header2);
    Escape(header3);
    for (i = 0; i < n_deriv; ++i)
	    Escape(formats[i]);

    /* Write out the headers. */

    printf(header1);
    printf(header2);
    printf(header3);
    fflush(stdin);

    i_fea_rec = allo_fea_rec (ih);

    ppcnt = 0;

    /* Begin Processing */

    for (   n_rec = s_rec;
	    n_rec <= e_rec && get_fea_rec(i_fea_rec, ih, inp) != EOF;
	    n_rec++ )
    {

	/* get a record from the input ESPS Feature file */

	if (debug_level > 8)
	    Fprintf (stderr,
	    "%s: got record number %ld from input ESPS FEA file %s.\n",
	    ProgName, n_rec, instr);

	/* Get pointers to each vector of desired elements in this record.
	 */
	for (j = 0; j < n_deriv; j++) {

	    if (debug_level > 8)
		Fprintf (stderr,
		"%s: getting value of %s.\n",
		ProgName, srcfields[j][0]);

	    /* This isn't real component: treat as immediate string var. */
	    if	(data_type[j] == UNDEF)
		    {
		    vec = srcfields[j][0];
		    length = 1;
		    }
	    else    vec = get_deriv_vec(srcfields[j], i_fea_rec, ih,
				     data_type[j], &length, vvec[j]);
	    if (vec == NULL)
	    {
		Fprintf (stderr,
	       "%s: get_deriv_vec: encountered error getting field.\n",
		ProgName);
		exit(1);
	    }

	    if	(ppcnt+length > MAXPRINTVARS)
		    {
		    Fprintf(stderr,
		     "%s: more than %d elements to print per record.\n",
		     ProgName, MAXPRINTVARS);
		    exit(1);
		    }

	    switch (data_type[j]) 
	    {
	    case DOUBLE: DSize = 8;
		     break;
	    case FLOAT:  DSize = 4;
		     break;
	    case LONG:   DSize = 4;
		     break;
	    case CODED:
	    case SHORT:  DSize = 2;
		     break;
            case UNDEF:  DSize = -1;
		    break;
	    case CHAR:   DSize = 0;
		    if (n_rec == s_rec) 
		      vec = realloc(vec, (unsigned) length+1);
		    vec[length] = '\0';
		    length = 1;
		    break;
	    case BYTE:   DSize = 1;
		    break;
	    }  /* end switch (type) */


	    /* If this is the first record, set up the pointers to
	     * each element location, element type, and print format string.
	     */
	    if	(n_rec == s_rec)
		    {
		    vvec[j] = vec;
		    for (i = 0; i < length; ++i, ++ppcnt)
			    {
			    printptrs[ppcnt] = vec + DSize*i;
			    printtypes[ppcnt] = data_type[j];
			    printfrms[ppcnt] = formats[j];
			    }
		    }


	}  /* end for (j = 0; j < n_deriv; j++) */

	/* Print the record. */

	for	(i = 0; i < ppcnt; ++i)
		{
		if (debug_level > 10) 
		  printf("printing element %d of type %d using format %s\n",
		       i, printtypes[i], printfrms[i]);
		switch (printtypes[i]) 
			{
		case DOUBLE: printf(printfrms[i], *(double *)printptrs[i]);
			break;
		case FLOAT:  printf(printfrms[i], *(float *)printptrs[i]);
			break;
		case LONG:   printf(printfrms[i], *(long *)printptrs[i]);
			break;
		case SHORT:  printf(printfrms[i], *(short *)printptrs[i]);
			break;
		case UNDEF:
		case CHAR:   printf(printfrms[i], (char *)printptrs[i]);
			break;
		case CODED: 
		        printf(printfrms[i], 
			   fea_decode(*(short *) printptrs[i], 
				       (char *) field_names[i], ih));
		        break;
		case BYTE:   printf(printfrms[i], *(char *)printptrs[i]);
			break;
			}  /* end switch */
		}


    }  /* end for (n_rec = 0; i <= e_rec && ... ; n_rec++) */

    exit(0);
    /*NOTREACHED*/
}
Escape(s)
	char *s;
/*================================================================

FUNCTION:	Escape() scans a text string and converts C-like
		escape sequences to their proper ASCII character.

ARGUMENTS:	s:	String to be converted.

NOTES:		The conversions that are handled are:
			\n -> newline
			\s -> space
			\t -> tab
			\f -> formfeed

==================================================================
!*/
{
char	*t = s, c;

while	(*s)
	{
	if	(*s == '\\')
		{
		switch	(*(++s))
			{
		case ('n'): c = '\n'; break;
		case ('s'): c = ' '; break;
		case ('e'): c = '='; break;
		case ('t'): c = '\t'; break;
		case ('f'): c = '\f'; break;
		default: c = *s; break;
			}
		*t++ = c;
		++s;
		}
	else	*t++ = *s++;
	}
*t = '\0';
}