自学教程：C++ E_FATAL函数代码示例

/* * Wait for the user to type a <CR> then capture input audio for approx. 2 sec * and compute a measure of its power. */intmain (int32 argc, char *argv[]){    char line[1024];    ad_rec_t *ad;    int16 buf[1000];    int32 sps;        sps = DEFAULT_SAMPLES_PER_SEC;    if ((ad = ad_open_sps (sps)) == NULL)	E_FATAL("ad_open_sps failed/n");        for (;;) {	printf ("Hit <CR> to measure A/D power; Q<CR> to quit: ");		fgets (line, sizeof(line), stdin);	if ((line[0] == 'q') || (line[0] == 'Q'))	    break;		ad_start_rec (ad);	adpow(ad);		ad_stop_rec (ad);	while (ad_read (ad, buf, 1000) >= 0);	/* Flush any buffered, unread data */    }    ad_close (ad);    return 0;}

/** * Reads all the N-grams in the given N-gram file into the array of strings. * * args: * ngrams_file - the N-gram file to read N-grams from * ngrams - the array of string to read N-grams into * * returns: the number of ngrams read */intread_ngrams(char *ngrams_file,            char **ngrams,            s3lmwid32_t * wid[], int32 nwords[], int max_lines, lm_t * lm){    FILE *fp;    char line_read[MAX_STRLEN];    int n, length;    if ((fp = fopen(ngrams_file, "r")) == NULL) {        E_FATAL("Unable to open N-gram file %s/n", ngrams_file);    }    n = 0;    /* read each line in the file into the ngrams array */    while (fgets(line_read, MAX_STRLEN, fp) != NULL) {        if (n < max_lines) {            length = strlen(line_read);            line_read[length - 1] = '/0';            ngrams[n] = (char *) ckd_calloc(length, sizeof(char));            strncpy(ngrams[n], line_read, length - 1);            wid[n] = (s3lmwid32_t *) ckd_calloc(3, sizeof(s3lmwid32_t));            nwords[n] = ngram2wid(line_read, length, wid[n], lm);            n++;        }        else {            break;        }    }    return n;}

static intread_seno_cluster(int32 **seno_cluster,                  const char *seno_dir,                  const char *base_name,                  const char **ext,                  uint32 n_weights){    unsigned int f;    int n_read;    char seno_filename[MAXPATHLEN];    E_INFO("reading mixing weights for %s/n",           base_name);    for (f = 0; f < S2_N_FEATURE; f++) {        sprintf(seno_filename,                "%s/%s.%s",                seno_dir, base_name, ext[f]);        areadint(seno_filename, &seno_cluster[f], &n_read);        if (n_read != n_weights) {            E_FATAL("expected %d weights in %s but got %d/n",                    n_weights, seno_filename, n_read);        }    }    return S3_SUCCESS;}

voidagc(float32 *mfcc,    uint32 n_frame){    const char *agc_type = cmd_ln_access("-agc");    uint32 i;    if (strcmp(agc_type, "noise") == 0) {	real_agc_noise(mfcc, n_frame, veclen);    }    else if (strcmp(agc_type, "max") == 0) {	agc_max(mfcc, n_frame, veclen);    }    else if (strcmp(agc_type, "emax") == 0) {	for (i = 0; i < n_frame; i++) {	    agc_emax_proc(&mfcc[i*veclen], &mfcc[i*veclen],			  veclen);	}    }    else if (strcmp(agc_type, "none") == 0) {	/* do nothing */    }    else if (agc_type == NULL) {	E_WARN("no agc set/n");	return ;    }    else {	E_FATAL("unsupported agc type %s/n", agc_type);    }}

voidlistelem_free(void *elem, int32 elemsize){    char **cpp;    list_t *prev, *list;    /* Find list for elemsize */    prev = NULL;    for (list = head; list && (list->elemsize != elemsize);         list = list->next)        prev = list;    if (!list) {        E_FATAL("Unknown list item size: %d/n", elemsize);    }    else if (prev) {        /* List found; move entry to head of list */        prev->next = list->next;        list->next = head;        head = list;    }    /*     * Insert freed item at head of list.     * NOTE: skipping check for size being multiple of (void *).     */    cpp = (char **) elem;    *cpp = (char *) list->freelist;    list->freelist = cpp;    (list->n_freed)++;}

