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

intmain(int argc, char *argv[]){    lexicon_t *lex;    model_def_t *mdef;    if (initialize(&lex, &mdef,		   argc, argv) != S3_SUCCESS) {	E_ERROR("errors initializing./n");	return 1;    }        if (init_gau(lex, mdef) != S3_SUCCESS) {	return 1;    }    return 0;}

intsbthread_wait(sbthread_t *th){    void *exit;    int rv;    /* It has already been joined. */    if (th->th == (pthread_t)-1)        return -1;    rv = pthread_join(th->th, &exit);    if (rv != 0) {        E_ERROR("Failed to join thread: %d/n", rv);        return -1;    }    th->th = (pthread_t)-1;    return (int)(long)exit;}

sbthread_t *sbthread_start(cmd_ln_t *config, sbthread_main func, void *arg){    sbthread_t *th;    int rv;    th = ckd_calloc(1, sizeof(*th));    th->config = config;    th->func = func;    th->arg = arg;    th->msgq = sbmsgq_init(1024);    if ((rv = pthread_create(&th->th, NULL, &sbthread_internal_main, th)) != 0) {        E_ERROR("Failed to create thread: %d/n", rv);        sbthread_free(th);        return NULL;    }    return th;}

voidfsg_model_writefile_symtab(fsg_model_t *fsg, char const *file){    FILE *fp;    assert(fsg);    E_INFO("Writing FSM symbol table '%s'/n", file);    if ((fp = fopen(file, "w")) == NULL) {        E_ERROR("Failed to open symbol table '%s' for writing: %s/n", file, strerror(errno));        return;    }    fsg_model_write_symtab(fsg, fp);    fclose(fp);}

PJ *PROJECTION(loxim) {    struct pj_opaque *Q = pj_calloc (1, sizeof (struct pj_opaque));    if (0==Q)        return freeup_new (P);    P->opaque = Q;    Q->phi1 = pj_param(P->ctx, P->params, "rlat_1").f;    Q->cosphi1 = cos(Q->phi1);    if (Q->cosphi1 < EPS)        E_ERROR(-22);    Q->tanphi1 = tan(M_FORTPI + 0.5 * Q->phi1);    P->inv = s_inverse;    P->fwd = s_forward;    P->es = 0.;   return P;}

intsbthread_wait(sbthread_t *th){    DWORD rv, exit;    /* It has already been joined. */    if (th->th == NULL)        return -1;    rv = WaitForSingleObject(th->th, INFINITE);    if (rv == WAIT_FAILED) {        E_ERROR("Failed to join thread: WAIT_FAILED/n");        return -1;    }    GetExitCodeThread(th->th, &exit);    CloseHandle(th->th);    th->th = NULL;    return (int)exit;}

void priority_queue_add(priority_queue_t *queue, void *element){    size_t i;    if (queue->size == queue->alloc_size) {        E_ERROR("Trying to add element into full queue/n");        return;    }    for (i = 0; i < queue->alloc_size; i++) {        if (queue->pointers[i] == NULL) {            queue->pointers[i] = element;            break;        }    }    if (queue->max_element == NULL || queue->compare(element, queue->max_element) < 0) {        queue->max_element = element;    }    queue->size++;}

intdict_add_g2p_word(dict_t * dict, char const *word){    int32 wid = 0;    s3cipid_t *pron;    char **phonestr, *tmp;    int np, i;    char *phones;    phones = dict_g2p(word, dict->ngram_g2p_model);    if (phones == NULL)        return 0;    E_INFO("Adding phone %s for word %s /n",  phones, word);    tmp = ckd_salloc(phones);    np = str2words(tmp, NULL, 0);    phonestr = ckd_calloc(np, sizeof(*phonestr));    str2words(tmp, phonestr, np);    pron = ckd_calloc(np, sizeof(*pron));    for (i = 0; i < np; ++i) {        pron[i] = bin_mdef_ciphone_id(dict->mdef, phonestr[i]);        if (pron[i] == -1) {            E_ERROR("Unknown phone %s in phone string %s/n",                    phonestr[i], tmp);            ckd_free(phonestr);            ckd_free(tmp);            ckd_free(pron);            ckd_free(phones);            return -1;        }    }    ckd_free(phonestr);    ckd_free(tmp);    ckd_free(phones);    if ((wid = dict_add_word(dict, word, pron, np)) == -1) {        ckd_free(pron);        return -1;    }    ckd_free(pron);    return wid;}

