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

/* UpWeights: update given mixture weights */void UpWeights(int i, int s, int M, WtAcc *wa, StreamElem *ste){   int m;   float sum=0.0;      if (wa->occ == 0.0)      HError(2127,"UpWeights: zero occ i=%d/s=%d",i,s);   for (m=1; m<=M; m++){      sum += wa->c[m];      switch(hset.hsKind){      case PLAINHS:      case SHAREDHS:         ste->spdf.cpdf[m].weight = wa->c[m] / wa->occ;         break;      case TIEDHS:         ste->spdf.tpdf[m] = wa->c[m] / wa->occ;         break;      }   }   if (fabs(sum-wa->occ)/sum > 0.001)      HError(2190,"UpWeights: mix weight sum error");}

/* UpMeans: update mean, leave old mean in acc */void UpMeans(int i, int s, int m, int size, MuAcc *ma, Vector mean){   int k;   float x;      if (ma->occ == 0.0)      HError(2127,"UpMeans: zero occ i=%d/s=%d/m=%d",i,s,m);   for (k=1; k<=size; k++){      x = mean[k] + ma->mu[k]/ma->occ;      ma->mu[k] = mean[k];  /* remember old mean */      if (uFlags&UPMEANS) mean[k] = x;   }}

/* FloorMixes: apply floor to given mix set */void FloorMixes(HMMSet *hset, MixtureElem *mixes, int M, float floor){   float sum,fsum,scale;   MixtureElem *me;   int m;      if (hset->logWt == TRUE) HError(999,"FloorMixes requires linear weights");   sum = fsum = 0.0;   for (m=1,me=mixes; m<=M; m++,me++) {      if (MixWeight(hset,me->weight)>floor)         sum += me->weight;      else {         fsum += floor; me->weight = floor;      }   }   if (fsum>1.0) HError(2327,"FloorMixes: Floor sum too large");   if (fsum == 0.0) return;   if (sum == 0.0) HError(2328,"FloorMixes: No mixture weights above floor");   scale = (1.0-fsum)/sum;   for (m=1,me=mixes; m<=M; m++,me++)      if (me->weight>floor) me->weight *= scale;}

void CheckUpdateSetUp(){  AdaptXForm *xf;  xf = xfInfo.paXForm;  if ((xfInfo.paXForm != NULL) && !(uFlags&UPXFORM)) {    while (xf != NULL) {       if ((xf->xformSet->xkind != CMLLR) && (xf->xformSet->xkind != SEMIT))	HError(999,"SAT only supported with SEMIT/CMLLR transforms");      xf = xf->parentXForm;    }  }}

/* GenSentences: top level control of the sentence generator */void  GenSentences(char * latfn, char * dicfn){   int i,min,max,len;   double e,p;   MemHeap lheap;   FILE *f;   Boolean isPipe;   InitVocab(&voc);   if(ReadDict(dicfn,&voc)<SUCCESS)      HError(3413,"GenSententces:ReadDict failed" );   CreateHeap(&lheap,"Lattice Heap",MSTAK,1,0.4,1000,5000);   if ((f=FOpen(latfn,NetFilter,&isPipe)) == NULL)      HError(3410,"GenSentences: Can't open lattice file %s",latfn);   if((lat = ReadLattice(f, &lheap, &voc, TRUE, FALSE))==NULL)      HError(3410,"GenSentences: ReadLattice failed");   FClose(f,isPipe);   if (trace&T_TOP)      printf("HSGen %d sents from lattice %s/dictionary %s/n",             ngen,latfn,dicfn);   psSum = 0.0; lenSum = 0; min = 100000; max = 0;   if (trace&T_DET) quiet = TRUE;  /* kill output if detailed trace */   for (i=1; i<=ngen; i++){      len = GenSent(i);      lenSum += len;      if (len>max) max = len;      if (len<min) min = len;   }   if (stats)  {      ComputeVSize();      e = psSum / lenSum;      p = exp(e);      e = e / log(2.0);      printf("Entropy = %f,  Perplexity = %f/n",e,p);      printf("%d Sentences: average len = %.1f, min=%d, max=%d/n",             ngen,(float)lenSum/ngen,min,max);   }}

