typesets.c

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

	return;
    }
    EiC_exchtype(t_int,e1->Type);
    u1.ival = n;
    EiC_generate(&e1->Code, inst, &u1, 0);
}

static void checkint(unsigned obj, token_t * e1, token_t * e2)
{
    if (EiC_gettype(e1->Type) != obj) {
	if(!isconst(e1->Type))
	    EiC_exchtype(obj, e1->Type);
	else
	    EiC_castconst(e1,e2,0);
    }
    if (EiC_gettype(e2->Type) != obj) {
	if(!isconst(e1->Type))
	    EiC_exchtype(obj, e2->Type);
	else
	    EiC_castconst(e2, e1, 0);
    }
    if (!e2->Pflag)
	EiC_output(e2);
}


void binhint(unsigned oper, token_t * e1, token_t * e2)
{
    checkint(t_int, e1, e2);
    switch (oper) {
      case '+':
	EiC_generate(&e2->Code, addint, &e2->Val, 0);
	break;
      case '-':
	EiC_generate(&e2->Code, subint, &e2->Val, 0);
	break;
      case '*':
	EiC_generate(&e2->Code, multint, &e2->Val, 0);
	break;
      case '/':
	EiC_generate(&e2->Code, divint, &e2->Val, 0);
	break;
      case '%':
	EiC_generate(&e2->Code, modint, &e2->Val, 0);
	break;
      case LSHT:
	EiC_generate(&e2->Code, lshtint, &e2->Val, 0);
	break;
      case RSHT:
	EiC_generate(&e2->Code, rshtint, &e2->Val, 0);
	break;
      case LT:
	EiC_generate(&e2->Code, ltint, &e2->Val, 0);
	break;
      case LE:
	EiC_generate(&e2->Code, leint, &e2->Val, 0);
	break;
      case EQ:
	EiC_generate(&e2->Code, eqint, &e2->Val, 0);
	break;
      case NE:
	EiC_generate(&e2->Code, neint, &e2->Val, 0);
	break;
      case GT:
	EiC_generate(&e2->Code, gtint, &e2->Val, 0);
	break;
      case GE:
	EiC_generate(&e2->Code, geint, &e2->Val, 0);
	break;
      case BOR:
	EiC_generate(&e2->Code, borint, &e2->Val, 0);
	break;
      case XOR:
	EiC_generate(&e2->Code, xorint, &e2->Val, 0);
	break;
      case AND:
	EiC_generate(&e2->Code, andint, &e2->Val, 0);
	break;
    }
}

void binhuint(unsigned oper, token_t * e1, token_t * e2)
{
    checkint(t_uint, e1, e2);
    switch (oper) {
      case '+':
	EiC_generate(&e2->Code, adduint, &e2->Val, 0);
	break;
      case '-':
	EiC_generate(&e2->Code, subuint, &e2->Val, 0);
	break;
      case '*':
	EiC_generate(&e2->Code, multuint, &e2->Val, 0);
	break;
      case '/':
	EiC_generate(&e2->Code, divuint, &e2->Val, 0);
	break;
      case '%':
	EiC_generate(&e2->Code, moduint, &e2->Val, 0);
	break;
      case LSHT:
	EiC_generate(&e2->Code, lshtuint, &e2->Val, 0);
	break;
      case RSHT:
	EiC_generate(&e2->Code, rshtuint, &e2->Val, 0);
	break;
      case BOR:
	EiC_generate(&e2->Code, boruint, &e2->Val, 0);
	break;
      case XOR:
	EiC_generate(&e2->Code, xoruint, &e2->Val, 0);
	break;
      case AND:
	EiC_generate(&e2->Code, anduint, &e2->Val, 0);
	break;
      default:
	EiC_output(e1);
	EiC_exchtype(t_int, e1->Type);	/* should really be boolean */
	switch (oper) {
	  case LT:
	    EiC_generate(&e2->Code, ltuint, &e2->Val, 0);
	    break;
	  case LE:
	    EiC_generate(&e2->Code, leuint, &e2->Val, 0);
	    break;
	  case EQ:
	    EiC_generate(&e2->Code, equint, &e2->Val, 0);
	    break;
	  case NE:
	    EiC_generate(&e2->Code, neuint, &e2->Val, 0);
	    break;
	  case GT:
	    EiC_generate(&e2->Code, gtuint, &e2->Val, 0);
	    break;
	  case GE:
	    EiC_generate(&e2->Code, geuint, &e2->Val, 0);
	    break;
	}
    }
}