sbevent_t *sbevent_init(void){    sbevent_t *evt;    int rv;    evt = ckd_calloc(1, sizeof(*evt));    if ((rv = pthread_mutex_init(&evt->mtx, NULL)) != 0) {        E_ERROR("Failed to initialize mutex: %d/n", rv);        ckd_free(evt);        return NULL;    }    if ((rv = pthread_cond_init(&evt->cond, NULL)) != 0) {        E_ERROR_SYSTEM("Failed to initialize mutex: %d/n", rv);        pthread_mutex_destroy(&evt->mtx);        ckd_free(evt);        return NULL;    }    return evt;}

static intcalc_feat_idx(acmod_t *acmod, int frame_idx){    int n_backfr, feat_idx;    n_backfr = acmod->n_feat_alloc - acmod->n_feat_frame;    if (frame_idx < 0 || acmod->output_frame - frame_idx > n_backfr) {        E_ERROR("Frame %d outside queue of %d frames, %d alloc (%d > %d), cannot score/n",                frame_idx, acmod->n_feat_frame, acmod->n_feat_alloc,                acmod->output_frame - frame_idx, n_backfr);        return -1;    }    /* Get the index in feat_buf/framepos of the frame to be scored. */    feat_idx = ((acmod->feat_outidx + frame_idx - acmod->output_frame)                % acmod->n_feat_alloc);    if (feat_idx < 0) feat_idx += acmod->n_feat_alloc;    return feat_idx;}

blkarray_list_t *_blkarray_list_init(int32 maxblks, int32 blksize){    blkarray_list_t *bl;    if ((maxblks <= 0) || (blksize <= 0)) {        E_ERROR("Cannot allocate %dx%d blkarray/n", maxblks, blksize);        return NULL;    }    bl = (blkarray_list_t *) ckd_calloc(1, sizeof(blkarray_list_t));    bl->ptr = (void ***) ckd_calloc(maxblks, sizeof(void **));    bl->maxblks = maxblks;    bl->blksize = blksize;    bl->n_valid = 0;    bl->cur_row = -1;           /* No row is allocated (dummy) */    bl->cur_row_free = blksize; /* The dummy row is full */    return bl;}

/** * Map the given ngram string to an array of word IDs of the individual * words in the ngram. * * args: * ngram - the ngram string to map * length - the length of the ngram string * w - the word ID array * lm - the language model to use * * returns: * the number of words in the ngram string, or 0 if the string contains an * unknown word */intngram2wid(char *ngram, int length, s3lmwid32_t * w, lm_t * lm){    char *word[1024];    int nwd;    int i;    if ((nwd = str2words(ngram, word, length)) < 0)        E_FATAL("Increase word[] and w[] arrays size/n");    for (i = 0; i < nwd; i++) {        w[i] = lm_wid(lm, word[i]);        if (NOT_LMWID(lm, w[i])) {            E_ERROR("Unknown word: %s/n", word[i]);            return 0;        }    }    return nwd;}

voidutt_decode_block(float ***block_feat,   /* Incoming block of featurevecs */                 int32 no_frm,  /* No. of vecs in cepblock */                 int32 * curfrm,        /* Utterance level index of                                           frames decoded so far */                 kb_t * kb      /* kb structure with all model                                   and decoder info */    ){    srch_t *s;    s = (srch_t *) kb->srch;    /* These are necessary! */    s->uttid = kb->uttid;    s->uttfile = kb->uttfile;    if (srch_utt_decode_blk(s, block_feat, no_frm, curfrm) == SRCH_FAILURE) {        E_ERROR("srch_utt_decode_blk failed. /n");    }}

intacmod_rewind(acmod_t *acmod){    /* If the feature buffer is circular, this is not possible. */    if (acmod->output_frame > acmod->n_feat_alloc) {        E_ERROR("Circular feature buffer cannot be rewound (output frame %d, "                "alloc %d)/n", acmod->output_frame, acmod->n_feat_alloc);        return -1;    }    /* Frames consumed + frames available */    acmod->n_feat_frame = acmod->output_frame + acmod->n_feat_frame;    /* Reset output pointers. */    acmod->feat_outidx = 0;    acmod->output_frame = 0;    acmod->senscr_frame = -1;    acmod->mgau->frame_idx = 0;    return 0;}