/* GetNode: read a node definition and create node */static VQNode GetNode(Source *src, CovKind ck, short width){   char buf[MAXSTRLEN];   VQNode n;   short vqidx,nid,lid,rid;   Vector mean;   Covariance cov;   vqidx = GetVal(src,0,0,"VQ Index");   nid = GetVal(src,0,0,"Node Id");   lid = GetVal(src,0,0,"Left Id");   rid = GetVal(src,0,0,"Right Id");   mean = CreateVector(&vqHeap,width);   if (!ReadVector(src, mean, FALSE))      HError(6150,"GetNode: cannot read mean vector at %s",             SrcPosition(*src, buf));   switch(ck){   case NULLC:      cov.var = NULL;      n = CreateVQNode(vqidx,nid,lid,rid,mean,ck,cov);      break;   case INVDIAGC:      cov.var = CreateVector(&vqHeap,width);      if (!ReadVector(src, cov.var, FALSE))         HError(6150,"GetNode: cannot read variance vector at %s",                SrcPosition(*src, buf));      n = CreateVQNode(vqidx,nid,lid,rid,mean,ck,cov);      break;   case FULLC:      cov.inv = CreateTriMat(&vqHeap,width);      if (!ReadTriMat(src, cov.inv, FALSE))         HError(6150,"GetNode: cannot read covariance matrix at %s",                SrcPosition(*src, buf));      n = CreateVQNode(vqidx,nid,lid,rid,mean,ck,cov);      break;   }   return n;}

/* EXPORT->LoadMasterFile: Load the Master Label File stored in fname                            and append the entries to the MLF table */void LoadMasterFile(char *fname){   char buf[MAXFNAMELEN];   char *men;        /* end of mode indicator */   char *pst,*pen;   /* start/end of pattern (inc quotes) */   char *dst=NULL,*den=NULL;   /* start/end of subdirectory (inc quotes) */   Boolean inEntry = FALSE;   /* ignore ".." within an entry */   MLFEntry *e;   FILE *f;      if (numMLFs == MAXMLFS)      HError(6520,"LoadMasterFile: MLF file limit reached [%d]",MAXMLFS);   if ((f = fopen(fname,"rb")) == NULL)      HError(6510,"LoadMasterFile: cannot open MLF %s",fname);   if (fgets(buf,MAXFNAMELEN,f) == NULL)      HError(6513,"LoadMasterFile: MLF file is empty");   if (NoMLFHeader(buf))      HError(6551,"LoadMasterFile: MLF file header is missing");    incSpaces=FALSE;   while (fgets(buf,MAXFNAMELEN,f) != NULL){      if (!inEntry && FindMLFStr(buf,&pst,&pen)) {         e = (MLFEntry *)New(&mlfHeap,sizeof(MLFEntry));         e->type = FindMLFType(pen+1,&men);         if (e->type == MLF_IMMEDIATE) {            e->def.immed.fidx = numMLFs;            e->def.immed.offset = ftell(f);            if (e->def.immed.offset < 0)               HError(6521,"LoadMasterFile: cant ftell on MLF file");            inEntry = TRUE;         } else {            if (!FindMLFStr(men+1,&dst,&den))               HError(6551,"LoadMasterFile: Missing subdir in MLF/n(%s)",buf);            *den = '/0';            e->def.subdir = NewString(&mlfHeap,den-dst-1);            strcpy(e->def.subdir,dst+1);         }         *pen = '/0';         /* overwrite trailing pattern quote */         ++pst;               /* skipover leading pattern quote */         e->patType = ClassifyMLFPattern(pst);         if (e->patType == PAT_ANYPATH)             pst += 2;         /* skipover leading "* /" */         e->pattern = NewString(&mlfHeap,pen-pst);         strcpy(e->pattern,pst);         e->patHash = (e->patType==PAT_GENERAL)?0:MLFHash(e->pattern);         StoreMLFEntry(e);      } else         if (inEntry && IsDotLine(buf)) inEntry = FALSE;   }   if (compatMode && incSpaces)      HError(-6551,"LoadMasterFile: . or %s on line with spaces in %s",             LEVELSEP,fname);   mlfile[numMLFs++] = f;}

