trsread.c

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

  if (valfromlist) {
    res=FillDst(value,currentvalue->val_adr,
                currentvalue->extra,currentvalue->valtp);
    currentvalue->value=reStringDup(currentvalue->value,value);
    if (!res) {
      Warning("Read: Illegal format");
      return FALSE;                    /*FALSE                            */
    };                                /*from while continue next or current*/
    ptr=currentvalue;
  } else {
    res=FillDst(value,dst,extra,dsttype);
    if (!res) {
        Warning("Read: Illegal format");
        Trs_ReadSource=TRS_None;
        return FALSE;                    /*   FALSE                        */
    };                                /*from while continue next or current*/
    ptr=AddInpValueList(valuename,value,dsttype,dst,extra,help);
    if (!ptr) {
        TRS_ERROR(TRS_StsNoMem,"AssignValue","No space for new value");
        Trs_FlowStatus=TRS_QUIT;
        return FALSE;
    };
    Trs_ReadSource=inpmode;
    CurrentEntryPtr=ptr;
  };
  if (DstToFile) PutToFile(ptr->valname,ptr->value,ptr->valhelp);
  return TRUE;
}

static int ParseTokenAssign(char *name,char *cptr,void *dst,TRSfvr_t dsttype,
                     void *extra,char *help,int inplstflg) {

  char          *iwrk;
  TRSfvr_t        valuetype;
  char          dstname[INPBUF_LEN],srcname[INPBUF_LEN];
  InpValueType  *ptr,*dptr=NULL;
  char          headbuf[INPBUF_LEN],tailbuf[INPBUF_LEN];
  int           valfromlist,res,i,dstfromfl=0;


  strcpy(dstname,name);
  strcpy(headbuf,cptr);
  valfromlist=0;
  valuetype=dsttype;
  i=StrParse2(headbuf,"=",headbuf,tailbuf);
  if (i==0) {
    res=StrParse2(headbuf,"<",headbuf,tailbuf);
    if (res==0) {                               /* "=" noexist               */
      strcpy(tailbuf,headbuf);
      headbuf[0]=0;
    } else {
      dstfromfl=1;
      if (headbuf[0]=='*') {
        headbuf[0]=0;
        SrcFromFile=TRUE;
      };
    };
  };
                                                /* parser destination        */
  if (headbuf[0]!=0) {
    strcpy(dstname,headbuf);
    if (strcmp(dstname,name)!=0) {              /* dstname != name           */
                                                /* search in ValueList       */
      dptr=ScanValueList(dstname);
      if (dptr!=NULL) {
        valfromlist=1;
        valuetype=dptr->valtp;
      } else  {                                 /* first occasion put string */
                                                /* into InputList            */
        if (dstfromfl) {
          strcpy(headbuf,"<");
          strcat(headbuf,tailbuf);
        } else strcpy(headbuf,tailbuf);
        AddInputListEntry(dstname,headbuf,inplstflg);
        return TRUE;
      };
    } else Trs_ReadSource=TRS_TTYInput;
  };
                                                /* Parser source             */
  if (dstfromfl) {
    strcpy(srcname,dstname);
    iwrk=GetDstFromFile(tailbuf,srcname);
    if (!iwrk) {
      if (!valfromlist) Trs_ReadSource=TRS_NoInFile;
      return TRUE;
    };
    printf("Read from file: %s=%s\n",srcname,iwrk);
    res=AssignValue(valfromlist,dptr,iwrk,name,dst,dsttype,
                    extra,help,TRS_FileInput);
    if (res==FALSE) {
     if (Trs_FlowStatus==TRS_QUIT) return FALSE;
     return TRUE;
    };
  } else {                                      /* letter or number        */
    if (((valfromlist==1) &&
        ((valuetype==text_fvr) || (valuetype==case_fvr) || (valuetype==bit_fvr))) ||
        ((valfromlist==0) &&
        ((dsttype==text_fvr) || (dsttype==case_fvr) || (dsttype==bit_fvr))))
    {
      res=AssignValue(valfromlist,dptr,tailbuf,name,dst,dsttype,
                      extra,help,TRS_TTYInput);
      if ((res==FALSE) && (Trs_FlowStatus==TRS_QUIT)) return FALSE;
      return TRUE;
    };
    if ((tailbuf[0]=='+') || (tailbuf[0]=='-') || (tailbuf[0]=='.')
    || ((tailbuf[0]>='0') && (tailbuf[0]<='9'))) { /* number               */
      res=AssignValue(valfromlist,dptr,tailbuf,name,dst,dsttype,
                      extra,help,TRS_TTYInput);
      if (res==FALSE) {
        if (Trs_FlowStatus==TRS_QUIT) return FALSE;
        return TRUE;
      };
    } else {                                    /* letter                  */
      strcpy(srcname,tailbuf);
      ptr=ScanValueList(srcname);
      if (ptr!=NULL) {
        if (ptr->valtp!=valuetype) {
          Warning("Read: Incompatible src and dst types");
          Trs_ReadSource=TRS_None;
          return TRUE;
        } else {
          res=AssignValue(valfromlist,dptr,ptr->value,name,dst,dsttype,
                          extra,help,TRS_TTYInput);
          if (res==FALSE) {
            if (Trs_FlowStatus==TRS_QUIT) return FALSE;
            return TRUE;
          };
        };
      } else {                                  /* src undefined         */
        Warning("Read: Source undefined");
        return TRUE;
      };
    }; /**/
  };
  return TRUE;
}