static voidrecognize_from_microphone(){    ad_rec_t *ad;    int16 adbuf[2048];    uint8 utt_started, in_speech;    int32 k;    char const *hyp;    if ((ad = ad_open_dev(AUDIO_DEVICE_NAME,                          (int) SAMPLE_RATE )) == NULL) {        E_FATAL("Failed to open audio device/n");	}    if (ad_start_rec(ad) < 0) {        E_FATAL("Failed to start recording/n");    }    if (ps_start_utt(ps) < 0) {        E_FATAL("Failed to start utterance/n");    }    utt_started = FALSE;    printf("READY..../n");    for (;;) {        if ((k = ad_read(ad, adbuf, 2048)) < 0)            E_FATAL("Failed to read audio/n");        ps_process_raw(ps, adbuf, k, FALSE, FALSE);        in_speech = ps_get_in_speech(ps);        if (in_speech && !utt_started) {            utt_started = TRUE;            printf("Listening.../n");        }        if (!in_speech && utt_started) {            /* speech -> silence transition, time to start new utterance  */            ps_end_utt(ps);            hyp = ps_get_hyp(ps, NULL );            if (hyp != NULL)                printf("%s/n", hyp);            if (ps_start_utt(ps) < 0)                E_FATAL("Failed to start utterance/n");            utt_started = FALSE;            printf("READY..../n");        }        sleep_msec(100);    }    ad_close(ad);}

/* * Record A/D data for approximately specified number of seconds into specified file. */intmain (int32 argc, char *argv[]){    char line[1024];    ad_rec_t *ad;    int16 buf[1000];    int32 len, k, sps;    FILE *fp;        if ((argc != 4) ||	(sscanf (argv[1], "%d", &sps) != 1) ||	(sscanf (argv[2], "%d", &len) != 1)) {	E_FATAL("Usage: %s <sampling-rate> <#sec-to-record> <output-file>/n", argv[0]);    }    if ((fp = fopen (argv[3], "wb")) == NULL)	E_FATAL("fopen(%s,wb) failed/n", argv[3]);        len *= sps;		/* Convert to min. #samples to record */        if ((ad = ad_open_sps (sps)) == NULL)	E_FATAL("ad_open_sps(%d) failed/n", sps);        printf ("Hit <CR> to start recording/n");    fgets (line, sizeof(line), stdin);        ad_start_rec (ad);        /* Record desired no. of samples */    while (len > 0) {	/* Read A/D */	if ((k = ad_read (ad, buf, 1000)) < 0)	    E_FATAL("ad_read returned %d/n", k);	/* Write data read, if any, to file (ad_read may return 0 samples) */	if (k > 0) {	    fwrite (buf, sizeof(int16), k, fp);	    fflush (fp);	    len -= k;	}    }        ad_stop_rec (ad);    ad_close (ad);    fclose (fp);    return 0;}

static void subvq_map_compact (subvq_t *vq, mgau_model_t *g){    int32 r, c, c2, s;        if (g) {	if ((g->n_mgau != vq->origsize.r) || (g->max_comp != vq->origsize.c))	    E_FATAL("Model size conflict: %d x %d (SubVQ) vs %d x %d (Original)/n",		    vq->origsize.r, vq->origsize.c, g->n_mgau, g->max_comp);    }        /*     * Compress map entries by removing invalid ones.  NOTE: There's not much of a consistency     * check to ensure that the entries remaining do map correctly on to the valid entries in     * the original (parent) mixture Gaussian model g.  The only check we have is to verify     * the NUMBER of valid entries (components) in each mixture.     */    for (r = 0; r < vq->origsize.r; r++) {	for (c = 0, c2 = 0; c < vq->origsize.c; c++) {	    if (vq->map[r][c][0] < 0) {		/* All ought to be < 0 */		for (s = 1; s < vq->n_sv; s++) {		    if (vq->map[r][c][s] >= 0)			E_FATAL("Partially undefined map[%d][%d]/n", r, c);		}	    } else {		if (c2 != c) {		    for (s = 0; s < vq->n_sv; s++) {			if (vq->map[r][c][s] < 0)			    E_FATAL("Partially undefined map[%d][%d]/n", r, c);			vq->map[r][c2][s] = vq->map[r][c][s];		    }		}		c2++;	    }	}		if (g && (c2 != mgau_n_comp (g, r)))	    E_FATAL("Mixture %d: #Valid components conflict: %d (SubVQ) vs %d (Original)/n",		    r, c2, mgau_n_comp(g,r));		/* Invalidate the remaining map entries, for good measure */	for (; c2 < vq->origsize.c; c2++) {	    for (s = 0; s < vq->n_sv; s++)		vq->map[r][c2][s] = -1;	}    }}