int32 cep_write_bin(char const *file, float32 *buf, int32 len){  int32 fd;#ifdef WIN32 fd = open(file, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0644);#else  fd = open(file, O_WRONLY|O_CREAT|O_TRUNC, 0644);#endif  if (fd < 0) {    E_ERROR("Couldn't open %s for writing/n", file);    return errno;  }  len *= sizeof(float32);  if (write(fd, (char *)&len, sizeof(int32)) != sizeof(int32)) return -1;  if (write(fd, (char *)buf, len) != len) return -1;  if (close(fd) != ESUCCESS) return -1;  return ESUCCESS;}  

jsgf_t *jsgf_parse_file(const char *filename, jsgf_t * parent){    yyscan_t yyscanner;    jsgf_t *jsgf;    int yyrv;    FILE *in = NULL;    yylex_init(&yyscanner);    if (filename == NULL) {        yyset_in(stdin, yyscanner);    }    else {        in = fopen(filename, "r");        if (in == NULL) {            E_ERROR_SYSTEM("Failed to open %s for parsing", filename);            return NULL;        }        yyset_in(in, yyscanner);    }    jsgf = jsgf_grammar_new(parent);    if (!parent)        jsgf_set_search_path(jsgf, filename);    yyrv = yyparse(yyscanner, jsgf);    if (yyrv != 0) {        E_ERROR("Failed to parse JSGF grammar from '%s'/n",                filename ? filename : "(stdin)");        jsgf_grammar_free(jsgf);        yylex_destroy(yyscanner);        return NULL;    }    if (in)        fclose(in);    yylex_destroy(yyscanner);    return jsgf;}

huff_code_t *huff_code_build_str(char * const *values, int32 const *frequencies, int nvals){    huff_code_t *hc;    huff_node_t *root;    heap_t *q;    int i;    hc = (huff_code_t*)ckd_calloc(1, sizeof(*hc));    hc->refcount = 1;    hc->type = HUFF_CODE_STR;    /* Initialize the heap with nodes for each symbol. */    q = heap_new();    for (i = 0; i < nvals; ++i) {        heap_insert(q,                    huff_node_new_str(values[i]),                    frequencies[i]);    }    /* Now build the tree, which gives us codeword lengths. */    root = huff_code_build_tree(q);    heap_destroy(q);    if (root == 0 || root->nbits > 32) {        E_ERROR("Huffman trees currently limited to 32 bits/n");        huff_node_free_str(root, TRUE);        huff_code_free(hc);        return 0;    }    /* Build a canonical codebook. */    hc->maxbits = root->nbits;    huff_code_canonicalize(hc, root);    /* Tree no longer needed (note we retain pointers to its strings). */    huff_node_free_str(root, FALSE);    return hc;}

/** * Add a word to the word string and ID mapping. */int32ngram_add_word_internal(ngram_model_t * model,                        const char *word, int32 classid){    /* Check for hash collisions. */    int32 wid;    if (hash_table_lookup_int32(model->wid, word, &wid) == 0) {        E_WARN("Omit duplicate word '%s'/n", word);        return wid;    }    /* Take the next available word ID */    wid = model->n_words;    if (classid >= 0) {        wid = NGRAM_CLASSWID(wid, classid);    }    /* Reallocate word_str if necessary. */    if (model->n_words >= model->n_1g_alloc) {        model->n_1g_alloc += UG_ALLOC_STEP;        model->word_str = ckd_realloc(model->word_str,                                      sizeof(*model->word_str) *                                      model->n_1g_alloc);    }    /* Add the word string in the appropriate manner. */    /* Class words are always dynamically allocated. */    model->word_str[model->n_words] = ckd_salloc(word);    /* Now enter it into the hash table. */    if (hash_table_enter_int32        (model->wid, model->word_str[model->n_words], wid) != wid) {        E_ERROR            ("Hash insertion failed for word %s => %p (should not happen)/n",             model->word_str[model->n_words], (void *) (long) (wid));    }    /* Increment number of words. */    ++model->n_words;    return wid;}

static intcorpus_read_next_sent_file(char **trans){    FILE *fp;    lineiter_t *li;    /* open the current file */    fp = open_file_for_reading(DATA_TYPE_SENT);    li = lineiter_start_clean(fp);    if (li == NULL) {	E_ERROR("Unable to read data in sent file %s/n",		mk_filename(DATA_TYPE_SENT, cur_ctl_path));			return S3_ERROR;    }    *trans = strdup(li->buf);    lineiter_free(li);    fclose(fp);    return S3_SUCCESS;}

huff_code_t *huff_code_build_int(int32 const *values, int32 const *frequencies, int nvals){    huff_code_t *hc;    huff_node_t *root;    heap_t *q;    int i;    hc = ckd_calloc(1, sizeof(*hc));    hc->refcount = 1;    hc->type = HUFF_CODE_INT;    /* Initialize the heap with nodes for each symbol. */    q = heap_new();    for (i = 0; i < nvals; ++i) {        heap_insert(q,                    huff_node_new_int(values[i]),                    frequencies[i]);    }    /* Now build the tree, which gives us codeword lengths. */    root = huff_code_build_tree(q);    heap_destroy(q);    if (root == NULL || root->nbits > 64) {        E_ERROR("Huffman trees currently limited to 32 bits/n");        huff_node_free_int(root);        huff_code_free(hc);        return NULL;    }    /* Build a canonical codebook. */    hc->maxbits = root->nbits;    huff_code_canonicalize(hc, root);    /* Tree no longer needed. */    huff_node_free_int(root);    return hc;}

intsrch_FSG_dump_vithist(void *srch){    FILE *latfp;    char file[8192];    srch_t *s;    fsg_search_t *fsgsrch;    s = (srch_t *) srch;    fsgsrch = (fsg_search_t *) s->grh->graph_struct;    sprintf(file, "%s/%s.hist", cmd_ln_str("-bptbldir"), fsgsrch->uttid);    if ((latfp = fopen(file, "w")) == NULL)        E_ERROR("fopen(%s,w) failed/n", file);    else {        fsg_history_dump(fsgsrch->history, fsgsrch->uttid, latfp,                         fsgsrch->dict);        fclose(latfp);    }    return SRCH_SUCCESS;}

static fwd_dbg_t *init_fwd_dbg(srch_FLAT_FWD_graph_t * fwg){    const char *tmpstr;    fwd_dbg_t *fd;    fd = (fwd_dbg_t *) ckd_calloc(1, sizeof(fwd_dbg_t));    assert(fd);    /* Word to be traced in detail */    if ((tmpstr = cmd_ln_str_r(kbcore_config(fwg->kbcore), "-tracewhmm")) != NULL) {        fd->trace_wid = dict_wordid(fwg->kbcore->dict, tmpstr);        if (NOT_S3WID(fd->trace_wid))            E_ERROR("%s not in dictionary; cannot be traced/n", tmpstr);    }    else        fd->trace_wid = BAD_S3WID;    /* Active words to be dumped for debugging after and before the given frame nos, if any */    fd->word_dump_sf = (int32) 0x7ffffff0;    if (cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-worddumpsf"))        fd->word_dump_sf = cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-worddumpsf");    fd->word_dump_ef = (int32) 0x7ffffff0;    if (cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-worddumpef"))        fd->word_dump_ef = cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-worddumpef");    /* Active HMMs to be dumped for debugging after and before the given frame nos, if any */    fd->hmm_dump_sf = (int32) 0x7ffffff0;    if (cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-hmmdumpsf"))        fd->hmm_dump_sf = cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-hmmdumpsf");    fd->hmm_dump_ef = (int32) 0x7ffffff0;    if (cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-hmmdumpef"))        fd->hmm_dump_ef = cmd_ln_int32_r(kbcore_config(fwg->kbcore), "-hmmdumpef");    return fd;}

hmm_context_t *hmm_context_init(int32 n_emit_state,		 uint8 ** const *tp,		 int16 const *senscore,		 uint16 * const *sseq){    hmm_context_t *ctx;    assert(n_emit_state > 0);    if (n_emit_state > HMM_MAX_NSTATE) {        E_ERROR("Number of emitting states must be <= %d/n", HMM_MAX_NSTATE);        return NULL;    }    ctx = ckd_calloc(1, sizeof(*ctx));    ctx->n_emit_state = n_emit_state;    ctx->tp = tp;    ctx->senscore = senscore;    ctx->sseq = sseq;    ctx->st_sen_scr = ckd_calloc(n_emit_state, sizeof(*ctx->st_sen_scr));    return ctx;}

intngram_model_trie_write_bin(ngram_model_t * base, const char *path){    int i;    int32 is_pipe;    ngram_model_trie_t *model = (ngram_model_trie_t *) base;    FILE *fp = fopen_comp(path, "wb", &is_pipe);    if (!fp) {        E_ERROR("Unable to open %s to write binary trie LM/n", path);        return -1;    }    fwrite(trie_hdr, sizeof(*trie_hdr), strlen(trie_hdr), fp);    fwrite(&model->base.n, sizeof(model->base.n), 1, fp);    for (i = 0; i < model->base.n; i++) {        fwrite(&model->base.n_counts[i], sizeof(model->base.n_counts[i]),               1, fp);    }    lm_trie_write_bin(model->trie, base->n_counts[0], fp);    write_word_str(fp, base);    fclose_comp(fp, is_pipe);    return 0;}

static PJ *setup(PJ *P) {    struct pj_opaque *Q = P->opaque;    if ((Q->height = pj_param(P->ctx, P->params, "dh").f) <= 0.) E_ERROR(-30);    if (fabs(fabs(P->phi0) - M_HALFPI) < EPS10)        Q->mode = P->phi0 < 0. ? S_POLE : N_POLE;    else if (fabs(P->phi0) < EPS10)        Q->mode = EQUIT;    else {        Q->mode = OBLIQ;        Q->sinph0 = sin(P->phi0);        Q->cosph0 = cos(P->phi0);    }    Q->pn1 = Q->height / P->a; /* normalize by radius */    Q->p = 1. + Q->pn1;    Q->rp = 1. / Q->p;    Q->h = 1. / Q->pn1;    Q->pfact = (Q->p + 1.) * Q->h;    P->inv = s_inverse;    P->fwd = s_forward;    P->es = 0.;    return P;}

static intadd_phones(uint32 n_phone,	   lex_entry_t *e,	   acmod_set_t *acmod_set){    uint32 i;    char *nxt_phone;    e->phone = ckd_calloc(n_phone, sizeof(char *));    e->ci_acmod_id = ckd_calloc(n_phone, sizeof(uint32));    e->phone_cnt = n_phone;    for (i = 0; (nxt_phone = strtok(NULL, " /t")); i++) {	e->phone[i] = nxt_phone;	e->ci_acmod_id[i] =	    acmod_set_name2id(acmod_set, nxt_phone);	if (e->ci_acmod_id[i] == NO_ACMOD) {	    E_ERROR("Unknown phone %s/n", nxt_phone);	    ckd_free(e->phone);	    e->phone = NULL;	    ckd_free(e->ci_acmod_id);	    e->ci_acmod_id = NULL;	    e->phone_cnt = 0;	    return S3_ERROR;	}    }        assert(i == n_phone);    return S3_SUCCESS;}

FILE *s3_open_bin_write(const char *file_name,		  const char *version,		  const char *comment){    FILE *fp;    fp = fopen(file_name, "wb");    if (fp == NULL) {	E_WARN_SYSTEM("Unable to open %s for writing", file_name);	goto error;    }    if ((unsigned)fprintf(fp, "%s/n", version) !=	strlen(version)+1) {	E_ERROR("unable to write version id in %s",		file_name);    	goto error;    }    if (bcomment_write(fp, comment) != S3_SUCCESS) {	goto error;    }        if (swap_stamp(fp) != S3_SUCCESS) {	goto error;    }	    return fp;        error:        fclose(fp);    return NULL;}

const char *id_of(const char *buf){    uint32 i;    char *op, *cp;    static char id[128];        op = strrchr(buf, '(');    cp = strrchr(buf, ')');        if (op && cp) {	for (i = 0, ++op; op < cp; op++, i++) {	    id[i] = *op;	}	id[i] = '/0';    }    else {	E_ERROR("Unable to locate id field at end of line/n");	    	return NULL;    }    /* Fixed by awb 23/09/00, this didn't return anything before */    return id;} 

cmd_ln_t *cmd_ln_init(cmd_ln_t *inout_cmdln, const arg_t *defn, int32 strict, ...){    va_list args;    const char *arg, *val;    char **f_argv;    int32 f_argc;    va_start(args, strict);    f_argc = 0;    while ((arg = va_arg(args, const char *))) {        ++f_argc;        val = va_arg(args, const char*);        if (val == NULL) {            E_ERROR("Number of arguments must be even!/n");            return NULL;        }        ++f_argc;    }    va_end(args);    /* Now allocate f_argv */    f_argv = ckd_calloc(f_argc, sizeof(*f_argv));    va_start(args, strict);    f_argc = 0;    while ((arg = va_arg(args, const char *))) {        f_argv[f_argc] = ckd_salloc(arg);        ++f_argc;        val = va_arg(args, const char*);        f_argv[f_argc] = ckd_salloc(val);        ++f_argc;    }    va_end(args);    return parse_options(inout_cmdln, defn, f_argc, f_argv, strict);}

intcorpus_ckpt_set_interval(const char *fn){    FILE *fp;    uint32 o, rl;    fp = fopen(fn, "r");    if (fp == NULL) {	E_ERROR_SYSTEM("Can't open ckpt file %s", fn);	return S3_ERROR;    }    if (fscanf(fp, "%u %u", &o, &rl) != 2) {	E_ERROR("Problems reading ckpt file %s/n", fn);	fclose(fp);	return S3_ERROR;    }    fclose(fp);    return corpus_set_interval(o, rl);}