/*===========================================================================*/

static int ParseInput(void *dst,char *tname,char *buf,TRSfvr_t dsttype,
               void *extra,char *help,int inplstflg) {

  char          *cptr,*wptr;
  char          srcname[50]="";
  InpValueType  *ptr;
  TokenListType *ptoken;
  int            res;

    Trs_FlowStatus=TRS_CONTINUE;
    res=ParseTokens(buf,";");
    if (res==FALSE) {
      ErrorMess("ParseInput: No memory");
      Trs_FlowStatus=TRS_QUIT;
      return FALSE;
    };
    if (TokenList==NULL) {
      Trs_FlowStatus=TRS_CONTINUE;
      return TRUE;
    };

    for (ptoken=TokenList;ptoken!=NULL; ptoken=ptoken->next) {
      cptr=ptoken->token;                       /* get token                 */
      if((!cptr) || (*cptr==0)) continue;
      if ((ptoken==TokenList)  &&  ((dsttype==text_fvr) ||
                                    (dsttype==case_fvr) ||
                                    (dsttype==bit_fvr))) {
        res=AssignValue(0,NULL,cptr,tname,dst,dsttype,
                        extra,help,TRS_TTYInput);
        if ((res==FALSE) && (Trs_FlowStatus==TRS_QUIT)) return FALSE;
        continue;
      };
      while (*cptr==' ') cptr++;
      if (*cptr == '!') {                       /* command;                  */
        cmdAct(cptr);
        if (trsStatus()==TRS_CONTINUE) continue;
        DeleteTokenList();
        return FALSE;
      };
      if (*cptr=='?') {                         /* help                      */
        cptr++;
        trsPrintHelp(Trs_CurrentTest,*cptr,tname,"",help);
        continue;                              /* exit from while            */
      };

      wptr=cptr;

      cptr=strchr(wptr,'>');
      if (cptr){
        srcname[0]=0;
        ParseFileAppKey(cptr+1,srcname);

        if (*wptr=='*') {                       /* "*>a.dat                  */

          if (ValueList!=NULL) {
            ptr=ValueList;
            while (ptr!=NULL) {
              PutToFile(ptr->valname,ptr->value,ptr->valhelp);
              ptr=ptr->next;
            };
          };

        } else {
          if ((trsReadSource()!=TRS_None)&&(CurrentEntryPtr)) {
            if (srcname[0]==0)
              PutToFile(CurrentEntryPtr->valname,CurrentEntryPtr->value,CurrentEntryPtr->valhelp);
            else
              PutToFile(srcname,CurrentEntryPtr->value,CurrentEntryPtr->valhelp);
          };
        };
        continue;
      };
      if (!ParseTokenAssign(tname,wptr,dst,dsttype,extra,help,inplstflg)) return FALSE;
    };
    DeleteTokenList();
    return TRUE;
}

/* ==========================================================================*/