/* EXPORT->ASpec2LPCep: Perform IDFT to get autocorrelation values then            produce autoregressive coeffs. and cepstral transform them */void ASpec2LPCep (Vector as, Vector ac, Vector lp, Vector c, DMatrix cm){   float lpcGain, E;   /* Do IDFT to get autocorrelation values */   E = MatrixIDFT(as, ac, cm);   lp[VectorSize(lp)] = 0.0;    /* init to make Purify et al. happy */   /* do Durbin recursion to get predictor coefficients */   lpcGain = Durbin(NULL,lp,ac,E,VectorSize(ac)-1);   if (lpcGain<=0)       HError(-5323,"ASpec2LPCep: Negative lpcgain");   LPC2Cepstrum(lp,c);   c[VectorSize(c)] = (float) -log((double) 1.0/lpcGain); /* value forms C0 */}

/* StoreOOV: store OOV wdid/count into ps */static void StoreOOV(PStats *ps, LabId wdid, int count){   int n;   ps->oov[ps->uniqOOV].wdid  = wdid;   ps->oov[ps->uniqOOV].count = count;   ps->uniqOOV++; ps->nOOV++;   if (ps->uniqOOV==MAX_OOV) {     n = SortOOV(ps);     printf("StoreOOV: sorting OOVs, compacting %d -> %d/n",MAX_OOV,n);     if (n==MAX_OOV)       HError(16630,"Maximum number of unique OOV's [%d] reached/n",MAX_OOV);  }}

/* UpTrans: update transition parameters */void UpTrans(TrAcc *ta, Matrix tr){   int i,j;   float occi,x,sum;   for (i=1; i<nStates; i++){      occi = ta->occ[i];      if (occi == 0.0)         HError(2127,"UpTrans: zero occ in state %d",i);      sum = 0.0;      tr[i][1] = LZERO;      for (j=2;j<=nStates;j++) {         x = ta->tran[i][j]/occi;         tr[i][j] = x; sum += x;      }      if (fabs(sum-1.0) > 0.001)         HError(2190,"UpTrans: row %d, sum=%f",i,sum,occi);      for (j=2;j<=nStates;j++) {         x = tr[i][j]/sum;         tr[i][j] = (x<MINLARG) ? LZERO : log(x);      }   }}

/* FindVQTable: find VQ table with given name and unless magic is 0, check                that it is same, return NULL if not found */static VQTable FindVQTable(char * tabFN, short magic){   Boolean found=FALSE;   VQTable p;   for (p=vqList; p!=NULL && !found; p=p->next)      if (strcmp(tabFN,p->tabFN)==0){         if (magic != 0 && magic != p->magic)            HError(6170,"FindVQTable: %s has magic=%d but new magic=%d",                   tabFN,p->magic,magic);         return p;      }   return NULL;}

/* FindBestMixes: for each state/obs pair find most likely mix component */void FindBestMixes(int segNum, int segLen, IntVec states, IntVec *mixes){   int i,s,m,bestm,M=0;   StreamElem *ste;   IntVec smix;   Observation obs;   Vector v;   LogFloat bestP,p;   MixtureElem *me;   MixPDF *mp;   if (trace&T_MIX)      printf(" Mixture component alignment/n");   for (i=1; i<=segLen; i++){      ste = hmmLink->svec[states[i]].info->pdf+1;      obs = GetSegObs(segStore, segNum, i);      if (hset.hsKind == TIEDHS)         PrecomputeTMix(&hset, &obs, 0.0, 1);      for (s=1; s<=nStreams; s++,ste++){         if (hset.hsKind != TIEDHS)            M = ste->nMix;         smix = mixes[s];         if (hset.hsKind==TIEDHS) /* PrecomputeTMix has already sorted probs */            bestm = hset.tmRecs[s].probs[1].index;         else if (M==1)            bestm = 1;            else{            v = obs.fv[s];            bestP = LZERO; bestm=0;            if (trace&T_MIX)               printf("  seg %d, stream %d: ",i,s);            for (m=1; m<=M; m++){               me =  ste->spdf.cpdf+m;               mp = me->mpdf;               p = MOutP(v,mp);               if (p>bestP){                  bestP=p; bestm=m;               }               if (trace&T_MIX)                  printf(" P(mix[%d])=%.1f",m,p);            }            if (bestm==0)               HError(2125,"FindBestMixes: no best mix");            if (trace&T_MIX)               printf(" [best=%d]/n",bestm);         }         smix[i] = bestm;      }   }}