static voidparse_base_line(mdef_t * m, char *line, int p){    int32 wlen, n;    __BIGSTACKVARIABLE__ char word[1024], *lp;    int ci;    lp = line;    /* Read base phone name */    if (sscanf(lp, "%s%n", word, &wlen) != 1)        E_FATAL("Missing base phone name: %s/n", line);    lp += wlen;    /* Make sure it's not a duplicate */    ci = mdef_ciphone_id(m, word);    if (ci >= 0)        E_FATAL("Duplicate base phone: %s/n", line);    /* Add ciphone to ciphone table with id p */    ciphone_add(m, word, p);    ci = (int) p;    /* Read and skip "-" for lc, rc, wpos */    for (n = 0; n < 3; n++) {        if ((sscanf(lp, "%s%n", word, &wlen) != 1)            || (strcmp(word, "-") != 0))            E_FATAL("Bad context info for base phone: %s/n", line);        lp += wlen;    }    /* Read filler attribute, if present */    if (sscanf(lp, "%s%n", word, &wlen) != 1)        E_FATAL("Missing filler atribute field: %s/n", line);    lp += wlen;    if (strcmp(word, "filler") == 0)        m->ciphone[(int) ci].filler = 1;    else if (strcmp(word, "n/a") == 0)        m->ciphone[(int) ci].filler = 0;    else        E_FATAL("Bad filler attribute field: %s/n", line);    triphone_add(m, ci, -1, -1, WORD_POSN_UNDEFINED, p);    /* Parse remainder of line: transition matrix and state->senone mappings */    parse_tmat_senmap(m, line, lp - line, p);}

void phone_add_diphones (void)/*------------------------* * DESCRIPTION - figure out what the word begin/end diphones of intrest are *	         and add them to the phone set. */{    int32 	phone_cnt = phone_count();    int32	pid;    int32	ret;    int32	new_phone_id = phone_cnt;    char	tp[64];    char 	ci[32], lc[64], rc[64], pc[64];    for (pid = 0; pid < phone_cnt; pid++) {	strcpy (tp, phone_from_id (pid));	ret = parse_triphone (tp, ci, lc, rc, pc);	if (ret == 4) {	    switch (pc[0]) {	    case 'b':		sprintf (tp, "%s(%%s,%s)b", ci, rc);		if (phone_to_id (tp, FALSE) == NO_PHONE) {		    add_phone (tp, new_phone_id, phone_to_id(ci, TRUE),			       PT_DIPHONE, 1);		    new_phone_id++;		}		break;	    case 'e':		sprintf (tp, "%s(%s,%%s)e", ci, lc);		if (phone_to_id (tp, FALSE) == NO_PHONE) {		    add_phone (tp, new_phone_id, phone_to_id(ci, TRUE),			       PT_DIPHONE, 1);		    new_phone_id++;		}		break;	    case 's':		sprintf (tp, "%s(%%s,%%s)s", ci);		if (phone_to_id (tp, FALSE) == NO_PHONE) {		    add_phone (tp, new_phone_id, phone_to_id(ci, TRUE),			       PT_DIPHONE_S, 1);		    new_phone_id++;		}		break;	    case '/0':		break;	    default:		E_FATAL("Unknown position context in %s == '%c'/n",			tp, pc[0]);	    }	}    }    /*     * Remake the phone map to account for the diphones     */    mk_phone_map ();    E_INFO("Added %d new begin/end word diphones/n",	   new_phone_id - phone_cnt);}

float32gs_fread_float32(gs_t * gs){    float32 val;    if (fread(&val, sizeof(float32), 1, gs->fp) != 1)        E_FATAL("fread failed/n");    return (val);}

