trsread.c

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

/* ==========================================================================*/
/* MODULE: Test System, Read Command Anylyzer                                */
/*   VERSION: 1.00                                                           */
/*   DATE: 13-may-94                                                         */
/*   AUTHOR: Smirnov I.                                                      */
/*   FILE:  trsapi.c                                                         */
/*   ENVIRONMENT: ANSI C                                                     */
/* ==========================================================================*/

#include <stdlib.h>
#include <string.h>
#include <time.h>

#if !defined (TRS_BUILD)
# define TRS_BUILD
#endif

#include "trsapi.h"
/* -------------------------------------------------------------------------*/
#if defined putchar
# undef putchar
#endif

#define putchar _putchar
#define printf  _printf
#define fprintf _fprintf
#define gets    _gets

/* --- Input ----------------------------------------------------------------*/

#if defined _TRSREAD_C

#define BUFLEN            400
#define COMMONLEN         INPBUF_LEN+BUFLEN

typedef  struct _InpValueType{
  struct _InpValueType   *next;                 /* next value in a list      */
  char                   *valname;              /* value name                */
  char                   *value;                /* value in string           */
  TRSfvr_t                 valtp;                /* value type                */
  void                   *extra;                /* size or items             */
  char                   *valhelp;              /* value size                */
  void                   *val_adr;              /* value address             */
} InpValueType;

typedef struct _InpListType{
  struct _InpListType     *next;
  char                    *inputdst;
  char                    *inputsrc;
  int                      lorgflg;
} InpListType;

typedef struct _TokenListType{
  struct _TokenListType   *next;
  char                    *token;
} TokenListType;

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

  static  InpListType           *InputList=NULL;
  static  InpValueType          *ValueList=NULL;
  static  TokenListType         *TokenList=NULL;
  static  int                    SrcFromFile=0;         /* src from file             */
  static  int                    DstToFile=0;           /* dst to file               */
  static  char  *TypeName[] =
          {"float","SCplx","double","DCplx","short","WCplx","int","ICplx","long",
           "text","",""};
  static  char  *TypePrompt[] =
          {"Enter ","Enter ","Enter ","Enter ","Enter ","Enter ","Enter ","Enter ","Enter ",
           "Enter ", "Select ","Set bits of "};
/* ------------------------------------------------------------------------- */

static void DeleteValueList   (void);
static void DeleteInpListEntry(InpListType *current);
static void DeleteTokenList   (void);
static void ErrorMess         (char *msg);
static int FillDst         (char *buf,void *dst,void *extra,TRSfvr_t dt);

static int ParseInput      (void *dst,  char *tname,char *buf,TRSfvr_t dsttype,
                            void *extra,char *help,int ifl);
static int ParseTokens     (char *buf,  char *delimiter);
static int ParseTokenAssign(char *name, char *cptr,void *dst,TRSfvr_t dsttype,
                            void *extra,char *help,int ifl);

static InpListType  *ScanInpList    (char *name);
static InpValueType *ScanValueList  (char *name);
static InpValueType *AddInpValueList(char *name,char *dst,TRSfvr_t dsttype,
                              void *d_adr,void *extra,char *help);
static int AssignValue(int valfromlist,InpValueType *currentvalue,char *value,
                char *valuename,void *dst,TRSfvr_t dsttype,
                void *extra,char *help,int inpmode);

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

static void cmdAct(char *buf) {

  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 : Trs_FlowStatus=TRS_CONTINUE;
  };
}

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

static void DeleteInpList(void) {

  InpListType   *ptr;

  while (InputList) {
    ptr=InputList;
    free(ptr->inputsrc);    free(ptr->inputdst);
    InputList=ptr->next;    free(ptr);
  };
  return;
}

static void DeleteValueList(void) {

  InpValueType      *ptr;

  while (ValueList) {
    ptr=ValueList;
    free(ptr->value);    free(ptr->valname);    free(ptr->valhelp);
    if ((ptr->valtp==case_fvr)||(ptr->valtp==bit_fvr)) free(ptr->extra);
    ValueList=ptr->next;
    free(ptr);
  };
  return;
}

TRSAPI(int, trs_arInit,(void)) {

  const char  *chptr;
  char         buf[INPBUF_LEN];


  chptr=trsGetKeyArg('D');
  if ((chptr==NULL) || (*chptr==0)) return TRUE;
  strcpy(buf,chptr);
  if(!ParseInput(NULL,"",buf,i_fvr,NULL,"",1)) return FALSE;
  return TRUE;
}

