hshell.c

Hidden Markov Toolkit (HTK) 3.2.1 HTK is a toolkit for use in research into automatic speech recogn

  Prints toolname and then message to stderr.  Form of message and any
  subsequent arguments is similar to 'printf' with just %d %f %e %s being
  recognised.  If status<>0 then tool is aborted and status returned to OS,
  return status is also printed in error message in this case.
*/

/* EXPORT->HError: print error message on stderr and abort if status<>0 */
void HError(int errcode, char *message, ...)
{
   va_list ap;             /* Pointer to unnamed args */
   FILE *f;

   fflush(stdout);        /* Flush any pending output */
   va_start(ap,message);
   if (errcode<=0) {
      fprintf(stdout," WARNING [%+d]  ",errcode);
      f = stdout;
      vfprintf(f, message, ap);
      va_end(ap);
      fprintf(f," in %s\n", arglist[0]);
   }else{
      fprintf(stderr,"  ERROR [%+d]  ",errcode);
      f = stderr;
      vfprintf(f, message, ap);
      va_end(ap);
      fprintf(f,"\n FATAL ERROR - Terminating program %s\n", arglist[0]);
   }
   fflush(f);
   if (errcode>0) {
      if (abortOnError) abort();
      else Exit(errcode);
   }
}

/* EXPORT->HRError: New function - print error message on stderr and don't abort*/
void HRError(int errcode, char *message, ...)
{
   va_list ap;             /* Pointer to unnamed args */
   FILE *f;

   fflush(stdout);        /* Flush any pending output */
   va_start(ap,message);
   if (errcode<=0) {
      fprintf(stdout," WARNING [%+d]  ",errcode);
      f = stdout;
      vfprintf(f, message, ap);
      va_end(ap);
      fprintf(f," in %s\n", arglist[0]);
   }else{
      fprintf(stderr,"  ERROR [%+d]  ",errcode);
      f = stderr;
      vfprintf(f, message, ap);
      va_end(ap);
      fprintf(f,"\n");
   }
   fflush(f);
}

/* ------------------- Output Routines ----------------------- */

/* EXPORT->WriteShort: write n shorts to f */
void WriteShort (FILE *f, short *s, int n, Boolean binary)
{
   int j,x;
   short *p;
   
   if (binary){
      if (vaxOrder && !natWriteOrder){
         for(p=s,j=0;j<n;p++,j++)
            SwapShort(p);  /* Write in SUNSO unless natWriteOrder=T */
      }
      if (fwrite(s,sizeof(short),n,f) != n)
         HError(5014,"WriteShort: cant write to file");
      if (vaxOrder && !natWriteOrder){
         for(p=s,j=0;j<n;p++,j++)
            SwapShort(p);  /* Swap back */
      }
   } else {
      for (j=1; j<=n; j++){
         x = *s++;
         fprintf(f," %d",x);
      }
   }
}

/* EXPORT->WriteInt: write n ints to f */
void WriteInt(FILE *f, int *i, int n, Boolean binary)
{
   int j;
   int *p;
   
   if (binary){
      if (vaxOrder && !natWriteOrder){
         for(p=i,j=0;j<n;p++,j++)
            SwapInt32((int32*)p);  /* Write in SUNSO unless natWriteOrder=T */
      }
      if (fwrite(i,sizeof(int),n,f) != n)
         HError(5014,"WriteInt: cant write to file");
      if (vaxOrder && !natWriteOrder){
         for(p=i,j=0;j<n;p++,j++)
            SwapInt32((int32*)p);  /* Swap Back */
      }
   } else {
      for (j=1; j<=n; j++){
         fprintf(f," %d",*i++);
      }
   }
}

/* EXPORT->WriteFloat: write n floats to f */
void WriteFloat (FILE *f, float *x, int n, Boolean binary)
{
   int j;
   float *p;
   
   if (binary){
      if (vaxOrder && !natWriteOrder){
         for(p=x,j=0;j<n;p++,j++)
            SwapInt32((int32*)p);  /* Write in SUNSO unless natWriteOrder=T */
      }
      if (fwrite(x,sizeof(float),n,f) != n)
         HError(5014,"WriteFloat: cant write to file");
      if (vaxOrder && !natWriteOrder){
         for(p=x,j=0;j<n;p++,j++)
            SwapInt32((int32*)p);  /* Swap Back */
      }
   } else {
      for (j=1; j<=n; j++){
         fprintf(f," %e",*x++);
      }
   }
}