TRSAPI(int,trs_Read,(void *dst,char *name,void *extra,char *def,char *help,TRSfvr_t dsttype)) {

  char           workbuf[INPBUF_LEN],buf[INPBUF_LEN];
  char          *cptr;
  char           srcname[50];
  InpListType   *iptr;
  InpValueType  *ptr;
  int            res,ires;
  char*          tname=name+1;
  char           sep[2]=" ";
  char           head[INPBUF_LEN],tail[INPBUF_LEN],_typename[50];

  if (dsttype==text_fvr)tname=tname-1;
  Trs_ReadSource=TRS_None;

  if ((dsttype==case_fvr)||(dsttype==bit_fvr)) {
    sep[0]=*(char*)extra;
    StrParse2((char*)extra,(char*)sep,(char*)head,(char*)tail);
  };
  iptr=ScanInpList(tname);              /* test2. dst already defined (search*/
                                        /* in input list )                   */
  if (iptr)                             /* search in inputlist               */
  {                                     /* find                              */
    cptr=workbuf;
    cptr=strcpy(cptr,iptr->inputdst);
    cptr=strcat(cptr,"=");
    cptr=strcat(cptr,iptr->inputsrc);
    if (ParseTokenAssign(tname,cptr,dst,dsttype,extra,help,0)) {
       if (trsReadSource()!=TRS_None) {
         if (!iptr->lorgflg) Trs_ReadSource=TRS_IndirectTTY;
         else Trs_ReadSource=TRS_CmdLine;
         DeleteInpListEntry(iptr);
         return TRUE;
       } else DeleteInpListEntry(iptr);
    };
  };
  if (SrcFromFile) {                    /* test 3. dst from file             */
    strcpy(srcname,tname);
    cptr=GetDstFromFile(Trs_String,srcname);

    if (cptr) {
      printf("From file: %s=%s\n",srcname,cptr);
      res=FillDst(cptr,dst,extra,dsttype);
      if (res) {
        ptr=AddInpValueList(tname,cptr,dsttype,dst,extra,help);
        Trs_ReadSource=TRS_FileInput;
        if (DstToFile) PutToFile(ptr->valname,ptr->value,ptr->valhelp);
        return TRUE;
      };
    };
    Trs_ReadSource=TRS_NoInFile;
  };

  strcpy(_typename,TypeName[dsttype]);
  if ((dsttype==case_fvr)||(dsttype==bit_fvr)) strcpy(_typename,tail);

  for(;;) {
    res=CmdWithoutPrefix(buf,TypePrompt[dsttype],tname,_typename,def,help);
    switch (res) {
      case RETRY : continue;
      case FALSE : return FALSE;
      case TRUE  : ires=ParseInput(dst,tname,buf,dsttype,extra,help,0);
                   if (ires==FALSE) return FALSE;
                   if ((trsReadSource()==TRS_None) ||
                   (trsReadSource()==TRS_NoInFile) ||
                   (trsReadSource()==TRS_DefaultNull)  ||
                   (trsReadSource()==TRS_Default)) break;
                   Trs_FlowStatus=TRS_CONTINUE;
                   return TRUE;
    };
  };
}
TRSAPI(int, CmdWithoutPrefix,(char *buf,  char *prompt, char *dstname,
                     char *type,char *def,    char *help)) {

  char           bufwdefault[COMMONLEN];

  if (trsGetKeyArg('B')==NULL)
    trsMoreSize(Trs_PageSize);
  printf("%s%s, %s",prompt,dstname,type);
  if (def) printf(", [%s]",def);
  if (Trs_ReadSource==TRS_NoInFile)
     printf("?> ");
  else
     printf(" > ");

  CurrentEntryPtr=NULL;
  Trs_FlowStatus=TRS_CONTINUE;
  gets(buf);
  for (;;) {
    switch (buf[0]) {
      case  ';':
      case  0  : if (!def) {
                   Trs_ReadSource=TRS_DefaultNull;
                   Trs_FlowStatus=TRS_CONTINUE;
                   if (buf[0]==';') return TRUE;
                   return FALSE;
                 }
                 Trs_ReadSource=TRS_Default;
                 if (def[0]==0) {
                   if (buf[0]==';') return TRUE;
                   return RETRY;
                 };
                 strcpy(bufwdefault,def);
                 strcat(bufwdefault,buf);
                 strcpy(buf,bufwdefault);
                 continue;
      case '!' :switch (buf[1]) {
                  case 'q': Trs_FlowStatus=TRS_QUIT;break;
                  case 'r': Trs_FlowStatus=TRS_RETRY;break;
                  case 'p': Trs_FlowStatus=TRS_PREVIOUS;break;
                  case 'e': Trs_FlowStatus=TRS_EXIT;break;
                  case 't': Trs_FlowStatus=TRS_TOP;break;
                  default : return RETRY;
                };break;
      case HELP_PREFIX:
                  trsPrintHelp(Trs_CurrentTest,buf[1],dstname,def,help);return RETRY;
      default: return TRUE;
    }
    return FALSE;
  }
}