TRSAPI(void, trs_arTerminate,(void)) {

  DeleteValueList();
  DeleteInpList();
  DstToFile=FALSE;
  SrcFromFile=FALSE;
  return;
}

/* Find value entry with valuename                                           */

static InpValueType *ScanValueList(char *name){

  static InpValueType      *ptr=NULL;

  ptr=ValueList;
  while (ptr) {
    if (!strcmp(ptr->valname,name)) break;
    ptr=ptr->next;
  };
  return ptr;
}

/* Find input entry with inputdstname, if global and local take local        */

static InpListType *ScanInpList(char *name) {

  static InpListType     *ptr=NULL;
         InpListType     *keyinputvalue;

  ptr=InputList;
  while (ptr) {                                 /*scan InputList             */
    if (!strcmp(ptr->inputdst,name)) break;
    ptr=ptr->next;
  };
  if (!ptr) return ptr;                        /* no such entry              */
  if (!ptr->lorgflg) return ptr;               /* entry not global -  o'key  */
  keyinputvalue=ptr;                           /* if global - save ptr       */
  ptr=ptr->next;                               /* take next entry            */
  while (ptr) {                                /* scan for local entry       */
    if (!strcmp(ptr->inputdst,name)) break;    /* if local - return it ptr   */
    ptr=ptr->next;                             /* get next entry             */
  };
  if(!ptr)ptr=keyinputvalue;                   /* no local - get global ptr  */
  return ptr;
}

/* Delete local input entry with pointer                                     */

static void DeleteInpListEntry(InpListType *current){

  InpListType     *ptr,*prev;

  if((current==NULL) || (InputList==NULL)) return;
  ptr=InputList;prev=ptr;
  while (ptr!=current) {                       /* find entry                 */
    prev=ptr;                                  /* get previos                */
    ptr=ptr->next;
    if (!ptr) return;
  };
  if (ptr->lorgflg) return;                    /* if global - do nothing     */
  prev->next=ptr->next;                        /* if local - put next to prev*/
  if (ptr==InputList) InputList=ptr->next;
  free(ptr->inputsrc);                         /* delete entry               */
  free(ptr->inputdst);
  free(ptr);
  return;
}

static void AddInputListEntry(char *dst,char *src,int inplstflg) {

  InpListType     *iptr,*prev;

  iptr=ScanInpList(dst);
  if( (!iptr) || ((iptr!=NULL) && (iptr->lorgflg==1)) ) {
    iptr=(InpListType*)trsmAlloc(sizeof(InpListType));
    iptr->inputdst=StringDup(dst);
    iptr->inputsrc=StringDup(src);
    iptr->next=NULL;
    iptr->lorgflg=inplstflg;
    if (InputList==NULL)  InputList=iptr;
    else {
      prev=InputList;
      while ((prev->next) !=NULL)prev=prev->next;
      prev->next=iptr;
    };
  } else {
    iptr->inputdst=reStringDup(iptr->inputdst,dst);
    iptr->inputsrc=reStringDup(iptr->inputsrc,src);
    iptr->lorgflg =inplstflg;
  };
}

static InpValueType *AddInpValueList(char *name,char *dst,TRSfvr_t dsttype,
                              void *d_adr, void *extra,char *help) {
  static InpValueType  *ptr;
         InpValueType  *pp;

  ptr=ScanValueList(name);
  if(!ptr) {
    ptr=(InpValueType*)trsmAlloc(sizeof(InpValueType));
    if (ptr==NULL) return ptr;

    ptr->valname = StringDup(name);
    ptr->valhelp = StringDup(help);

    ptr->valtp    = dsttype;
    ptr->val_adr  = d_adr;
    ptr->value   = StringDup(dst);

    switch (dsttype) {
      case text_fvr: ptr->extra=extra;          break;
      case case_fvr:
      case bit_fvr: ptr->extra=(void*)StringDup((char*)extra);  break;
      default:    ptr->extra=NULL;           break;
    };
    ptr->next     = NULL;
    if (ValueList==NULL)
      ValueList=ptr;
    else {
      pp=ValueList;
      while ((pp->next) !=NULL)   pp=pp->next;
      pp->next=ptr;
    };
  } else {


    ptr->valname = reStringDup(ptr->valname,name);
    ptr->valhelp = reStringDup(ptr->valhelp,help);

    ptr->valtp    = dsttype;
    ptr->val_adr  = d_adr;
    ptr->value    = reStringDup(ptr->value,dst);

    switch (dsttype) {
      case text_fvr: ptr->extra=extra;                       break;
      case case_fvr:
      case bit_fvr: ptr->extra=reStringDup((char*)ptr->extra,(char*)extra);  break;
      default:    ptr->extra=NULL;                        break;
    };
  };
  return ptr;
}

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