void LoadNetwork(){   FILE *nf;   Boolean isPipe;   int n=0;   CreateHeap(&wdNetHeap,"Lattice heap",MSTAK,1,0.0,4000,4000);   if ( (nf = FOpen(wdNetFn,NetFilter,&isPipe)) == NULL)      HError(3210,"LoadNetwork: Cannot open Word Net file %s",wdNetFn);   if((wdNet = ReadLattice(nf,&wdNetHeap,&vocab,TRUE,FALSE))==NULL)      HError(3210,"LoadNetwork: ReadLattice failed");   FClose(nf,isPipe);   printf("Read Word Network with %d nodes / %d arcs/n",wdNet->nn,wdNet->na);   CreateHeap(&netHeap,"Net heap",MSTAK,1,0,      wdNet->na*sizeof(NetLink),wdNet->na*sizeof(NetLink));   net = ExpandWordNet(&netHeap,wdNet,&vocab,&hset);   printf("Created network with %d nodes / %d links/n",      net->numNode,net->numLink);}

/* EXPORT->GetVQ: get vq indices for vectors in fv */void GetVQ(VQTable vqTab, int numS, Vector *fv, short *vq){   short s,idx,size;   float bestx, x,xl,xr;   VQNode n,bestn;   Vector v;   for (s=1; s<=numS; s++) {      n = vqTab->tree[s]; v = fv[s];      size = VectorSize(v);      if (n==NULL)         HError(6174,"GetVQ: null tree in stream %d",s);      if (size != vqTab->swidth[s])         HError(6174,"GetVQ: stream %d width incompatible",s);      switch(vqTab->type){      case linTree:         bestn = n; bestx = VQNodeScore(n,v,size,vqTab->ckind);         for(n=bestn->right; n != NULL; n=n->right){            x = VQNodeScore(n,v,size,vqTab->ckind);            if (x<bestx) {               bestx = x; bestn = n;            }         }         idx = bestn->vqidx;         break;      case binTree:         while (n->right != NULL){            xr = VQNodeScore(n->right,v,size,vqTab->ckind);            xl = VQNodeScore(n->left,v,size,vqTab->ckind);            n =  (xr<xl)?n->right:n->left;         }         idx = n->vqidx;         break;      }      vq[s] = idx;   }}

/* LoadHTKLabels: load a HTK transcription */static void LoadHTKLabels(MemHeap *x, Transcription *t, Source *src){   LabList *ll;   int alt = 0;      InitTrScan();   GetTrSym(src,TRUE);   if (trSym==TRNUM || trSym==TRSTR){      ll = LoadHTKList(x,src,++alt);      AddLabelList(ll,t);      while (trSym == TRLEV){         GetTrSym(src,TRUE);         if (trSym != TREOL)            HError(6550,"LoadHTKList: End of Line after /// Expected");                GetTrSym(src,TRUE);         ll = LoadHTKList(x,src,++alt);         AddLabelList(ll,t);      }   }   while (trSym==TREOL)       GetTrSym(src,TRUE);   if (trSym != TREOF)      HError(6550,"LoadHTKLabels: Junk at end of HTK transcription");}

/* CreateDataFileList: */static void CreateDataFileList(){   char *datafn;   g_nDataFileNum = 0;   do {      if (NextArg() != STRINGARG)         HError(2319, "HMGenS: data file name expected");      datafn = GetStrArg();      g_pDataFileList[g_nDataFileNum] = (TDataFile *) New(&gstack, sizeof(TDataFile));      strcpy(g_pDataFileList[g_nDataFileNum]->datafn, datafn);      g_pDataFileList[g_nDataFileNum]->bValid = TRUE;      g_nDataFileNum++;   } while (NumArgs() > 0);}

