trsapi.c

微软的基于HMM的人脸识别原代码, 非常经典的说

    tmpBuf[tmpBufIdx]=ch;
    tmpBufIdx++;
    if (tmpBufIdx<tmpBufLen)  tmpBuf[tmpBufIdx]=0;
  }
}

static void StoreArg(char key){
  int        idx=key-'?';

  if ((KeyStr[idx]!=NULL) && (KeyStr[idx]!=NullStr))
    free(KeyStr[idx]);
  if (strlen(tmpBuf)==0)
    KeyStr[idx]=NullStr;
  else
    KeyStr[idx]=StringDup(tmpBuf);
}

static void AssignCmd(char *cmd) {
  cmdBufLen=strlen(cmd);
  cmdBuf=cmd;
  cmdBufIdx=0;
}

static void NextCh(void) {
  if (cmdBufIdx<cmdBufLen) {
    cmdBufIdx=cmdBufIdx+1;
    Ch=cmdBuf[cmdBufIdx];
  }
}

static void ParseSwitches(char *cmd){
  enum {PS_INIT,PS_RD_KEY,PS_SKIP_SPACE,PS_RD_QUOTED,PS_RD_SPACED,PS_END}
       state;
  char key=0;
  char keyargbuf[INPBUF_LEN];
  char qmark=0;

  AssignCmd(cmd);
  KeysWithArg("?aBcdDfFghHilLmoqrRsStTxZ");
  state=PS_INIT;
  NextCh();

  while (state!=PS_END) {
    switch (state) {
      case PS_INIT:
        switch (Ch) {
          case ' ': NextCh();break;
          case '-': state=PS_RD_KEY;NextCh();break;
          case EOL: state=PS_END;break;
          default : state=PS_END;InvalidKey(' ');break;
        };
        break;
      case PS_RD_KEY:
        switch (Ch) {
          case ' ': state=PS_INIT;NextCh();break;
          case EOL: /*state=PS_INIT;AssignCmd(cmd);*/
                    state=PS_END;
                    break;
          case '-': Ch='Z';                     /* convert -- to -Z          */
          default : if (((Ch>='a') && (Ch<='z')) ||
                        ((Ch>='?') && (Ch<='Z')))
                    {
                      key=Ch;
                      NextCh();
                      ResetKeyArgBuf(keyargbuf,INPBUF_LEN);
                      if (MayHasArg(key))
                        state=PS_SKIP_SPACE;
                      else
                        StoreArg(key);
                    } else {
                      state=PS_END;InvalidKey(Ch);
                    };
        };
        break;
      case PS_SKIP_SPACE:
        switch (Ch) {
          case ' ' : NextCh();
                     if (Ch=='-') {
                       state=PS_RD_KEY;StoreArg(key);NextCh();
                     };
                     break;
          case EOL : state=PS_END;StoreArg(key);break;
          case SQ  :
          case DQ  : state=PS_RD_QUOTED;qmark=Ch;NextCh();break;
          default  : state=PS_RD_SPACED;
        };
        break;
      case PS_RD_QUOTED:
        if (Ch==qmark) {
          state=PS_SKIP_SPACE;NextCh();
        } else {
          switch (Ch) {
            case EOL : state=PS_END;StoreArg(key);break;
            default  : StoreCh(Ch);NextCh();
          };
        };
        break;
      case PS_RD_SPACED:
        switch (Ch) {
          case EOL : state=PS_END;StoreArg(key);break;
          case SQ  :
          case DQ  : state=PS_RD_QUOTED;qmark=Ch;NextCh();break;
          case ' ' : NextCh();
                     if (Ch=='-') {
                       state=PS_RD_KEY;StoreArg(key);NextCh();
                     } else {
                       state=PS_SKIP_SPACE;StoreCh(' ');
                     };
                     break;
          default  : StoreCh(Ch);NextCh();
        };
        break;
      default:
        state=PS_END;break;
    };
  };
}

static void ParseCmdLine(int argC, char *argV[]){
  int     i;
  char   *p;
  char    ch;
/*  char   *path,*filename

  printf("argC=%d\n",argC);for(i=0;i<argC;i=i+1) printf("%d. '%s'\n",i,argV[i]);
*/
  strcpy(ExePath,argV[0]);
  p=strrchr(ExePath,'.');
  if (p) (*p)=0;
/*  
  path=StringDup(ExePath);
  filename=StringDup(ExePath);

  StrParse(path,"/",2,path,filename);
*/
  strcpy(Cmd,ExePath);
  strcat(Cmd,".sum");
  SumFileName=StringDup(Cmd);

  strcpy(Cmd,ExePath);
  strcat(Cmd,".ini");
  IniFileName=StringDup(Cmd);

  strcpy(Cmd,ExePath);
  strcat(Cmd,".lst");
  LstFileName=StringDup(Cmd);

  strcpy(Cmd,ExePath);
  strcat(Cmd,".csv");
  CsvFileName=StringDup(Cmd);

  strcpy(ExePath,argV[0]);
  p=strrchr(ExePath,CatalogSep);
  if (p) *(p+1)=0;
    else ExePath[0]=0;

  Cmd[0]=0;
  for (i=1; i<argC; i=i+1) {            /* Restore command line              */
    strcat(Cmd," ");
    strcat(Cmd,argV[i]);
  };
  ParseSwitches(Cmd);
  for (ch='?';ch<='z';ch++)
    if (trsGetKeyArg(ch)!=NULL) {
      printf("<%c>:[%s]\n",ch,trsGetKeyArg(ch));
    };
}
/* ==========================================================================*/
static void NL(int i) {if (i) printf("\n");}