static void checklong(unsigned obj, token_t * e1, token_t * e2)
{
    int t;
    if ((t=EiC_gettype(e1->Type)) != obj) {
	if (!isconst(e1->Type)) {
	    if (!e1->Pflag)
		EiC_output(e1);
	    if(sizeof(int) != sizeof(long))
		switch (t) {
		CASE_INT:EiC_generate(&e1->Code, int2long, &e1->Val, 0);
		break;
		CASE_UINT:EiC_generate(&e1->Code, uint2long, &e1->Val, 0);
		break;
		}
	    EiC_exchtype(obj, e1->Type);
	} else 
	    EiC_castconst(e1, e2, 0);
    }
    if ((t=EiC_gettype(e2->Type)) != obj) {
	if (!isconst(e2->Type)) {
	    if (!e2->Pflag)
		EiC_output(e2);
	    if(sizeof(int) != sizeof(long))
		switch (t) {
		CASE_INT:EiC_generate(&e2->Code, int2long, &e1->Val, 0);
		break;
		CASE_UINT:EiC_generate(&e2->Code, uint2long, &e1->Val, 0);
		break;
		}
	    EiC_exchtype(obj, e2->Type);
	} else 
	    EiC_castconst(e2, e1, 0);
    }
    if (!e2->Pflag)
	EiC_output(e2);
}

void binhlong(unsigned oper, token_t * e1, token_t * e2)
{
    checklong(t_long, e1, e2);
    
    switch (oper) {
      case '+':
	EiC_generate(&e2->Code, addlong, &e2->Val, 0);
	break;
      case '-':
	EiC_generate(&e2->Code, sublong, &e2->Val, 0);
	break;
      case '*':
	EiC_generate(&e2->Code, multlong, &e2->Val, 0);
	break;
      case '/':
	EiC_generate(&e2->Code, divlong, &e2->Val, 0);
	break;
      case '%':
	EiC_generate(&e2->Code, modlong, &e2->Val, 0);
	break;
      case LSHT:
	EiC_generate(&e2->Code, lshtlong, &e2->Val, 0);
	break;
      case RSHT:
	EiC_generate(&e2->Code, rshtlong, &e2->Val, 0);
	break;
      case BOR:
	EiC_generate(&e2->Code, borlong, &e2->Val, 0);
	break;
      case XOR:
	EiC_generate(&e2->Code, xorlong, &e2->Val, 0);
	break;
      case AND:
	EiC_generate(&e2->Code, andlong, &e2->Val, 0);
	break;
      default:
	EiC_output(e1);
	EiC_exchtype(t_int, e1->Type);	/* should really be boolean */
	switch (oper) {
	  case LT:
	    EiC_generate(&e2->Code, ltlong, &e2->Val, 0);
	    break;
	  case LE:
	    EiC_generate(&e2->Code, lelong, &e2->Val, 0);
	    break;
	  case EQ:
	    EiC_generate(&e2->Code, eqlong, &e2->Val, 0);
	    break;
	  case NE:
	    EiC_generate(&e2->Code, nelong, &e2->Val, 0);
	    break;
	  case GT:
	    EiC_generate(&e2->Code, gtlong, &e2->Val, 0);
	    break;
	  case GE:
	    EiC_generate(&e2->Code, gelong, &e2->Val, 0);
	    break;
	}
	break;
    }
}