/* CheckGenSetUp: Check & setup GenInfo structure */static void CheckGenSetUp(void){   int d, p, r, s, stream;   PdfStream *pst = NULL;   /* # of PdfStreams */   genInfo->nPdfStream[0] = (nPdfStr == NULL) ? hset.swidth[0] : IntVecSize(nPdfStr);   if (genInfo->nPdfStream[0] > hset.swidth[0])      HError(6604, "CheckGenSetUp: # of PdfStreams (%d) is too large (should be less than %d)", genInfo->nPdfStream[0], hset.swidth[0]);   /* size of each PdfStreams */   r = hset.swidth[0];   for (p = stream = 1; p <= genInfo->nPdfStream[0]; stream += genInfo->nPdfStream[p++]) {      pst = &(genInfo->pst[p]);      /* # of streams in this PdfStream */      genInfo->nPdfStream[p] = (nPdfStr == NULL) ? 1 : nPdfStr[p];      r -= genInfo->nPdfStream[p];      /* calculate vector size for this PdfStream */      for (s = stream, pst->vSize = 0; s < stream + genInfo->nPdfStream[p]; s++)         pst->vSize += hset.swidth[s];      /* order (vecSize of static feature vector) of this PdfStream */      pst->order = (pdfStrOrder == NULL) ? 1 : pdfStrOrder[p];      if (pst->order < 1 || pst->order > pst->vSize)         HError(6604, "CheckGenSetUp: Order of PdfStream %d should be within 1--%d", p, pst->vSize);      /* window coefficients */      if (winFn[p] == NULL)         HError(6604, "CheckGenSetUp: window file names are not specified");      pst->win.num = (int) winFn[p][0][0];      if (pst->win.num > MAXWINNUM)         HError(6604, "CheckGenSetUp: # of window out of range");      if (pst->win.num * pst->order != pst->vSize)         HError(6604, "CheckGenSetUp: # of window (%d) times order (%d) should be equal to vSize (%d)", pst->win.num, pst->order, pst->vSize);      for (d = 0; d < pst->win.num; d++)         MakeFN(winFn[p][d + 1], winDir, winExt, pst->win.fn[d]);   }   if (r != 0)      HError(6604, "CheckGenSetUp: # of streams in HMMSet (%d) and PdfStreams (%d) are inconsistent", hset.swidth[0], genInfo->nPdfStream[0]);   /* output trace information */   if (trace & T_TOP) {      for (p = 1; p <= genInfo->nPdfStream[0]; p++) {         printf("PdfStream [%d]:/n", p);         printf("  #streams: %d (vSize=%d)/n", genInfo->nPdfStream[p], genInfo->pst[p].vSize);         printf("  #order:   %d/n", genInfo->pst[p].order);         printf("  file ext: %s/n", genInfo->pst[p].ext);         for (d = 0; d < genInfo->pst[p].win.num; d++)            printf("  %d-th window: %s/n", d, genInfo->pst[p].win.fn[d]);      }      printf("/n");      fflush(stdout);   }}

/* CalcCovs: calculate covariance of speech data */void CalcCovs(void){   int x,y,s,V;   float meanx,meany,varxy,n;   Matrix fullMat;      if (totalCount<2)      HError(2021,"CalcCovs: Only %d speech frames accumulated",totalCount);   if (trace&T_TOP)      printf("%ld speech frames accumulated/n", totalCount);   n = (float)totalCount;     /* to prevent rounding to integer below */   for (s=1; s<=hset.swidth[0]; s++){  /* For each stream   */      V = hset.swidth[s];      for (x=1; x<=V; x++)            /* For each coefficient ... */         accs[s].meanSum[x] /= n;         /* ... calculate mean */      for (x=1;x<=V;x++) {         meanx = accs[s].meanSum[x];      /* ... and [co]variance */         if (fullcNeeded[s]) {            for (y=1; y<=x; y++) {               meany = accs[s].meanSum[y];               varxy = accs[s].squareSum.inv[x][y]/n - meanx*meany;               accs[s].squareSum.inv[x][y] =                  (x != y || varxy > minVar) ? varxy : minVar;                }         }         else {            varxy = accs[s].squareSum.var[x]/n - meanx*meanx;            accs[s].fixed.var[x] = (varxy > minVar) ? varxy :minVar;         }      }      if (fullcNeeded[s]) { /* invert covariance matrix */         fullMat=CreateMatrix(&gstack,V,V);         ZeroMatrix(fullMat);          CovInvert(accs[s].squareSum.inv,fullMat);         Mat2Tri(fullMat,accs[s].fixed.inv);         FreeMatrix(&gstack,fullMat);      }      if (trace&T_COVS) {         printf("Stream %d/n",s);         if (meanUpdate)            ShowVector(" Mean Vector ", accs[s].meanSum,12);         if (fullcNeeded[s]) {            ShowTriMat(" Covariance Matrix ",accs[s].squareSum.inv,12,12);         } else            ShowVector(" Variance Vector ", accs[s].fixed.var,12);      }   }}