static voidread_1rule(s3_cfg_t *_cfg, FILE *_file, float32 *_score,           s3_cfg_id_t *_src, s3_cfg_id_t *_products){  char name[S3_CFG_MAX_ITEM_STR_LEN + 1];  float32 score;  s3_cfg_id_t src;  s3_cfg_id_t products[S3_CFG_MAX_ITEM_COUNT + 1];  s3_cfg_id_t item;  char format[1024];  int len;  int i;  assert(_cfg != NULL);  assert(_file != NULL);  sprintf(format, "%%%ds", S3_CFG_MAX_ITEM_STR_LEN);  /* read the prior */  if (fscanf(_file, "%f", &score) != 1 || score < 0)    E_FATAL("Bad CFG production rule/n");  /* read the source */  if (fscanf(_file, format, name) != 1)    E_FATAL("Bad CFG production rule/n");  src = s3_cfg_str2id(_cfg, name);  if (src == S3_CFG_INVALID_ID)    E_FATAL("Bad CFG production rule/n");  if (s3_cfg_is_terminal(src))    E_FATAL("Bad CFG production rule/n");  if (fscanf(_file, "%d", &len) != 1)    E_FATAL("Bad CFG production rule/n");  if (len > S3_CFG_MAX_ITEM_COUNT)    E_FATAL("CFG Production rule too long/n");  /* read the products */  for (i = 0; i < len; i++) {    if (fscanf(_file, format, name) != 1)      E_FATAL("Bad CFG production rule/n");    item = s3_cfg_str2id(_cfg, name);    if (item == S3_CFG_INVALID_ID)      E_FATAL("Bad CFG production term/n");    products[i] = item;  }  products[len] = S3_CFG_EOR_ITEM;  *_src = src;  *_score = score;  memcpy(_products, products, (len + 1) * sizeof(s3_cfg_id_t));}

floatfe_warp_unwarped_to_warped(melfb_t *mel,float linear){    if (mel->warp_id <= FE_WARP_ID_MAX) {        return fe_warp_conf[mel->warp_id].unwarped_to_warped(linear);    }    else if (mel->warp_id == FE_WARP_ID_NONE) {        E_FATAL("fe_warp module must be configured w/ a valid ID/n");    }    else {        E_FATAL            ("fe_warp module misconfigured with invalid fe_warp_id %u/n",             mel->warp_id);    }    return 0;}

intmain(int argc, char *argv[]){	cmd_ln_t *config;	ngram_model_t *lm = NULL;	logmath_t *lmath;	const char *lmfn, *probdefn, *lsnfn, *text;	if ((config = cmd_ln_parse_r(NULL, defn, argc, argv, TRUE)) == NULL)		return 1;        verbose = cmd_ln_boolean_r(config, "-verbose");	/* Create log math object. */	if ((lmath = logmath_init	     (cmd_ln_float64_r(config, "-logbase"), 0, 0)) == NULL) {		E_FATAL("Failed to initialize log math/n");	}	/* Load the language model. */	lmfn = cmd_ln_str_r(config, "-lm");	if (lmfn == NULL	    || (lm = ngram_model_read(config, lmfn,				      NGRAM_AUTO, lmath)) == NULL) {		E_FATAL("Failed to load language model from %s/n",			cmd_ln_str_r(config, "-lm"));	}        if ((probdefn = cmd_ln_str_r(config, "-probdef")) != NULL)            ngram_model_read_classdef(lm, probdefn);        ngram_model_apply_weights(lm,                                  cmd_ln_float32_r(config, "-lw"),                                  cmd_ln_float32_r(config, "-wip"),                                  cmd_ln_float32_r(config, "-uw"));	/* Now evaluate some text. */	lsnfn = cmd_ln_str_r(config, "-lsn");	text = cmd_ln_str_r(config, "-text");	if (lsnfn) {		evaluate_file(lm, lmath, lsnfn);	}	else if (text) {		evaluate_string(lm, lmath, text);	}	return 0;}

const char *fe_warp_doc(melfb_t *mel){    if (mel->warp_id <= FE_WARP_ID_MAX) {        return fe_warp_conf[mel->warp_id].doc();    }    else if (mel->warp_id == FE_WARP_ID_NONE) {        E_FATAL("fe_warp module must be configured w/ a valid ID/n");    }    else {        E_FATAL            ("fe_warp module misconfigured with invalid fe_warp_id %u/n",             mel->warp_id);    }    return NULL;}