/* -------------------- File Name Handling ------------------- */

/*
  Given a filename of the general form "path/n.x" in fn, the following
  functions return "n.x", "n", "x" and "path", respectively. In each case,
  the string is returned in s which must be large enough and s is returned
  as the function result.
*/

/* EXPORT->CheckFn: Check (and modify) fn matches machine path conventions */
static char *CheckFn(char *fn)
{
   if (fn==NULL) return(fn);
#ifdef ALTPATHCHAR
   {
      char *s;
      for(s=fn; *s!=0; s++) 
         if (*s==ALTPATHCHAR) *s=PATHCHAR;
   }
#endif
   return(fn);
}

/* EXPORT->NameOf: name of fn */
char * NameOf(char *fn, char *s)
{
   char *t;

   CheckFn(fn);
   t = strrchr(fn,PATHCHAR);
   if (t == NULL) 
      t = fn;
   else 
      t++;
   return strcpy(s,t);
}

/* EXPORT->BaseOf: base name part of fn */
char * BaseOf(char *fn, char *s)
{
   char *t;
   
   NameOf(fn,s);
   t = strrchr(s,'.');
   if (t == NULL) return s;
   if (t>=s) *t = '\0';
   return s;
}

/* EXPORT->PathOf: path part of fn */
char * PathOf(char *fn, char *s)
{
   char *t;
   
   CheckFn(fn);
   strcpy(s,fn);
   t = strrchr(s,PATHCHAR);
   if (t == NULL) 
      *s='\0';
   else
      *++t = '\0';
   return s;
}

/* EXPORT->ExtnOf: extension part of fn */
char * ExtnOf(char *fn, char *s)
{
   char *t,buf[100];
   
   NameOf(fn,buf);
   t = strrchr(buf,'.');
   if (t == NULL){
      *s ='\0'; return s;
   }
   return strcpy(s,t+1);
}

/* EXPORT->MakeFN: construct a filename from fn */
char * MakeFN(char *fn, char *path, char *ext, char *s)
{
   char newPath[MAXFNAMELEN], base[MAXSTRLEN], newExt[MAXSTRLEN];  /* components of new fn */
   int i;
   
   CheckFn(path);
   BaseOf(fn,base);
   if (path==NULL) 
      PathOf(fn,newPath);
   else
      strcpy(newPath,path);
   if (ext==NULL)
      ExtnOf(fn,newExt);
   else 
      strcpy(newExt,ext);
   i = strlen(newPath);
   if (i>0 && newPath[i-1] != PATHCHAR) {
      newPath[i] = PATHCHAR;
      newPath[i+1] = '\0';
   }
   strcpy(s,newPath);
   strcat(s,base);
   if (strlen(newExt) > 0) {
      strcat(s,".");
      strcat(s,newExt);
   }
   return s;
}

/* EXPORT->CounterFN: generate a file name with embedded count */
char * CounterFN(char *prefix, char* suffix, int count, int width, char *s)
{
   char num[20];

   sprintf(num,"%0*d",width,count);
   s[0] = '\0';
   if (prefix!=NULL) strcat(s,prefix);
   strcat(s,num);
   if (suffix!=NULL) strcat(s,suffix);
   return s;
}


/* ------------------- Pattern Matching ------------------- */

/* RMatch: recursively match s against pattern p, minplen
   is the min length string that can match p and
   numstars is the number of *'s in p */
Boolean RMatch(char *s,char *p,int slen,int minplen,int numstars)
{
   if (slen==0 && minplen==0)
      return TRUE;
   if (numstars==0 && minplen!=slen)
      return FALSE;
   if (minplen>slen)
      return FALSE;
   if (*p == '*')
      return RMatch(s+1,p+1,slen-1,minplen,numstars-1) ||
         RMatch(s,p+1,slen,minplen,numstars-1) ||
         RMatch(s+1,p,slen-1,minplen,numstars);
   if (*p == *s || *p == '?')
      return RMatch(s+1,p+1,slen-1,minplen-1,numstars);
   else
      return FALSE;  
}