void SetuFlags(void){   char *s;      s=GetStrArg();   uFlags=(UPDSet) 0;         while (*s != '/0')      switch (*s++) {      case 'm': uFlags = (UPDSet) (uFlags+UPMEANS); break;      case 'v': uFlags = (UPDSet) (uFlags+UPVARS); break;      case 'w': uFlags = (UPDSet) (uFlags+UPMIXES); break;      case 't': uFlags = (UPDSet) (uFlags+UPTRANS); break;      default: HError(2120,"SetuFlags: Unknown update flag %c",*s);         break;      }}

/* ClusterVecs: apply required clustering to vectors in stream s */void ClusterVecs(Sequence *seq, int s){   switch(tType) {   case binTree:      cs[s] = TreeCluster(&cStack,seq[s],cbSizes[s],ck,ck,cov[s]);      break;      case linTree:      cs[s] = FlatCluster(&cStack,seq[s],cbSizes[s],ck,ck,cov[s]);      break;      default:      HError(2590,"ClusterVecs: Unsupported tree type %d",tType);   }   if(trace&T_CLUST) ShowClusterSet(cs[s]);}

/* EXPORT->ResetHeap: Free all items from heap x */void ResetHeap(MemHeap *x){   BlockP cur,next;      if(x==&gstack)	x=&(HThreadSelf()->gstack);   LOCK   switch(x->type){   case MHEAP:      if (trace&T_TOP)         printf("HMem: ResetHeap %s[M]/n",x->name);      cur=x->heap;      /* delete all blocks */      while (cur != NULL) {         next = cur->next;         free(cur->data); free(cur->used);         free(cur); cur = next;      }      x->curElem = x->minElem;      x->totAlloc = 0; x->heap = NULL;      break;   case MSTAK:      if (trace&T_TOP)         printf("HMem: ResetHeap %s[S]/n",x->name);      cur=x->heap;      if (cur != NULL) {         /* delete all blocks but first */         while (cur->next != NULL) {            next = cur->next;            x->totAlloc -= cur->numElem;            free(cur->data); free(cur);            cur = next;         }         x->heap = cur;      }      x->curElem = x->minElem;      if (cur != NULL){         cur->numFree = cur->numElem;         cur->firstFree = 0;      }      break;   case CHEAP:      HError(5172,"ResetHeap: cannot reset C heap");   }   x->totUsed = 0;   UNLOCK}

/* SortEntries: use the id fields of the supplied list of nodes                to build the required linTree or binTree */static VQNode SortEntries(VQNode *list, short rootId){   VQNode newNode;   newNode = FindVQNode(list,rootId);   if (newNode == NULL)      HError(6173,"SortEntries: cannot find node %d",rootId);   if (newNode->lid != 0)      newNode->left = SortEntries(list,newNode->lid);   else      newNode->left = NULL;   if (newNode->rid != 0)      newNode->right = SortEntries(list,newNode->rid);   else      newNode->right = NULL;   return newNode;}

/* OpenWaveFile: open source wave file and extract portion if indicated */HTime OpenWaveFile(char *src){   Wave w, cw;   long nSamps;   short *data;   if((w = OpenWaveInput(&iStack,src,srcFF,0,0,&srcSampRate))==NULL)      HError(1013,"OpenWaveFile: OpenWaveInput failed");   srcPK = WAVEFORM;   tgtSampRate = srcSampRate;   cw = (chopF)?ChopWave(w,st,en,srcSampRate) : w;   data = GetWaveDirect(cw,&nSamps);   wv = OpenWaveOutput(&oStack, &srcSampRate, nSamps);   PutWaveSample(wv,nSamps,data);   CloseWaveInput(cw);   return(nSamps*srcSampRate);}

/* UnRecordHeap: remove given heap from list */static void UnRecordHeap(MemHeap *x){   MemHeapRec *p, *q;      p = heapList; q = NULL;   while (p != NULL && p->heap != x){      q = p;      p = p->next;   }   if (p == NULL)      HError(5171,"UnRecordHeap: heap %s not found",x->name);   if (p==heapList)       heapList = p->next;   else      q->next = p->next;   free(p);}

/* EXPORT->DeleteHeap: delete given heap */void DeleteHeap(MemHeap *x){   if (x->type == CHEAP)       HError(5172,"DeleteHeap: cant delete C Heap %s",x->name);   if (trace&T_TOP)      printf("HMem: DeleteHeap %s/n",x->name);   /* free all data blocks */   ResetHeap(x);   if (x->heap != NULL){      free(x->heap->data);      free(x->heap);   }   /* expunge all trace of it */   UnRecordHeap(x);   /* free name */   free(x->name);}