uint32fe_warp_n_param(melfb_t *mel){    if (mel->warp_id <= FE_WARP_ID_MAX) {        return fe_warp_conf[mel->warp_id].n_param();    }    else if (mel->warp_id == FE_WARP_ID_NONE) {        E_FATAL("fe_warp module must be configured w/ a valid ID/n");    }    else {        E_FATAL            ("fe_warp module misconfigured with invalid fe_warp_id %u/n",             mel->warp_id);    }    return 0;}

static void homfile_load (char *file){    FILE *fp;    char line[16380], w1[4096], w2[4096];    int32 k, n;    s3wid_t wid1, wid2;    s3cipid_t ci[1];    hom_t *h;        E_INFO("Reading homophones file %s/n", file);    if ((fp = fopen(file, "r")) == NULL)	E_FATAL("fopen(%s,r) failed/n", file);        ci[0] = (s3cipid_t) 0;	/* Dummy */        n = 0;    while (fgets (line, sizeof(line), fp) != NULL) {	if ((k = sscanf (line, "%s %s", w1, w2)) == 2) {	    wid1 = dict_wordid (dict, w1);	    if (NOT_WID(wid1)) {		E_INFO("Adding %s to dictionary/n", w1);		wid1 = dict_add_word (dict, w1, ci, 1);		if (NOT_WID(wid1))		    E_FATAL("dict_add_word(%s) failed/n", w1);	    }	    	    wid2 = dict_wordid (dict, w2);	    if ((NOT_WID(wid2)) || (wid2 >= oovbegin))		E_FATAL("%s not in dictionary/n", w2);	    h = (hom_t *) listelem_alloc (sizeof(hom_t));	    h->w1 = wid1;	    h->w2 = wid2;	    h->next = homlist;	    homlist = h;	    	    n++;	} else	    E_FATAL("Bad homophones line: %s/n", line);    }        E_INFO("%d homophone pairs read/n", n);        fclose (fp);}

uint32feat_n_stream(){    if (sv.subvecs != NULL) {	return sv.n_sv;    }    else if (fid <= FEAT_ID_MAX) {	return feat_conf[fid].n_stream();    }    else if (fid == FEAT_ID_NONE) {	E_FATAL("feat module must be configured w/ a valid ID/n");    }    else {	E_FATAL("feat module misconfigured with invalid feat_id %u/n", fid);    }    return 0;}

static intread_audio_file(int16 * buf, int len){    if (!infile) {        E_FATAL("Failed to read audio from file/n");        return -1;    }    return fread(buf, sizeof(int16), len, infile);}

static voidevaluate_file(ngram_model_t *lm, logmath_t *lmath, const char *lsnfn){	FILE *fh;        lineiter_t *litor;	int32 nccs, noovs, nwords, lscr;	float64 ch, log_to_log2;;	if ((fh = fopen(lsnfn, "r")) == NULL)		E_FATAL_SYSTEM("failed to open transcript file %s", lsnfn);	/* We have to keep ch in floating-point to avoid overflows, so	 * we might as well use log2. */	log_to_log2 = log(logmath_get_base(lmath)) / log(2);	lscr = nccs = noovs = nwords = 0;	ch = 0.0;        for (litor = lineiter_start(fh); litor; litor = lineiter_next(litor)) {		char **words;		int32 n, tmp_ch, tmp_noovs, tmp_nccs, tmp_lscr;		n = str2words(litor->buf, NULL, 0);		if (n < 0)			E_FATAL("str2words(line, NULL, 0) = %d, should not happen/n", n);		if (n == 0) /* Do nothing! */			continue;		words = ckd_calloc(n, sizeof(*words));		str2words(litor->buf, words, n);		/* Remove any utterance ID (FIXME: has to be a single "word") */		if (words[n-1][0] == '('		    && words[n-1][strlen(words[n-1])-1] == ')')			n = n - 1;		tmp_ch = calc_entropy(lm, words, n, &tmp_nccs,                                      &tmp_noovs, &tmp_lscr);		ch += (float64) tmp_ch * (n - tmp_nccs - tmp_noovs) * log_to_log2;		nccs += tmp_nccs;		noovs += tmp_noovs;                lscr += tmp_lscr;		nwords += n;				ckd_free(words);	}	ch /= (nwords - nccs - noovs);	printf("cross-entropy: %f bits/n", ch);	/* Calculate perplexity pplx = exp CH */	printf("perplexity: %f/n", pow(2.0, ch));        printf("lm score: %d/n", lscr);	/* Report OOVs and CCs */	printf("%d words evaluated/n", nwords);	printf("%d OOVs (%.2f%%), %d context cues removed/n",	       noovs, (double)noovs / nwords * 100, nccs);}