static int Mismatch(char ch, char* str) {
  const char *name=trsGetKeyArg(ch);

  if (name) {
    if (name[0]=='?') return FALSE;
    if (strcmp(name, str)) return TRUE;
  }
  return FALSE;
}

static int MismatchFileName(char ch, char* str) {
  const char *name=trsGetKeyArg(ch);
  char       *fname=strrchr(str,'\\');

  if (name) {
    if (name[0]=='?') return FALSE;
    if (!fname) fname=str; else fname++;
#ifdef __BORLANDC__
	 if (stricmp(name, fname)) return TRUE;
#elif defined WIN32
	 if (_stricmp(name, fname)) return TRUE;
#else
	 if (strcasecmp(name, fname)) return TRUE;
#endif
  }
  return FALSE;
}

static int PrintFieldInfo(char ch,char *str){
  const char *name=trsGetKeyArg(ch);
  if ((name) &&(name[0] =='?')) {printf(" [%s]",str); return 1;}
  return 0;
}

static int CompareFields(TRSid_t *ptr){
  int info=0;

  if (Mismatch('f',ptr->funcname)) return FALSE;
  if (Mismatch('t',ptr->testname)) return FALSE;
  if (Mismatch('c',ptr->testclass)) return FALSE;
  if ((Mismatch('S',ptr->file)) && (MismatchFileName('S',ptr->file))) return FALSE;
  if (Mismatch('T',ptr->proctext )) return FALSE;

  info+=PrintFieldInfo('S',ptr->file);
  info+=PrintFieldInfo('c',ptr->testclass);
  info+=PrintFieldInfo('f',ptr->funcname);
  info+=PrintFieldInfo('t',ptr->testname);
  info+=PrintFieldInfo('T',ptr->proctext);

  NL(info);

  if (info) return FALSE;

  return TRUE;
}

static FILE * OpenTstFile(FILE ** file, char **fname, char key,char *mode) {
  char    *keyval;
/*  const char    *keyval;*/

  keyval=(char*)trsGetKeyArg(key);
  if (keyval) {
    if (keyval!=NullStr) {
      if (*fname) free(*fname);
      *fname=StringDup(keyval);
    }
    if (*file) fclose(*file);
    (*file)=fopen(*fname,mode);
  }
  return (*file);
}

static void trsCSVHeader(void);

static int ProcessKeys(void){
  const char    *keyval;
  int            intval;
  int            res;

  keyval=trsGetKeyArg('m');
  if (!keyval) trsMoreSize(DEFAULT_PAGE_SIZE);
  else {
    res=sscanf(keyval,"%u",&intval);
    if (res!=1) intval=0;
    trsMoreSize(intval);
  }

  keyval=trsGetKeyArg('L');
  if (keyval) {
/*    LoopMode=TRUE;*/
    res=sscanf(keyval,"%u",&LoopMax);
    if (res!=1) LoopMax=1;
  }

  keyval=trsGetKeyArg('r');
  if (keyval) {
    ReRunMode=TW_RERUN;
    res=sscanf(keyval,"%u",&ReRunCount);
    if (res!=1) ReRunCount=0;
  }

  if (trsGetKeyArg('d')) DebugMode=TW_DEBUG;

  OpenTstFile(&LstFile,&LstFileName,'l',"w");
  OpenTstFile(&SumFile,&SumFileName,'s',"w");
  OpenTstFile(&CsvFile,&CsvFileName,'C',"w");
  trsCSVHeader();

  keyval=trsGetKeyArg('i');

  if ((keyval) && (keyval[0]))
    IniFileName=reStringDup(IniFileName,keyval);

  if (trsGetKeyArg('?')) return CmdLineHelp(FALSE);
  if (trsGetKeyArg('h')) return CmdLineHelp(FALSE);
  if (trsGetKeyArg('H')) return CmdLineHelp(TRUE);

  return TRUE;
}

static TRSid_t *FindPrev(TRSid_t *current){
  TRSid_t       *ptr,*prev;

  ptr=TestList;prev=TestList;
  while (ptr!=current) {
    prev=ptr;
    ptr=ptr->next;
  };
  return prev;
}