TRSAPI(int, trs_bRead,(void *dst,char *name,int n,char *def,char *help,
               TRSfvr_t dsttype)) {
  char   buf[INPBUF_LEN];
  int    i,res=0;

  if ((n<=0) || (!dst)) return FALSE;

  for (i=0;i<n;i++) {
    sprintf(buf,"&%s[%d]",name,i);
    switch (dsttype) {
      case l_fvr: res=trs_Read( &((long  *)dst)[i],buf,0,def,help,dsttype); break;
      case w_fvr: res=trs_Read( &((short *)dst)[i],buf,0,def,help,dsttype); break;
      case i_fvr: res=trs_Read( &((int   *)dst)[i],buf,0,def,help,dsttype); break;
      case s_fvr: res=trs_Read( &((float *)dst)[i],buf,0,def,help,dsttype); break;
      case d_fvr: res=trs_Read( &((double*)dst)[i],buf,0,def,help,dsttype); break;
    };
    if (!res) return res;
  };
  return res;
}

/* ==========================================================================*/
TRSAPI(int, trsPause,(char *def,char *help)) {

  char                   buf[INPBUF_LEN];
  int                    ires,res;

  for(;;) {
    res=CmdWithoutPrefix(buf,"","Pause",help,def,help);
    switch (res) {
      case RETRY : continue;
      case FALSE : if (Trs_ReadSource==TRS_Default) return TRUE;
                   return FALSE;
      case TRUE  : ires=ParseInput(NULL,"",buf,i_fvr,NULL,help,0);
                   if (ires==FALSE) return FALSE;
                   Trs_FlowStatus=TRS_CONTINUE;
                   return TRUE;
    };
  };
}

/* ========================================================================== */

TRSAPI(int, _trslRead,(long *dst,char *name,char *def,char *help)) {
  return trs_Read(dst,name,NULL,def,help,l_fvr);
}

TRSAPI(int, _trswRead,(short *dst,char *name,char *def,char *help)) {
  return trs_Read(dst,name,NULL,def,help,w_fvr);
}
TRSAPI(int, _trsiRead,(int *dst,char *name,char *def,char *help)) {
  return trs_Read(dst,name,NULL,def,help,i_fvr);
}

TRSAPI(int, _trssRead,(float *dst,char *name,char *def,char *help)) {
  return trs_Read(dst,name,NULL,def,help,s_fvr);
}
TRSAPI(int, _trsdRead,(double *dst,char *name,char *def,char *help)) {
  return trs_Read(dst,name,NULL,def,help,d_fvr);
}
TRSAPI(int, _trstRead,(char * str,int size,char *name,char *def,char *help)){
  return trs_Read(str,name,(void *)size,def,help,text_fvr);
}
TRSAPI(int, _trsCaseRead,(int *dst, char *name, char *items,char *def,char *help)){
  return trs_Read(dst,name,items,def,help,case_fvr);
}
TRSAPI(int, _trsBitRead,(long int *dst, char *name, char *items,char *def,char *help)){
  return trs_Read(dst,name,items,def,help,bit_fvr);
}

/* --------------------------------------------------------------------------*/

TRSAPI(int, _trslbRead,(long *dst,char *name,int n,char *def,char *help)) {
  return trs_bRead(dst,name,n,def,help,l_fvr);
}


TRSAPI(int, _trswbRead,(short *dst,char *name,int n,char *def,char *help)) {
  return trs_bRead(dst,name,n,def,help,w_fvr);
}
TRSAPI(int, _trsibRead,(int *dst,char *name,int n,char *def,char *help)) {
  return trs_bRead(dst,name,n,def,help,i_fvr);
}

TRSAPI(int, _trssbRead,(float *dst,char *name,int n,char *def,char *help)) {
  return trs_bRead(dst,name,n,def,help,s_fvr);
}
TRSAPI(int, _trsdbRead,(double *dst,char *name,int n,char *def,char *help)) {
  return trs_bRead(dst,name,n,def,help,d_fvr);
}

#endif