HRESULT CPkcs7::SaveIntoJavaClassFile(FILEHANDLE hFile,LPCOLESTR wszFileName,BOOL fClearDirty)// Save this signed data (presumably already signed) into the right place in the class file	{	HRESULT hr = S_OK;	CFileStream stm;	if (stm.OpenFileForWriting(hFile, wszFileName, FALSE))		{		IPersistStream* pPerStream;		hr = CJavaClassFile::CreateInstance(NULL, IID_IPersistStream, (LPVOID*)&pPerStream);		if (hr == S_OK)			{			hr = pPerStream->Load(&stm);						// load the class file			if (hr == S_OK)				{				BLOB b;				hr = CPersistMemoryHelper2::Save(&b, FALSE);	// get our bits				if (hr == S_OK)					{					IInsertSig* pSig;					hr = pPerStream->QueryInterface(IID_IInsertSig, (LPVOID*)&pSig);					if (hr == S_OK)						{						hr = pSig->SaveSig(&b);					// stuff our bits in						pSig->Release();						}					FreeTaskMem(b);					}				if (hr == S_OK)					{					stm.Reset();					stm.Truncate();					hr = pPerStream->Save(&stm, FALSE);			// save the class file					}				}			pPerStream->Release();			}		}	else		hr = HError();	if (hr == S_OK && fClearDirty)		m_isDirty = FALSE;	return hr;	}

/* EXPORT-> HPlotVector: plot vector v in given rectangle */void HPlotVector(int x0, int y0, int x1, int y1, Vector v, int st, int en, float ymax, float ymin){   float yScale, yOffset, xInc, x;   int   xOld, yOld, ix, iy, i;        if (st >= en || st < 1 || en > VectorSize(v))      HError(6815, "HPlotVector: Plot indices %d -> %d out of range", st, en);   x = (x1 - x0 - 1); xInc = x/(en - st);   yScale  = (y1 - y0)/(ymin - ymax);   yOffset = y0 - ymax*yScale;   x = x0; xOld = x; yOld = v[st]*yScale + yOffset;   for (i = st+1; i <= en; i++){      x += xInc; ix = x;      iy = v[i]*yScale + yOffset;      HDrawLine(xOld,yOld,ix,iy);      xOld = ix; yOld = iy;   } }

   ln = lat->lnodes; ln->word = wd; ln->n=0; ln->v=0;   ln = lat->lnodes+1; ln->word = wd; ln->n=0; ln->v=0;   ln = lat->lnodes+nNode-1; ln->word = wd; ln->n=0; ln->v=0;   ln = lat->lnodes+nNode-2; ln->word = wd; ln->n=0; ln->v=0;   ln = lat->lnodes+2;   for (i = 0; i< VHASHSIZE; i++)      for ( wd = voc->wtab[i]; wd != NULL; wd = wd->next )          if ((wd != voc->nullWord) && (wd != voc->subLatWord)) {            ln->word = wd;            ln++;         }   la =lat->larcs;   la->start = lat->lnodes;     la->end = lat->lnodes+1;    la->lmlike = 0.0;   la = lat->larcs+1;   la->start = lat->lnodes+nNode-2;     la->end = lat->lnodes+nNode-1;   la->lmlike = 0.0;   la = lat->larcs+2;   la->start = lat->lnodes+nNode-2;      la->end = lat->lnodes+1;   la->lmlike = 0.0;   la = lat->larcs+3;   for (i = 0; i < voc->nwords; i++) {      la->start = lat->lnodes+1;

   HTime period;   int sampSize;   int numComps;   long nSamples;}HeadInfo;/* PrBar: print a horizantal bar of length n including title */void PrBar(char *title){   int i,len,n;      if (rawOut) return;   len = strlen(title);   n = (barwidth - len)/2;   for (i=1; i<n; i++) putchar(barc);   printf(" %s ",title);   n = barwidth - n - len;   for (i=1; i<n; i++) putchar(barc);   putchar('/n');}   /* SetBarWidth: set bar width according to nItems and item type */void SetBarWidth(int itemWidth)

static ConfParam *cParm[MAXGLOBS];      /* config parameters */static int nParm = 0;static MemHeap hashTableHeap;           /* heap for hash tables *//* --------------------- Initialisation --------------------- *//* EXPORT -> InitWMap: initialise the module */void InitLUtil(void)