static void trsInit(TRSid_t *ptr) {
  int appnamelen;

  appnamelen=strlen(ptr->funcname)+strlen(ptr->testclass)+
             strlen(ptr->proctext)+3;           /* +.+.+\0                   */
  TestAppName=(char*)trsreAlloc(TestAppName,appnamelen);
  strcpy(TestAppName,ptr->funcname);  strcat(TestAppName,".");
  strcat(TestAppName,ptr->testclass); strcat(TestAppName,".");
  strcat(TestAppName,ptr->proctext);
  trsGuardPattern(0xA55A,4);                       /* Set guardAlloc pattern    */

#ifdef ANYLIB
  iplSetErrStatus(IPL_StsOk);                    /* Set context               */
  iplSetErrMode(IPL_ErrModeParent);
#endif

  TstLastStatus=TRS_StsOk;
  TstStdErrMode=TRS_ErrModeParent;
  srand(1);                                      /* remove tests influence */
}

static void DeleteAppList(void);
static int trsCSVClose(void);

static void trsTerminateAll(void){
  TRSid_t  *ptr;
  int         i;

  DeleteAppList();
  LoadIniFileName=(char*)trsFree(LoadIniFileName);
  DeleteComments();

  if (LstFile) fclose(LstFile);                 /* Close Lst file       */
  if (SumFile) fclose(SumFile);                 /* Close Lst file       */
  if (CsvFile) trsCSVClose();

  while (TestList) {                            /* Release test reg memory   */
    ptr=TestList;
    TestList=TestList->next;
    free(ptr);
  }
  for (i=0;i<KEYARRSIZE;i=i+1)
    if (KeyStr[i]!=NullStr)
      trsFree(KeyStr[i]);

  trsFree(ResultString);
  trsFree(TestAppName);
  trsFree(SumFileName);
  trsFree(IniFileName);
  trsFree(LstFileName);
  trsFree(CsvFileName);
}
/* ==========================================================================*/
TRSFUN(void, trsCommandLine,(int argc, char *argv[])) {
  if (argc||argv) return;               /* for compatibility with timapi.c   */
}


TRSFUN(int, trsRun,(int argC, char *argV[]))
{
  TRSid_t               *ptr;
  int                    FailsFound=0;

#ifdef ANYLIB
  IPLErrorCallBack       oldStdError;
  const IPLLibVersion   *lib;
#endif

  TotalTime=time(NULL);

  ParseCmdLine(argC,argV);

  if (!ProcessKeys()) return TRS_QUIT;

  RunMode=TW_RUN;
  ptr=TestList;

#ifdef ANYLIB
  oldStdError=iplRedirectError(newStdError);
  lib=iplGetLibVersion();

  printf("--- Testing %s,%s,%s,%s,%s ---\n",
         lib->Name,lib->Version,lib->InternalVersion,lib->CallConv,lib->BuildDate);
  if (SumFile) fprintf(SumFile,"--- Testing %s,%s,%s,%s,%s ---\n",
         lib->Name,lib->Version,lib->InternalVersion,lib->CallConv,lib->BuildDate);
#endif

  while (ptr != NULL ) {

    Trs_CurrentTest=ptr;

    if (CompareFields(ptr)) {
      TestTime=time(NULL);
      TestResult=TRS_UNDEF;
      Trs_ReadSource=TRS_None;

      DeleteComments();
      trsPrintHeader(ptr,TRUE);
      Trs_FlowStatus=TRS_CONTINUE;
      trsInit(ptr);
      trs_arInit();
      Terminate=NULL;

      for (LoopCount=0;LoopCount<LoopMax;LoopCount++) {
        if (Trs_FlowStatus==TRS_CONTINUE) {
          if (!ptr->status)                       /* Invoking the test         */
            TestResult=((TRSProc_t)    ptr->test)();
          else
            TestResult=((TRSProcArg_t) ptr->test)(ptr->arg);
          if (Terminate)
             TestResult=Terminate(TestResult);
          if (TestResult==TRS_FAIL)
             FailsFound=1;
        }
      }
      trs_arTerminate();

      WrLn("");
      if (TestResult!=TRS_UNDEF)
         trsPrintFooter(Trs_CurrentTest);

      switch (Trs_FlowStatus) {          /* Some actions with return value     */
        case TRS_RETRY:
                WrLn("-Retrying test...\n");continue;
        case TRS_PREVIOUS:
                WrLn("-Previous test...\n");
                ptr=FindPrev(ptr);
                continue;
        case TRS_TOP:
                WrLn("-Top of list\n");
                ptr=TestList;continue;
        case TRS_QUIT:
                WrLn("-Cancel all tests.\n");break;
        case TRS_CONTINUE:
                WrLn("");
        case TRS_EXIT:
                WrLn("-Next test.\n");break;
        default:
                printf("-Unknown test return status: %d\n",TestResult);