static int FillDst(char *buf,void *dst,void *extra,TRSfvr_t dt) {

  int           res=0,bitno;
  long          i;
  float         re;
  double        dre;
  char          sep[2]=" ";
  long int      bitset=0;
  char          buftail[INPBUF_LEN],bufhead[INPBUF_LEN];
  char          head[INPBUF_LEN],tail[INPBUF_LEN];

  switch (dt) {
     case w_fvr: res=sscanf(buf,"%ld",&i);
                if (res>=1) {
                  *((short *) dst)=(short)i;
                  return TRUE;
                }
                break;
    case i_fvr: res=sscanf(buf,"%ld",&i);
                if (res>=1) {
                  *((int *) dst)=(int)i;
                  return TRUE;
                }
                break;
     case l_fvr: res=sscanf(buf,"%ld",&i);
/*    case l_fvr: res=sscanf(buf,"%lu",&l);*/
                if (res>=1) {
                  *((long *) dst)=i;
                  return TRUE;
                }
                break;
    case s_fvr: res=sscanf(buf,"%f",&re);
                if (res>=1) {
                  *((float *) dst)=re;
                  return TRUE;
                };
                break;
    case d_fvr: res=sscanf(buf,"%lf",&dre);
                if (res>=1) {
                  *((double *) dst)=dre;
                  return TRUE;
                };
                break;
    case text_fvr: StringnCpy((char *) dst,buf,(int )extra);
                return TRUE;
    case case_fvr: sep[0]=*(char *)extra;
                StrParse2((char*)extra,(char*)sep,(char*)head,(char*)tail);
                for (res=0;tail[0]!=0;res=res+1) {
                  StrParse2(tail,sep,head,tail);
                  if (!strcmp(buf,head)) {
                      *((int *) dst)=res;
                      return TRUE;
                  };
                };
                break;
    case bit_fvr: strcpy(buftail,buf);
                sep[0]=*(char *)extra;
                for (;buftail[0]!=0;) {
                  StrParse2(buftail,sep,bufhead,buftail);
                  if ((!buftail[0]) && (!bufhead[0])) {
                    res=TRUE; continue;
                  };
                  StrParse2((char*)extra,(char*)sep,(char*)head,(char*)tail);
                  res=FALSE;
                  for (bitno=0;tail[0]!=0;bitno=bitno+1) {
                    StrParse2(tail,sep,head,tail);
                    if (!strcmp(bufhead,head)) {
                      bitset=bitset | (1L<<bitno);
                      res=TRUE;break;
                    };
                  };
                  if (res) continue;
                  break;
                };
                if (res) {
                  *((long int *) dst)=bitset;
                  return TRUE;
                };
                break;
  };
  return FALSE;
}

/* ==========================================================================*/
static int ParseTokens( char *buf, char *delimiter) {

  TokenListType         *pcurtoken,*pprevtoken=NULL;
  char                  headbuf[256],tailbuf[256];
  int                   i=1;

  strcpy(tailbuf,buf);
  while (i!=0) {
    i=StrParse2(tailbuf,delimiter,headbuf,tailbuf);
    pcurtoken        = (TokenListType*)trsmAlloc(sizeof(TokenListType));
    pcurtoken->token = StringDup(headbuf);
    if (!pcurtoken->token) return FALSE;
    pcurtoken->next  = NULL;
    if (TokenList==NULL)
      TokenList=pcurtoken;
    else
      pprevtoken->next=pcurtoken;
    pprevtoken=pcurtoken;
  };
  return TRUE;
}

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

static void DeleteTokenList(void) {

  TokenListType      *ptr;

  while (TokenList) {
    ptr=TokenList;
    free(ptr->token);
    TokenList=ptr->next;
    free(ptr);
  };
  return;
}

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

static void ErrorMess(char *msg) {
  printf("?-f-TRS-%s",msg);
  DeleteTokenList();
}
static void Warning(char *str) {
  printf("?-w-TRS-%s\n",str);
}
/* ==========================================================================*/

/* --- token assignment ---------------------------------------------------- */

static   InpValueType  *CurrentEntryPtr=NULL;

static int AssignValue(int valfromlist,InpValueType *currentvalue,char *value,
                char *valuename,void *dst,TRSfvr_t dsttype,
                void *extra,char *help,int inpmode) {

  InpValueType  *ptr;
  int            res;