/* EXPORT->DoMatch: return TRUE if s matches pattern p */
Boolean DoMatch(char *s, char *p)
{
   int slen, minplen, numstars;
   char *q,c;
   
   slen = strlen(s);
   minplen = 0; numstars = 0; q = p;
   while ((c=*q++))
      if (c == '*') ++numstars; else ++minplen;
   return RMatch(s,p,slen,minplen,numstars);
}


/* SpRMatch: recursively match s against pattern p, minplen
   is the min length string that can match p and
   numstars is the number of *'s in p 
	   spkr is next character of the spkr name */
static Boolean SpRMatch(char *s,char *p,char *spkr,
			int slen,int minplen,int numstars)
{
   Boolean match;
   
   if (slen==0 && minplen==0)
      match=TRUE;
   else if ((numstars==0 && minplen!=slen) || minplen>slen)
      match=FALSE;
   else if (*p == '*') {
      match=(SpRMatch(s+1,p,spkr,slen-1,minplen,numstars) ||
	     SpRMatch(s,p+1,spkr,slen,minplen,numstars-1) ||
	     SpRMatch(s+1,p+1,spkr,slen-1,minplen,numstars-1));
   }
   else if (*p == '%') {
      *spkr=*s,spkr[1]=0;
      match=SpRMatch(s+1,p+1,spkr+1,slen-1,minplen-1,numstars);
      if (!match) *spkr=0;
   }
   else if (*p == *s || *p == '?')
      match=SpRMatch(s+1,p+1,spkr,slen-1,minplen-1,numstars);
   else
      match=FALSE;
   
   return(match);
}

/* EXPORT->MaskMatch: return spkr if s matches pattern p */
Boolean MaskMatch(char *mask, char *spkr, char *str)
{
   int spkrlen, slen, minplen, numstars;
   char *q,c;
  
   if (mask == NULL || str==NULL) return(FALSE);
   slen = strlen(str);
   spkrlen = minplen = numstars = 0;
   q = mask;
   while ((c=*q++)) {
      if (c == '*') ++numstars; else ++minplen;
      if (c == '%') ++spkrlen;
   }
   if (spkrlen>=MAXSTRLEN)
      HError(3390,"MaskMatch: Speaker name too long %d vs %d",spkrlen,MAXSTRLEN);
   spkr[0]=0;
   if (SpRMatch(str,mask,spkr,slen,minplen,numstars))
      return(TRUE);
   else {
      spkr[0]=0;
      return(FALSE);
   }
}

static char *savedCommandLine;
/* SaveCommandLine: Stores all command line arguments in 1 string */
static void SaveCommandLine(int argc, char **argv)
{
   int i, len=0;

   for (i=0;i<argc;i++)
      len+=strlen(argv[i])+1;
   savedCommandLine = (char *) malloc(len);
   savedCommandLine[0]='\000';
   strcat(savedCommandLine, argv[0]);
   for (i=1;i<argc;i++)
      sprintf(savedCommandLine,"%s %s", savedCommandLine, argv[i]);
}
/* EXPORT->RetrieveCommandLine: return a pointer to the saved command
line string */
char *RetrieveCommandLine(void)
{
   return savedCommandLine;
}

/* ------------------- Initialisation ------------------- */

/* EXPORT->InitShell:   Called by main to initialise the module.
   Main passes over the command line arguments which are then
   copied after processing -A/-B/-C/-S/-V.  */