void binhulong(unsigned oper, token_t * e1, token_t * e2)
{
    checklong(t_ulong, e1, e2);
    switch (oper) {
      case '+':
	EiC_generate(&e2->Code, addulong, &e2->Val, 0);
	break;
      case '-':
	EiC_generate(&e2->Code, subulong, &e2->Val, 0);
	break;
      case '*':
	EiC_generate(&e2->Code, multulong, &e2->Val, 0);
	break;
      case '/':
	EiC_generate(&e2->Code, divulong, &e2->Val, 0);
	break;
      case '%':
	EiC_generate(&e2->Code, modulong, &e2->Val, 0);
	break;
      case LSHT:
	EiC_generate(&e2->Code, lshtulong, &e2->Val, 0);
	break;
      case RSHT:
	EiC_generate(&e2->Code, rshtulong, &e2->Val, 0);
	break;
      case BOR:
	EiC_generate(&e2->Code, borulong, &e2->Val, 0);
	break;
      case XOR:
	EiC_generate(&e2->Code, xorulong, &e2->Val, 0);
	break;
      case AND:
	EiC_generate(&e2->Code, andulong, &e2->Val, 0);
	break;
      default:
	EiC_output(e1);
	EiC_exchtype(t_int, e1->Type);	/* should really be boolean */
	switch (oper) {
	  case LT:
	    EiC_generate(&e2->Code, ltulong, &e2->Val, 0);
	    break;
	  case LE:
	    EiC_generate(&e2->Code, leulong, &e2->Val, 0);
	    break;
	  case EQ:
	    EiC_generate(&e2->Code, equlong, &e2->Val, 0);
	    break;
	  case NE:
	    EiC_generate(&e2->Code, neulong, &e2->Val, 0);
	    break;
	  case GT:
	    EiC_generate(&e2->Code, gtulong, &e2->Val, 0);
	    break;
	  case GE:
	    EiC_generate(&e2->Code, geulong, &e2->Val, 0);
	    break;
	}
	break;
    }
}

static void checkllong(unsigned obj, token_t * e1, token_t * e2)
{
  int t;
  if ((t=EiC_gettype(e1->Type)) != obj) {
    if (!isconst(e1->Type)) {
      if (!e1->Pflag)
	EiC_output(e1);
      if(t <= t_uint && sizeof(int) != sizeof(eic_llong)) {
	switch (t) {
	CASE_INT:EiC_generate(&e1->Code, int2llong, &e1->Val, 0);
	break;
	CASE_UINT:EiC_generate(&e1->Code, uint2llong, &e1->Val, 0);
	}
      } else if(sizeof(long) != sizeof(eic_llong)) {
	switch (t) {
	case t_long:EiC_generate(&e1->Code, long2llong, &e1->Val, 0);
	  break;
	case t_ulong:EiC_generate(&e1->Code, ulong2llong, &e1->Val, 0);
	}
      }
      EiC_exchtype(obj, e1->Type);
    } else 
      EiC_castconst(e1, e2, 0);
  }
  if ((t=EiC_gettype(e2->Type)) != obj) {
    if (!isconst(e2->Type)) {
      if (!e2->Pflag)
	EiC_output(e2);
      if(t <= t_uint && sizeof(int) != sizeof(eic_llong)) {
	switch (t) {
	CASE_INT:EiC_generate(&e2->Code, int2llong, &e1->Val, 0);
	break;
	CASE_UINT:EiC_generate(&e2->Code, uint2llong, &e1->Val, 0);
	}
      } else if(sizeof(long) != sizeof(eic_llong)) {
	switch (t) {
	case t_long:EiC_generate(&e2->Code, long2llong, &e1->Val, 0);
	  break;
	case t_ulong:EiC_generate(&e2->Code, ulong2llong, &e1->Val, 0);
	}
      }
      EiC_exchtype(obj, e2->Type);
    } else 
      EiC_castconst(e2, e1, 0);
  }
  if (!e2->Pflag)
    EiC_output(e2);
}