intmain(int argc, char *argv[]){    parse_cmd_ln(argc, argv);    if(rd_parm()==S3_ERROR) {	E_FATAL("Problem in reading input parameters./n");    }    if(cp_parm()==S3_ERROR) {	E_FATAL("Problem in copying parameters./n");    }    if(wr_parm()==S3_ERROR) {	E_FATAL("Problem in writing output parameters./n");    }    return 0;}

int32 gauden_mean_reload (gauden_t *g, char *meanfile){    int32 i, m, f, d, *flen;        assert (g->mean != NULL);        gauden_param_read (&(g->mean), &m, &f, &d, &flen, meanfile);        /* Verify original and new mean parameter dimensions */    if ((m != g->n_mgau) || (f != g->n_feat) || (d != g->n_density))	E_FATAL("Mixture-gaussians dimensions for original and new means differ/n");    for (i = 0; i < g->n_feat; i++)	if (g->featlen[i] != flen[i])	    E_FATAL("Feature lengths for original and new means differ/n");    ckd_free (flen);    return 0;}

bool Theme::load(const char *f) {	E_RETURN_VAL_IF_FAIL(f != NULL, false);	/* do not allow loading if clear() wasn't called before */	E_RETURN_VAL_IF_FAIL(priv->sc == NULL, false);	priv->is_loaded = false;	init_interpreter();	scheme *ss = priv->sc;	/* 	 * Determine from which directory we loads file, and set that file as base directory	 * where '(include)' statement can search additional files. Include uses 'private::theme.search-path'.	 */	char *path = edelib_strndup(f, PATH_MAX);	if(!path)		E_FATAL(E_STRLOC ": No memory/n");	char *dir = local_dirname(path);	/* If returned name is the same as file, dirname wasn't found directory name in given path. */	if(strcmp(dir, f) != 0) {		pointer sym = mk_symbol(ss, "private:theme.search-path");		edelib_scheme_define(ss, ss->global_env, sym, mk_string(ss, dir));		ss->vptr->setimmutable(sym);	}	/* scheme copies path, so we do not need it any more */	free(path);	FILE *fd = fopen(f, "r");	if(!fd) {		edelib_scheme_deinit(ss);		free(ss);		priv->sc = 0;		return false;	}	edelib_scheme_load_named_file(ss, fd, f);	fclose(fd);	if(ss->no_memory) {		E_WARNING(E_STRLOC ": No memory to load theme source in interpreter/n");		return false;	}			if(ss->retcode != 0)		return false;	/* fetch common variables */	priv->name   = get_string_var(ss, "private:theme.name");	priv->author = get_string_var(ss, "private:theme.author");	priv->sample = get_string_var(ss, "private:theme.sample");	priv->is_loaded = true;	return true;}

void *__ckd_malloc__(size_t size,		     const char *caller_file, int caller_line){    void *mem;    if ((mem = malloc(size)) == NULL)	E_FATAL("malloc(%d) failed from %s(%d)/n", size, caller_file, caller_line);    return mem;}