ReturnStatus InitShell(int argc, char *argv[], char *ver, char *sccs)
{
   char *fn;
   int i,j;
   Boolean b;

   argcount = 1; arglist = (char **) malloc(argc*sizeof(char *));
   arglist[0] = argv[0];
   Register(ver,sccs);
   Register(hshell_version,hshell_vc_id);
   /* read default configuration parameter file, if any */
   if ((fn=getenv("HCONFIG")) != NULL){
      if(ReadConfigFile(fn)<SUCCESS){
         HRError(5020,"InitShell: ReadConfigFile failed on file %s", fn);
         return(FAIL);
      }
   }
   SaveCommandLine(argc, argv);
   
#ifdef WIN32
   _fmode = _O_BINARY;
#endif   
   vaxOrder = IsVAXOrder();

   /* copy arg list and process -C and/or -S options */
   for (i=1; i<argc; i++){
      if (strcmp(argv[i],"-A") == 0){
         for (j=0; j<argc; j++)
            printf("%s ",argv[j]);
         printf("\n"); fflush(stdout);
         infoPrinted = TRUE;
      } else
         if (strcmp(argv[i],"-C") == 0){
            if (++i >= argc){ 
               HRError(5020,"InitShell: Config file name expected");
               return(FAIL);
            }
            if(ReadConfigFile(argv[i])<SUCCESS){
               HRError(5020,"InitShell: ReadConfigFile failed on file %s", argv[i]);
               return(FAIL);
            }
         } else
            if (strcmp(argv[i],"-S") == 0){
               if (++i >= argc){ 
                  HRError(5020,"InitShell: Script file name expected");
                  return(FAIL);
               }
               if(SetScriptFile(argv[i])<SUCCESS){
                  HRError(5020,"InitShell: SetScriptFile failed on file %s", argv[i]);
                  return(FAIL);
               }
            } else
               if (strcmp(argv[i],"-V") == 0){
                  printVersionInfo = TRUE;
                  infoPrinted = TRUE;
               } else
                  if (strcmp(argv[i],"-D") == 0){
                     showConfig = TRUE;
                     infoPrinted = TRUE;
                  } else
                     arglist[argcount++] = argv[i];
   }
   if (showConfig)
      PrintConfig();
   /* process this module's config params */
   nParm = GetConfig("HSHELL", TRUE, cParm, MAXGLOBS);
   if (nParm>0) {
      if (GetConfInt(cParm,nParm,"TRACE",&i)) trace = i;
      if (GetConfBool(cParm,nParm,"NONUMESCAPES",&b)) noNumEscapes = b;
      if (GetConfBool(cParm,nParm,"ABORTONERR",&b)) abortOnError = b;
      if (GetConfBool(cParm,nParm,"NATURALREADORDER",&b)) natReadOrder = b;
      if (GetConfBool(cParm,nParm,"NATURALWRITEORDER",&b)) natWriteOrder = b;
      if (GetConfBool(cParm,nParm,"EXTENDFILENAMES",&b)) extendedFileNames = b;
      if (GetConfInt(cParm,nParm,"MAXTRYOPEN",&i)) {
         maxTry = i;
         if (maxTry<1 || maxTry>3){
            HRError(5073,"InitShell: MAXTRYOPEN out of range (%d)",maxTry);
            maxTry=1;
         }
      }
   }

   
   return(SUCCESS);
}


/* EXPORT->PrintStdOpts: print standard options */
void PrintStdOpts(char *opt)
{
   printf(" -A      Print command line arguments         off\n");
   if (strchr(opt,'B'))
      printf(" -B      Save HMMs/transforms as binary       off\n");
   printf(" -C cf   Set config file to cf                default\n");
   printf(" -D      Display configuration variables      off\n");
   if (strchr(opt,'E')) {
      printf(" -E s [s] set dir for parent xform to s       off\n");
      printf("         and optional extension                 \n");
   }
   if (strchr(opt,'F'))
      printf(" -F fmt  Set source data format to fmt        as config\n");
   if (strchr(opt,'G'))
      printf(" -G fmt  Set source label format to fmt       as config\n");
   if (strchr(opt,'H'))
      printf(" -H mmf  Load HMM macro file mmf\n");
   if (strchr(opt,'I'))
      printf(" -I mlf  Load master label file mlf\n");
   if (strchr(opt,'J')) {
      printf(" -J s [s] set dir for input xform to s        none\n");
      printf("         and optional extension                 \n");
   }
   if (strchr(opt,'K')) {
      printf(" -K s [s] set dir for output xform to s       none\n");
      printf("         and optional extension                 \n");
   }
   if (strchr(opt,'L'))
      printf(" -L dir  Set input label (or net) dir         current\n");
   if (strchr(opt,'M'))
      printf(" -M dir  Dir to write HMM macro files         current\n");
   if (strchr(opt,'O'))
      printf(" -O      Set target data format to fmt        as config\n");
   if (strchr(opt,'P'))
      printf(" -P      Set target label format to fmt       as config\n");
   if (strchr(opt,'Q'))
      printf(" -Q      Print command summary\n");
   printf(" -S f    Set script file to f                 none\n");
   printf(" -T N    Set trace flags to N                 0\n");
   printf(" -V      Print version information            off\n");
   if (strchr(opt,'X'))
      printf(" -X ext  Set input label (or net) file ext    lab\n");
}

/* -------------------------- End of HShell.c ----------------------------- */