void binhllong(unsigned oper, token_t * e1, token_t * e2)
{
    checkllong(t_llong, e1, e2);
    
    switch (oper) {
      case '+':
	EiC_generate(&e2->Code, addllong, &e2->Val, 0);
	break;
      case '-':
	EiC_generate(&e2->Code, subllong, &e2->Val, 0);
	break;
      case '*':
	EiC_generate(&e2->Code, multllong, &e2->Val, 0);
	break;
      case '/':
	EiC_generate(&e2->Code, divllong, &e2->Val, 0);
	break;
      case '%':
	EiC_generate(&e2->Code, modllong, &e2->Val, 0);
	break;
      case LSHT:
	EiC_generate(&e2->Code, lshtllong, &e2->Val, 0);
	break;
      case RSHT:
	EiC_generate(&e2->Code, rshtllong, &e2->Val, 0);
	break;
      case BOR:
	EiC_generate(&e2->Code, borllong, &e2->Val, 0);
	break;
      case XOR:
	EiC_generate(&e2->Code, xorllong, &e2->Val, 0);
	break;
      case AND:
	EiC_generate(&e2->Code, andllong, &e2->Val, 0);
	break;
      default:
	EiC_output(e1);
	EiC_exchtype(t_int, e1->Type);	/* should really be boolean */
	switch (oper) {
	  case LT:
	    EiC_generate(&e2->Code, ltllong, &e2->Val, 0);
	    break;
	  case LE:
	    EiC_generate(&e2->Code, lellong, &e2->Val, 0);
	    break;
	  case EQ:
	    EiC_generate(&e2->Code, eqllong, &e2->Val, 0);
	    break;
	  case NE:
	    EiC_generate(&e2->Code, nellong, &e2->Val, 0);
	    break;
	  case GT:
	    EiC_generate(&e2->Code, gtllong, &e2->Val, 0);
	    break;
	  case GE:
	    EiC_generate(&e2->Code, gellong, &e2->Val, 0);
	    break;
	}
	break;
    }
}



void binhdouble(unsigned oper, token_t * e1, token_t * e2)
{
    int t;
    if ((t=EiC_gettype(e1->Type)) != t_double) {
	if (!isconst(e1->Type)) {
	    if (!e1->Pflag)
		EiC_output(e1);
	    switch (t) {
	      CASE_INT:EiC_generate(&e1->Code, int2double, &e1->Val, 0);
		break;
	      CASE_UINT:EiC_generate(&e1->Code, uint2double, &e1->Val, 0);
		break;
	      CASE_LONG:EiC_generate(&e1->Code, long2double, &e1->Val, 0);
		break;
	      CASE_ULONG:EiC_generate(&e1->Code, ulong2double, &e1->Val, 0);
		break;
	    case t_llong: EiC_generate(&e1->Code, llong2double, &e1->Val, 0);
		break;
	    }
	    EiC_exchtype(t_double, e1->Type);
	} else 
	    EiC_castconst(e1, e2, 0);
    }
    if ((t=EiC_gettype(e2->Type)) != t_double) {
	if (!isconst(e2->Type)) {
	    if (!e2->Pflag)
		EiC_output(e2);
	    switch (t) {
	      CASE_INT:EiC_generate(&e2->Code, int2double, &e1->Val, 0);
		break;
	      CASE_UINT:EiC_generate(&e2->Code, uint2double, &e1->Val, 0);
		break;
	      CASE_LONG:EiC_generate(&e2->Code, long2double, &e1->Val, 0);
		break;
	      CASE_ULONG:EiC_generate(&e2->Code, ulong2double, &e1->Val, 0);
		break;
	      case t_llong:EiC_generate(&e2->Code, llong2double, &e1->Val, 0);
		break;
	    }
	    EiC_exchtype(t_double, e2->Type);
	} else
	    EiC_castconst(e2, e1, 0);
    }
    if (!e2->Pflag)
	EiC_output(e2);
    
    switch (oper) {
      case '+':
	EiC_generate(&e2->Code, adddouble, &e2->Val, 0);
	break;
      case '-':
	EiC_generate(&e2->Code, subdouble, &e2->Val, 0);
	break;
      case '*':
	EiC_generate(&e2->Code, multdouble, &e2->Val, 0);
	break;
      case '/':
	EiC_generate(&e2->Code, divdouble, &e2->Val, 0);
	break;
      default:
	EiC_output(e1);
	EiC_exchtype(t_int, e1->Type);	/* should really be boolean */
	switch (oper) {
	  case LT:
	    EiC_generate(&e2->Code, ltdouble, &e2->Val, 0);
	    break;
	  case LE:
	    EiC_generate(&e2->Code, ledouble, &e2->Val, 0);
	    break;
	  case EQ:
	    EiC_generate(&e2->Code, eqdouble, &e2->Val, 0);
	    break;
	  case NE:
	    EiC_generate(&e2->Code, nedouble, &e2->Val, 0);
	    break;
	  case GT:
	    EiC_generate(&e2->Code, gtdouble, &e2->Val, 0);
	    break;
	  case GE:
	    EiC_generate(&e2->Code, gedouble, &e2->Val, 0);
	    break;
	  default:EiC_error("illegal binary operation to `%c'", oper);
	}
    }
}