int main (int argc, char *argv[]){    short *samps;    int  i, j, buflen, endutt, blksize, nhypwds, nsamp;    char   *argsfile, *ctlfile, *indir;    char   filename[512], cepfile[512];    partialhyp_t *parthyp;    FILE *fp, *sfp;    if (argc != 4)	    E_FATAL("/nUSAGE: %s <ctlfile> <inrawdir> <argsfile>/n",argv[0]);    ctlfile = argv[1]; indir = argv[2]; argsfile = argv[3];	samps = (short *) calloc(MAXSAMPLES,sizeof(short));    blksize = 2000;    if ((fp = fopen(ctlfile,"r")) == NULL)	E_FATAL("Unable to read %s/n",ctlfile);    live_initialize_decoder(argsfile);    while (fscanf(fp,"%s",filename) != EOF){	sprintf(cepfile,"%s/%s.raw",indir,filename);	if ((sfp = fopen(cepfile,"rb")) == NULL)	    E_FATAL("Unable to read %s/n",cepfile);		nsamp = fread(samps, sizeof(short), MAXSAMPLES, sfp);        fprintf(stdout,"%d samples in file %s./nWill be decoded in blocks of %d/n",nsamp,cepfile,blksize);        fflush(stdout); fclose(sfp);        for (i=0;i<nsamp;i+=blksize){	    buflen = i+blksize < nsamp ? blksize : nsamp-i;	    endutt = i+blksize <= nsamp-1 ? 0 : 1;	    nhypwds = live_utt_decode_block(samps+i,buflen,endutt,&parthyp);	    E_INFO("PARTIAL HYP:");	    if (nhypwds > 0)                for (j=0; j < nhypwds; j++) fprintf(stderr," %s",parthyp[j].word);	    fprintf(stderr,"/n");        }    }    return 0;}

static voidciphone_add(mdef_t * m, const char *ci, s3pid_t p){    assert(p < m->n_ciphone);    m->ciphone[p].name = (char *) ckd_salloc(ci);       /* freed in mdef_free */    if (hash_table_enter(m->ciphone_ht, m->ciphone[p].name, (void *)(long)p) != (void *)(long)p)        E_FATAL("hash_table_enter(%s) failed; duplicate CIphone?/n",                m->ciphone[p].name);}

int32 line2wid (dict_t *dict, char *line, s3wid_t *wid, int32 max_n_wid, int32 add_oov,		char *uttid){    char *lp, word[1024];    int32 n, k;    s3wid_t w;    s3cipid_t ci[1];        uttid[0] = '/0';    ci[0] = (s3cipid_t) 0;        lp = line;    n = 0;    while (sscanf (lp, "%s%n", word, &k) == 1) {	lp += k;	if (n >= max_n_wid)	    return -n;		if (is_uttid (word, uttid))	    break;		wid[n] = dict_wordid (dict, word);	/* Up to caller to handle BAD_WIDs */	if (NOT_WID(wid[n])) {	    /* OOV word */	    if (add_oov) {		E_INFO("Adding %s to dictionary/n", word);		wid[n] = dict_add_word (dict, word, NULL, 0);		if (NOT_WID(wid[n]))		    E_FATAL("dict_add_word(%s) failed for line: %s/n", word, line);	    } else		E_FATAL("Unknown word (%s) in line: %s/n", word, line);	}		n++;    }        if (sscanf (lp, "%s", word) == 1)	/* Check that line really ended */	E_WARN("Nonempty data ignored after uttid(%s) in line: %s/n", uttid, line);        return n;}

/* * Return ptr WITHIN path (i.e., not a copy) of the base filename. * FATAL error if path ends in a /. */static char *path2basename (char *path){    int32 i;        for (i = strlen(path)-1; (i >= 0) && (path[i] != '/'); --i);    i++;    if (path[i] == '/')	E_FATAL("Path %s has no basename/n", path);    return (path + i);}

static voidparse_ctl_line(char *line,	       char **path,	       uint32 *sf,	       uint32 *ef,	       char **id){    char *sp;    char sv_line[4192];    strcpy(sv_line, line);    sp = strchr(sv_line, ' ');    if (sp == NULL) {	/* 'old' style control file */	if (path)	    *path = strdup(sv_line);	if (sf)	    *sf = NO_FRAME;	if (ef)	    *ef = NO_FRAME;	if (id)	    *id = NULL;    }    else {	*sp = '/0';	if (path)	    *path = strdup(sv_line);		/* at least one space, so try to parse rest of line */	if (sf != NULL)	    *sf = atoi(sp+1);	/* set the start frame */	sp = strchr(sp+1, ' ');	if (sp == NULL) {	    E_FATAL("Control file line must be '<path> [<sf> <ef> [<id>]]', instead saw '%s'/n",		    line);	}	if (ef != NULL)	    *ef = atoi(sp+1);	/* set the end frame */	sp = strchr(sp+1, ' ');	if (id != NULL) {	    if (sp == NULL) {		/* assume that the optional ID has been omitted */		*id = NULL;	    }	    else {		*id = strdup(sp+1);	/* set the utterance ID */	    }	}    }}