#define arrayLimit(type)    /* replaced by runtime checks */

/*if(limit && (e2->Val.type >= limit || \
				      e2->Val.type < 0))\
                               EiC_error("Array bound violation");
			       */
#define ConstPval(y) { if(oper == '+')\
			    e1->Val.p.p = (char*)e1->Val.p.p + e2->Val.y;\
			else\
			    e1->Val.p.p = (char*)e1->Val.p.p - e2->Val.y;\
		    }

void EiC_binhlval(unsigned oper, token_t * e1, token_t * e2)
{
    unsigned limit = 0;
    if (EiC_gettype(e1->Type) != t_pointer) {
	if(EiC_gettype(e1->Type) != t_array) {
	    EiC_binhlval(oper,e2,e1);
	    EiC_swaptokens(e1,e2);
	    return;
	} else { /* convert array to pointer */
	    limit = getNumElems(e1->Type);
	    EiC_output(e1);
	}
    }
    if(EiC_gettype(e2->Type) == t_array)
	EiC_output(e2);
       
    if (EiC_gettype(e2->Type) != t_pointer) {
	if(oper == '+' || oper == '-') {
	    int c = 0;
	    VAL.ival = EiC_get_sizeof(nextType(e1->Type));
	    if(!VAL.ival)
		EiC_error("Illegal pointer operation");
	    if(isconst(e1->Type) && isconst(e2->Type))
		c = 1;
	    if(isconst(e2->Type)) {
		switch (EiC_gettype(e2->Type)) {
		  CASE_INT:
		    arrayLimit(ival);
		    e2->Val.ival *= VAL.ival;
		    if(c)
			ConstPval(ival);
		    break;
		  CASE_UINT:
		    arrayLimit(uival);
		    e2->Val.uival *= VAL.ival;
		    if(c)
			ConstPval(uival);
		    break;
		  CASE_LONG:
		    arrayLimit(lval);
		    e2->Val.lval *= VAL.ival;
		    if(c)
			ConstPval(lval);
		    break;
		  CASE_ULONG:
		    arrayLimit(ulval);
		    e2->Val.ulval *= VAL.ival;
		    if(c)
			ConstPval(ulval);
		    break;
		  default:
		    EiC_error("Illegal pointer operation");
		}
		VAL.ival = 1; 
	    }
	    if(!c) {
		if(oper == '-')
		    VAL.ival = -VAL.ival;
		EiC_output(e2);
		if(EiC_gettype(e2->Type) > t_uint && sizeof(int) != sizeof(long)) {
		    token_t e3;
		    EiC_inittoken(&e3);
		    e3.Type = EiC_addtype(t_int,NULL);
		    EiC_castvar(e2,&e3,0);
		    EiC_freetype(e3.Type);
		}
		if(VAL.ival > 1 || VAL.ival < 0)
		    EiC_generate(&e2->Code, ixa, &VAL, limit);
		else
		    EiC_generate(&e2->Code, addptr2int, &e2->Val, 0);
	    }
	    return;
	}