自学教程：C++ ADD函数代码示例

voidImagingAccessInit(){#define ADD(mode_, line_, get_pixel_, put_pixel_)       /    { ImagingAccess access = add_item(mode_);           /        access->line = line_;                           /        access->get_pixel = get_pixel_;                 /        access->put_pixel = put_pixel_;                 /    }    /* populate access table */    ADD("1", line_8, get_pixel_8, put_pixel_8);    ADD("L", line_8, get_pixel_8, put_pixel_8);    ADD("LA", line_32, get_pixel, put_pixel);    ADD("I", line_32, get_pixel_32, put_pixel_32);    ADD("I;16", line_16, get_pixel_16L, put_pixel_16L);    ADD("I;16L", line_16, get_pixel_16L, put_pixel_16L);    ADD("I;16B", line_16, get_pixel_16B, put_pixel_16B);    ADD("I;32L", line_32, get_pixel_32L, put_pixel_32L);    ADD("I;32B", line_32, get_pixel_32B, put_pixel_32B);    ADD("F", line_32, get_pixel_32, put_pixel_32);    ADD("P", line_8, get_pixel_8, put_pixel_8);    ADD("PA", line_32, get_pixel, put_pixel);    ADD("RGB", line_32, get_pixel_32, put_pixel_32);    ADD("RGBA", line_32, get_pixel_32, put_pixel_32);    ADD("RGBa", line_32, get_pixel_32, put_pixel_32);    ADD("RGBX", line_32, get_pixel_32, put_pixel_32);    ADD("CMYK", line_32, get_pixel_32, put_pixel_32);    ADD("YCbCr", line_32, get_pixel_32, put_pixel_32);}

int main(int argc, char *argv[]) {    /*=========== commandline parsing ===========*/    int c, i;    char *name = argv[0];    static struct option long_options[] = {         {"help", no_argument, NULL, 'h'}    };    int option_index = 0;    while ((c = getopt_long(argc, argv, "h", long_options, &option_index)) != -1) {        switch (c) {            case 'h':                help(name);                return EXIT_SUCCESS;            case '?':                usage(name);                return EXIT_FAILURE;            default:                fprintf(stderr, "Illegal option %c./n", c);                usage(name);                return EXIT_FAILURE;        }    }        if(argc - optind < 2){        usage(name);        return EXIT_FAILURE;    }        bitset tuple = EMPTY_SET;        for(i = optind; i < argc; i++){        int t1, t2, t3;        if(sscanf(argv[i], "%d,%d,%d", &t1, &t2, &t3)!=3){            fprintf(stderr, "Error while reading triangle %d./n", i - optind + 1);            usage(name);            return EXIT_FAILURE;        }        bitset triangle = EMPTY_SET;        ADD(triangle, t1-1);        ADD(triangle, t2-1);        ADD(triangle, t3-1);        int j=0;        while(j < nf && CONTAINS_ALL(faceSets[j], triangle)){            j++;        }        if(j == nf){            fprintf(stderr, "The triangle %d,%d,%d does not exist -- exiting!/n", t1, t2, t3);            return EXIT_FAILURE;        } else {            ADD(tuple, j);        }    }    /*=========== read planar graphs ===========*/    unsigned short code[MAXCODELENGTH];    int length;    if (readPlanarCode(code, &length, stdin)) {        decodePlanarCode(code);    } else {        fprintf(stderr, "Error while reading triangulation -- exiting!/n");        return EXIT_FAILURE;    }        if(findEOPD(tuple)){        fprintf(stderr, "There is an extended outer planar disc./n");    } else {        fprintf(stderr, "There is no extended outer planar disc./n");    }        return EXIT_SUCCESS;}

intarch_pdp11_translate_instr(cpu_t *cpu, addr_t pc, BasicBlock *bb) {	uint16_t opcode = cpu->RAM[pc];//LOG("%s:%d PC=$%04X/n", __func__, __LINE__, pc);	switch (get_instr(opcode)) {		/* flags */		case INSTR_CLC:	LET1(cpu->ptr_C, FALSE);				break;		case INSTR_CLD:	LET1(ptr_D, FALSE);				break;		case INSTR_CLI:	LET1(ptr_I, FALSE);				break;		case INSTR_CLV:	LET1(cpu->ptr_V, FALSE);				break;		case INSTR_SEC:	LET1(cpu->ptr_C, TRUE);				break;		case INSTR_SED:	LET1(ptr_D, TRUE);				break;		case INSTR_SEI:	LET1(ptr_I, TRUE);				break;		/* register transfer */		case INSTR_TAX:	SET_NZ(LET(X,R(A)));			break;		case INSTR_TAY:	SET_NZ(LET(Y,R(A)));			break;		case INSTR_TXA:	SET_NZ(LET(A,R(X)));			break;		case INSTR_TYA:	SET_NZ(LET(A,R(Y)));			break;		case INSTR_TSX:	SET_NZ(LET(X,R(S)));			break;		case INSTR_TXS:	SET_NZ(LET(S,R(X)));			break;		/* load */		case INSTR_LDA:	SET_NZ(LET(A,OPERAND));			break;		case INSTR_LDX:	SET_NZ(LET(X,OPERAND));			break;		case INSTR_LDY:	SET_NZ(LET(Y,OPERAND));			break;		/* store */		case INSTR_STA:	STORE(R(A),LOPERAND);			break;		case INSTR_STX:	STORE(R(X),LOPERAND);			break;		case INSTR_STY:	STORE(R(Y),LOPERAND);			break;		/* stack */		case INSTR_PHA:	PUSH(R(A));						break;		case INSTR_PHP:	PUSH(arch_flags_encode(cpu, bb));	break;		case INSTR_PLA:	SET_NZ(LET(A,PULL));			break;		case INSTR_PLP:	arch_flags_decode(cpu, PULL, bb);	break;		/* shift */		case INSTR_ASL:	SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, true, false));	break;		case INSTR_LSR:	SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, false, false));	break;		case INSTR_ROL:	SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, true, true));	break;		case INSTR_ROR:	SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, false, true));	break;		/* bit logic */		case INSTR_AND:	SET_NZ(LET(A,AND(R(A),OPERAND)));			break;		case INSTR_ORA:	SET_NZ(LET(A,OR(R(A),OPERAND)));			break;		case INSTR_EOR:	SET_NZ(LET(A,XOR(R(A),OPERAND)));			break;		case INSTR_BIT:	SET_NZ(OPERAND);							break;		/* arithmetic */		case INSTR_ADC:	SET_NZ(ADC(ptr_A, ptr_A, OPERAND, true, false));		break;		case INSTR_SBC:	SET_NZ(ADC(ptr_A, ptr_A, COM(OPERAND), true, false));	break;		case INSTR_CMP:	SET_NZ(ADC(NULL, ptr_A, COM(OPERAND), false, true));		break;		case INSTR_CPX:	SET_NZ(ADC(NULL, ptr_X, COM(OPERAND), false, true));		break;		case INSTR_CPY:	SET_NZ(ADC(NULL, ptr_Y, COM(OPERAND), false, true));		break;		/* increment/decrement */		case INSTR_INX:	SET_NZ(LET(X,INC(R(X))));			break;		case INSTR_INY:	SET_NZ(LET(Y,INC(R(Y))));			break;		case INSTR_DEX:	SET_NZ(LET(X,DEC(R(X))));			break;		case INSTR_DEY:	SET_NZ(LET(Y,DEC(R(Y))));			break;		case INSTR_INC:	SET_NZ(STORE(INC(OPERAND),LOPERAND));			break;		case INSTR_DEC:	SET_NZ(STORE(DEC(OPERAND),LOPERAND));			break;				/* control flow */		case INSTR_JMP:			if (get_addmode(opcode) == ADDMODE_IND) {				Value *v = LOAD_RAM16(CONST32(OPERAND_16));				new StoreInst(v, cpu->ptr_PC, bb);			}			break;		case INSTR_JSR:	PUSH16(pc+2);						break;		case INSTR_RTS:	STORE(ADD(PULL16, CONST16(1)), cpu->ptr_PC);	break;		/* branch */		case INSTR_BEQ:		case INSTR_BNE:		case INSTR_BCS:		case INSTR_BCC:		case INSTR_BMI:		case INSTR_BPL:		case INSTR_BVS:		case INSTR_BVC:			break;		/* other */		case INSTR_NOP:											break;		case INSTR_BRK:	arch_6502_trap(cpu, pc, bb);			break;		case INSTR_RTI:	arch_6502_trap(cpu, pc, bb);			break;		case INSTR_XXX:	arch_6502_trap(cpu, pc, bb);			break;	}	return get_length(get_addmode(opcode));}

int countStaticBitdemand(PSY_OUT_CHANNEL psyOutChannel[MAX_CHANNELS],                         PSY_OUT_ELEMENT *psyOutElement,                         int channels){  int statBits=0;  int ch;  COUNT_sub_start("countStaticBitdemand");  MOVE(1); /* counting previous operation */  BRANCH(2);  switch(channels) {  case 1:    ADD(1);    statBits+=SI_ID_BITS+SI_SCE_BITS+SI_ICS_BITS;    PTR_INIT(1); FUNC(2); ADD(1);    statBits+=countTnsBits(&(psyOutChannel[0].tnsInfo),                           psyOutChannel[0].windowSequence);    BRANCH(2);    switch(psyOutChannel[0].windowSequence){      case LONG_WINDOW:      case START_WINDOW:      case STOP_WINDOW:        ADD(1);        statBits+=SI_ICS_INFO_BITS_LONG;      break;      case SHORT_WINDOW:      ADD(1);      statBits+=SI_ICS_INFO_BITS_SHORT;      break;    }    break;  case 2:    ADD(1);    statBits+=SI_ID_BITS+SI_CPE_BITS+2*SI_ICS_BITS;        ADD(1);    statBits+=SI_CPE_MS_MASK_BITS;        INDIRECT(1); PTR_INIT(1); FUNC(4); ADD(1);    statBits+=countMsMaskBits(psyOutChannel[0].sfbCnt,                              psyOutChannel[0].sfbPerGroup,                              psyOutChannel[0].maxSfbPerGroup,                              &psyOutElement->toolsInfo);        PTR_INIT(1); /* psyOutChannel[] */        switch(psyOutChannel[0].windowSequence) {          case LONG_WINDOW:    case START_WINDOW:    case STOP_WINDOW:            ADD(1);      statBits+=SI_ICS_INFO_BITS_LONG;      break;          case SHORT_WINDOW:            ADD(1);      statBits+=SI_ICS_INFO_BITS_SHORT;      break;    }        PTR_INIT(1); /* psyOutChannel[ch] */    LOOP(1);    for(ch=0;ch<2;ch++) {            PTR_INIT(1); FUNC(2); ADD(1);      statBits+=countTnsBits(&(psyOutChannel[ch].tnsInfo),                             psyOutChannel[ch].windowSequence);    }        break;  }  COUNT_sub_end();    return statBits;}

static voidtest_md_reject_cache(void *arg){  (void) arg;  microdesc_cache_t *mc = NULL ;  smartlist_t *added = NULL, *wanted = smartlist_new();  or_options_t *options = get_options_mutable();  char buf[DIGEST256_LEN];  tor_free(options->DataDirectory);  options->DataDirectory = tor_strdup(get_fname("md_datadir_test_rej"));  mock_rgsbd_val_a = tor_malloc_zero(sizeof(routerstatus_t));  mock_rgsbd_val_b = tor_malloc_zero(sizeof(routerstatus_t));  mock_ns_val = tor_malloc_zero(sizeof(networkstatus_t));  mock_ns_val->valid_after = time(NULL) - 86400;  mock_ns_val->valid_until = time(NULL) + 86400;  mock_ns_val->flavor = FLAV_MICRODESC;#ifdef _WIN32  tt_int_op(0, OP_EQ, mkdir(options->DataDirectory));#else  tt_int_op(0, OP_EQ, mkdir(options->DataDirectory, 0700));#endif  MOCK(router_get_mutable_consensus_status_by_descriptor_digest,       mock_router_get_status_by_digest);  MOCK(networkstatus_get_latest_consensus_by_flavor, mock_ns_get_by_flavor);  mc = get_microdesc_cache();#define ADD(hex)                                                        /  do {                                                                  /    tt_int_op(0,OP_EQ,base16_decode(buf,sizeof(buf),hex,strlen(hex)));     /    smartlist_add(wanted, tor_memdup(buf, DIGEST256_LEN));              /  } while (0)  /* invalid,0 */  ADD("5d76bf1c6614e885614a1e0ad074e1ab4ea14655ebeefb1736a71b5ed8a15a51");  /* invalid,2 */  ADD("20d1576c5ab11bbcff0dedb1db4a3cfcc8bc8dd839d8cbfef92d00a1a7d7b294");  /* valid, 6 */  ADD("53f740bd222ab37f19f604b1d3759aa65eff1fbce9ac254bd0fa50d4af9b1bae");  /* valid, 8 */  ADD("a0a155562d8093d8fd0feb7b93b7226e17f056c2142aab7a4ea8c5867a0376d5");  added = microdescs_add_to_cache(mc, MD_PARSE_TEST_DATA, NULL,                                  SAVED_NOWHERE, 0, time(NULL), wanted);  tt_int_op(smartlist_len(added), OP_EQ, 2);  tt_int_op(mock_rgsbd_called, OP_EQ, 2);  tt_int_op(mock_rgsbd_val_a->dl_status.n_download_failures, OP_EQ, 255);  tt_int_op(mock_rgsbd_val_b->dl_status.n_download_failures, OP_EQ, 255); done:  UNMOCK(networkstatus_get_latest_consensus_by_flavor);  UNMOCK(router_get_mutable_consensus_status_by_descriptor_digest);  tor_free(options->DataDirectory);  microdesc_free_all();  smartlist_free(added);  SMARTLIST_FOREACH(wanted, char *, cp, tor_free(cp));  smartlist_free(wanted);  tor_free(mock_rgsbd_val_a);  tor_free(mock_rgsbd_val_b);  tor_free(mock_ns_val);}

int main(){    int m,n,x,b;    int i;    char a[100000];    long long int b0[100000];    long long int b1[100000];    long long int b2[100000];    long long int b3[100000];    long long int b4[100000];    long long int b5[100000];    long long int b6[100000];    long long int b7[100000];    long long int b8[100000];    long long int b9[100000];    scanf("%d%d%s",&m,&n,a);    i=0;        m--;        b=a[i] - '0';        b0[0]=ADD(0,b,0);        b1[0]=ADD(0,b,1);        b2[0]=ADD(0,b,2);        b3[0]=ADD(0,b,3);        b4[0]=ADD(0,b,4);        b5[0]=ADD(0,b,5);        b6[0]=ADD(0,b,6);        b7[0]=ADD(0,b,7);        b8[0]=ADD(0,b,8);        b9[0]=ADD(0,b,9);        i++;    while(m--)    {        b=a[i]-'0';        b0[i]=ADD(b0[i-1],b,0);        b1[i]=ADD(b1[i-1],b,1);        b2[i]=ADD(b2[i-1],b,2);        b3[i]=ADD(b3[i-1],b,3);        b4[i]=ADD(b4[i-1],b,4);        b5[i]=ADD(b5[i-1],b,5);        b6[i]=ADD(b6[i-1],b,6);        b7[i]=ADD(b7[i-1],b,7);        b8[i]=ADD(b8[i-1],b,8);        b9[i]=ADD(b9[i-1],b,9);        i++;    }    while(n--)    {        scanf("%d",&x);        x--;        i=a[x]-'0';        switch(i)        {            case 0:printf("%lld/n",b0[x]);break;            case 1:printf("%lld/n",b1[x]);break;            case 2:printf("%lld/n",b2[x]);break;            case 3:printf("%lld/n",b3[x]);break;            case 4:printf("%lld/n",b4[x]);break;            case 5:printf("%lld/n",b5[x]);break;            case 6:printf("%lld/n",b6[x]);break;            case 7:printf("%lld/n",b7[x]);break;            case 8:printf("%lld/n",b8[x]);break;            case 9:printf("%lld/n",b9[x]);break;        }    }    return 0;}

void foo(){  int add = ADD(505);  int sub = SUB(525);}

static void remote_ui_raw_line(UI *ui, Integer grid, Integer row,                               Integer startcol, Integer endcol,                               Integer clearcol, Integer clearattr,                               Boolean wrap, const schar_T *chunk,                               const sattr_T *attrs){  UIData *data = ui->data;  if (ui->ui_ext[kUILinegrid]) {    Array args = ARRAY_DICT_INIT;    ADD(args, INTEGER_OBJ(grid));    ADD(args, INTEGER_OBJ(row));    ADD(args, INTEGER_OBJ(startcol));    Array cells = ARRAY_DICT_INIT;    int repeat = 0;    size_t ncells = (size_t)(endcol-startcol);    int last_hl = -1;    for (size_t i = 0; i < ncells; i++) {      repeat++;      if (i == ncells-1 || attrs[i] != attrs[i+1]          || STRCMP(chunk[i], chunk[i+1])) {        Array cell = ARRAY_DICT_INIT;        ADD(cell, STRING_OBJ(cstr_to_string((const char *)chunk[i])));        if (attrs[i] != last_hl || repeat > 1) {          ADD(cell, INTEGER_OBJ(attrs[i]));          last_hl = attrs[i];        }        if (repeat > 1) {          ADD(cell, INTEGER_OBJ(repeat));        }        ADD(cells, ARRAY_OBJ(cell));        repeat = 0;      }    }    if (endcol < clearcol) {      Array cell = ARRAY_DICT_INIT;      ADD(cell, STRING_OBJ(cstr_to_string(" ")));      ADD(cell, INTEGER_OBJ(clearattr));      ADD(cell, INTEGER_OBJ(clearcol-endcol));      ADD(cells, ARRAY_OBJ(cell));    }    ADD(args, ARRAY_OBJ(cells));    push_call(ui, "grid_line", args);  } else {    for (int i = 0; i < endcol-startcol; i++) {      remote_ui_cursor_goto(ui, row, startcol+i);      remote_ui_highlight_set(ui, attrs[i]);      remote_ui_put(ui, (const char *)chunk[i]);      if (utf_ambiguous_width(utf_ptr2char(chunk[i]))) {        data->client_col = -1;  // force cursor update      }    }    if (endcol < clearcol) {      remote_ui_cursor_goto(ui, row, endcol);      remote_ui_highlight_set(ui, (int)clearattr);      // legacy eol_clear was only ever used with cleared attributes      // so be on the safe side      if (clearattr == 0 && clearcol == Columns) {        Array args = ARRAY_DICT_INIT;        push_call(ui, "eol_clear", args);      } else {        for (Integer c = endcol; c < clearcol; c++) {          remote_ui_put(ui, " ");        }      }    }  }}

/*typedef struct{	char mnemonic[10];	char op1_type; // reconoce una r o un numeral	char op2_type;	char op3_type;	uint32_t op1_value; guarda el numero del registro o el valor del inmediato	uint32_t op2_value;	uint32_t op3_value;}instruction_t;*/void decodeInstruction(instruction_t instruction,uint32_t* Rd, uint32_t* Rm, uint32_t* Rr, bool flg[], int*pc, uint8_t pila)// recibe el retorno de getInstruccion{    uint32_t cero=0;	if( strcmp(instruction.mnemonic,"PUSH") == 0 )        {	    } else	if( strcmp(instruction.mnemonic,"ADD") == 0)        {           if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='R'))		{           ADD(Rd[instruction.op1_value],Rm[instruction.op2_value],Rr[instruction.op3_value],flg,&pc);        }else if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='#'))           ADD(&Rd[instruction.op1_value],&Rm[instruction.op2_value],&instruction.op3_value,flg, &pc);        }else	    if( strcmp(instruction.mnemonic,"AND") == 0)        {        if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='R'))		{           AND(&Rd[instruction.op1_value],&Rm[instruction.op2_value],&Rr[instruction.op3_value],&flg[0], &pc);        }else if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='#'))           AND(&Rd[instruction.op1_value],&Rm[instruction.op2_value],instruction.op3_value,&flg[0], &pc);	    } else	 if( strcmp(instruction.mnemonic,"ASRS") == 0 )        {		if((instruction.op1_type=='R')&&(instruction.op2_type=='R'))		{           ASRS(&Rd[instruction.op1_value],&Rm[instruction.op2_value], &pc);        }else if((instruction.op1_type=='R')&&(instruction.op2_type=='#'))           ASRS(&Rd[instruction.op1_value],instruction.op2_value, &pc);        } else     if( strcmp(instruction.mnemonic,"BIC") == 0 )        {		if((instruction.op1_type=='R')&&(instruction.op2_type=='R'))		{           BIC(&Rd[instruction.op1_value],&Rm[instruction.op2_value], &pc);        }else if((instruction.op1_type=='R')&&(instruction.op2_type=='#'))           BIC(&Rd[instruction.op1_value],instruction.op2_value, &pc);        } else	 if( strcmp(instruction.mnemonic,"CMN") == 0)        {		if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='R'))		{        CMN(&Rd[instruction.op1_value],&Rm[instruction.op2_value],&Rr[instruction.op3_value], &pc);        }else if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='#'))        CMN(&Rd[instruction.op1_value],&Rm[instruction.op2_value],instruction.op3_value, &pc);        } else	 if( strcmp(instruction.mnemonic,"CMP") == 0 )        {		if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='R'))		{        CMP(&Rd[instruction.op1_value],&Rm[instruction.op2_value],&Rr[instruction.op3_value], &pc);        }else if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='#'))        CMP(&Rd[instruction.op1_value],&Rm[instruction.op2_value],instruction.op3_value, &pc);		} else	 if( strcmp(instruction.mnemonic,"EOR") == 0)        {if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='R'))		{           EOR(&Rd[instruction.op1_value],&Rm[instruction.op2_value],&Rr[instruction.op3_value],&flg[0], &pc);        }else if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='#'))           EOR(&Rd[instruction.op1_value],&Rm[instruction.op2_value],instruction.op3_value,&flg[0], &pc);		} else	 if( strcmp(instruction.mnemonic,"LSL") == 0 )        {if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='R'))		{         LSL(&Rd[instruction.op1_value],&Rm[instruction.op2_value],instruction.op3_value, &pc);        }else if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='#'))         LSL(&Rd[instruction.op1_value],&Rm[instruction.op2_value],cero, &pc);	    } else     if( strcmp(instruction.mnemonic,"LSR") == 0)        {        {if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='R'))		{         LSR(&Rd[instruction.op1_value],&Rm[instruction.op2_value],cero, &pc);        }else if((instruction.op1_type=='R')&&(instruction.op2_type=='R')&&(instruction.op3_type=='#'))         LSR(&Rd[instruction.op1_value],&Rm[instruction.op2_value],instruction.op3_value, &pc);        }        } else	 if( strcmp(instruction.mnemonic,"MOV") == 0)        {          if((instruction.op1_type=='R')&&(instruction.op2_type=='R'))		{         MOV(&Rd[instruction.op1_value],&Rm[instruction.op2_value],&flg[0], &pc);        }else if((instruction.op1_type=='R')&&(instruction.op2_type=='#'))         MOV(&Rd[instruction.op1_value],instruction.op2_value,&flg[0], &pc);//.........这里部分代码省略.........

char *makeWindowsCommandLine (const char *const *arguments) {  const char backslash = '//';  const char quote = '"';  char *buffer = NULL;  int size = 0;  int length = 0;#define ADD(c) if (!addWindowsCommandLineCharacter(&buffer, &size, &length, (c))) goto error  while (*arguments) {    const char *character = *arguments;    int backslashCount = 0;    int needQuotes = 0;    int start = length;    while (*character) {      if (*character == backslash) {        ++backslashCount;      } else {        if (*character == quote) {          needQuotes = 1;          backslashCount = (backslashCount * 2) + 1;        } else if ((*character == ' ') || (*character == '/t')) {          needQuotes = 1;        }        while (backslashCount > 0) {          ADD(backslash);          --backslashCount;        }        ADD(*character);      }      ++character;    }    if (needQuotes) backslashCount *= 2;    while (backslashCount > 0) {      ADD(backslash);      --backslashCount;    }    if (needQuotes) {      ADD(quote);      ADD(quote);      memmove(&buffer[start+1], &buffer[start], length-start-1);      buffer[start] = quote;    }    ADD(' ');    ++arguments;  }#undef ADD  buffer[length-1] = 0;  {    char *line = realloc(buffer, length);    if (line) return line;    logSystemError("realloc");  }error:  if (buffer) free(buffer);  return NULL;}

static void remote_ui_grid_scroll(UI *ui, Integer grid, Integer top,                                  Integer bot, Integer left, Integer right,                                  Integer rows, Integer cols){  if (ui->ui_ext[kUILinegrid]) {    Array args = ARRAY_DICT_INIT;    ADD(args, INTEGER_OBJ(grid));    ADD(args, INTEGER_OBJ(top));    ADD(args, INTEGER_OBJ(bot));    ADD(args, INTEGER_OBJ(left));    ADD(args, INTEGER_OBJ(right));    ADD(args, INTEGER_OBJ(rows));    ADD(args, INTEGER_OBJ(cols));    push_call(ui, "grid_scroll", args);  } else {    Array args = ARRAY_DICT_INIT;    ADD(args, INTEGER_OBJ(top));    ADD(args, INTEGER_OBJ(bot-1));    ADD(args, INTEGER_OBJ(left));    ADD(args, INTEGER_OBJ(right-1));    push_call(ui, "set_scroll_region", args);    args = (Array)ARRAY_DICT_INIT;    ADD(args, INTEGER_OBJ(rows));    push_call(ui, "scroll", args);    // some clients have "clear" being affected by scroll region,    // so reset it.    args = (Array)ARRAY_DICT_INIT;    ADD(args, INTEGER_OBJ(0));    ADD(args, INTEGER_OBJ(ui->height-1));    ADD(args, INTEGER_OBJ(0));    ADD(args, INTEGER_OBJ(ui->width-1));    push_call(ui, "set_scroll_region", args);  }}

bp_Table * bp_parseTable(bp_Context * context, xmlNodePtr node) {	bp_Table * result = malloc(sizeof(bp_Table));	bp_Node * const parent = &result->node;	xmlAttrPtr attr;	xmlNodePtr child, grand;	bp_pushBlockBorder(context);	bp_pushBlockInside(context);	bp_pushInline(context);	bp_initNode(&result->node, BPE_TABLE);	result->_float = bp_defaultFloatAttributes;	result->blockOutside = *(context->blockOutside);	result->caption = NULL;	result->nCols = 0;	result->nRows = 0;		for (attr = node->properties; attr; attr = attr->next) {		bp_parseFloatAttribute(context, &result->_float, attr);		bp_parseBlockOutsideAttribute(context, &result->blockOutside, attr);		bp_parseBlockBorderAttribute(context, context->blockBorder, attr);		bp_parseBlockInsideAttribute(context, context->blockInside, attr);		bp_parseInlineAttribute(context, context->inlineAttr, attr);	}	result->blockBorder = *(context->blockBorder); // shared with children	for (child = node->children; child; child = child->next) {		switch(ELEM(child)) {			case BPE_TR: result->nRows++; break;			case BPE_TC: result->nCols++; break;			case BPE_CAPTION:				result->caption = bp_parseCaption(context, child);			default: DISCARD(child);		}	}	if (result->nRows) {		int * colHeights = NULL; 		int col, row = 0;		result->nCols = 0;		for (child = node->children; child; child = child->next) {			if(ELEM(child) == BPE_TR) {				bp_pushBlockBorder(context);				bp_pushBlockInside(context);				bp_pushInline(context);				for (attr = child->properties; attr; attr = attr->next) {					bp_parseBlockBorderAttribute(context, context->blockBorder, attr);					bp_parseBlockInsideAttribute(context, context->blockInside, attr);					bp_parseInlineAttribute(context, context->inlineAttr, attr);				}								col = 0;				for (grand = child->children; grand; grand = grand->next) {					while ((col < result->nCols) && (colHeights[col] >= row)) col++;												if(ELEM(grand) == BPE_TD) {						bp_Cell * cell = bp_parseCell(context, grand, row, col);						ADD(cell);												if (cell->endCol >= result->nCols) {							result->nCols = cell->endCol + 1;							colHeights = realloc(colHeights, result->nCols * sizeof(int));						}												for (col=cell->startCol; col <= cell->endCol; col++) {							colHeights[col] = cell->endRow;						}					} else {						DISCARD(grand);					}				}				bp_popBlockBorder(context);				bp_popBlockInside(context);				bp_popInline(context);				row++;			}		}		if(colHeights) free(colHeights);	} else if (result->nCols) {		int * rowWidths = NULL; 		int col = 0, row;		result->nRows = 0;		for (child = node->children; child; child = child->next) {			if(ELEM(child) == BPE_TC) {				bp_pushBlockBorder(context);				bp_pushBlockInside(context);				bp_pushInline(context);				for (attr = child->properties; attr; attr = attr->next) {					bp_parseBlockBorderAttribute(context, context->blockBorder, attr);					bp_parseBlockInsideAttribute(context, context->blockInside, attr);					bp_parseInlineAttribute(context, context->inlineAttr, attr);				}//.........这里部分代码省略.........

bp_Page * bp_parsePage(bp_Context * context, xmlNodePtr node) {	bp_Page * result = malloc(sizeof(bp_Page));	bp_Node * const parent = &result->node;	xmlAttrPtr attr;	xmlNodePtr child;	bp_pushBlockOutside(context);	bp_pushBlockBorder(context);	bp_pushBlockInside(context);	bp_pushInline(context);	bp_initNode(&result->node, BPE_PAGE);	result->title = NULL;	for (attr = node->properties; attr; attr = attr->next) {		bp_parseBlockOutsideAttribute(context, context->blockOutside, attr);		bp_parseBlockBorderAttribute(context, context->blockBorder, attr);		bp_parseBlockInsideAttribute(context, context->blockInside, attr);		bp_parseInlineAttribute(context, context->inlineAttr, attr);	}	for (child = node->children; child; child = child->next) {		switch(ELEM(child)) {			case BPE_TITLE:				if (!result->title) {					xmlNodePtr grandchild = child->children;					if (ELEM(grandchild) == BPE_TEXT) {						int len = strlen(grandchild->content);						char * title_string = malloc(++len);						memcpy(title_string, grandchild->content, len);						result->title = title_string;					} else {						DISCARD(grandchild);					}				} else {					DISCARD(child);				}				break;			case BPE_REF:				bp_parseNavRef(context, child, result);				break;			case BPE_BLOCK:				ADD(bp_parseBlock(context, child));				break;			case BPE_IMAGE:				ADD(bp_parseImage(context, child));				break;			case BPE_TABLE:				ADD(bp_parseTable(context, child));				break;			case BPE_LABEL:				ADD(bp_parseLabel(context, child));				break;			default:				DISCARD(child);		}	}	bp_popBlockOutside(context);	bp_popBlockBorder(context);	bp_popBlockInside(context);	bp_popInline(context);	return result;}

bp_Book * bp_parseBook(bp_Context * context, xmlNodePtr node) {	bp_Book * result = malloc(sizeof(bp_Book));	bp_Node * const parent = &result->node;	bp_Node * page;	xmlAttrPtr attr;	xmlNodePtr child;	bp_Page ** pages;	st_data * fontSym;	context->blockOutside = (void *) &bp_defaultBlockOutsideAttributes;	context->blockBorder  = (void *) &bp_defaultBlockBorderAttributes;	context->blockInside  = (void *) &bp_defaultBlockInsideAttributes;	context->inlineAttr      = (void *) &bp_defaultInlineAttributes;	bp_pushBlockOutside(context);	bp_pushBlockBorder(context);	bp_pushBlockInside(context);	bp_pushInline(context);	bp_initNode(&result->node, BPE_BOOK);	result->width = 528;	result->height = 320;	result->background = load_texture_cache_deferred("textures/book1.bmp",0);	fontSym = st_lookup (bp_fonts, "default");	if (fontSym != NULL) {		result->fontFace = fontSym->num;	} else {		LOG_ERROR_OLD("FATAL: default font missing in font symbol table/n");		exit(1);	}	result->layout = BPL_BOOK;	result->blockProgression = BPD_DOWN;	result->inlineProgression = BPD_RIGHT;	result->pages = NULL;	result->nPages = 0;	for (attr = node->properties; attr; attr = attr->next) {		bp_parseBlockOutsideAttribute(context, context->blockOutside, attr);		bp_parseBlockBorderAttribute(context, context->blockBorder, attr);		bp_parseBlockInsideAttribute(context, context->blockInside, attr);		bp_parseInlineAttribute(context, context->inlineAttr, attr);	}	for (child = node->children; child; child = child->next) {		switch(ELEM(child)) {			case BPE_PAGE:				result->nPages++;				ADD(bp_parsePage(context, child));				break;			default:				DISCARD(child);		}	}	bp_popBlockOutside(context);	bp_popBlockBorder(context);	bp_popBlockInside(context);	bp_popInline(context);	/* create page index */	pages = calloc(result->nPages, sizeof(bp_Page *));	result->pages = pages;	for (page = parent->children; page; page = page->next) {		*pages++ = (bp_Page *) page;	}		return result;}

//.........这里部分代码省略.........    BF0( 6, 25, COS0_6 , 1);    BF0( 9, 22, COS0_9 , 1);    /* pass 2 */    BF( 6,  9, COS1_6 , 2);    BF(22, 25,-COS1_6 , 2);    /* pass 3 */    BF( 1,  6, COS2_1 , 1);    BF( 9, 14,-COS2_1 , 1);    BF(17, 22, COS2_1 , 1);    BF(25, 30,-COS2_1 , 1);    /* pass 1 */    BF0( 2, 29, COS0_2 , 1);    BF0(13, 18, COS0_13, 3);    /* pass 2 */    BF( 2, 13, COS1_2 , 1);    BF(18, 29,-COS1_2 , 1);    /* pass 1 */    BF0( 5, 26, COS0_5 , 1);    BF0(10, 21, COS0_10, 1);    /* pass 2 */    BF( 5, 10, COS1_5 , 2);    BF(21, 26,-COS1_5 , 2);    /* pass 3 */    BF( 2,  5, COS2_2 , 1);    BF(10, 13,-COS2_2 , 1);    BF(18, 21, COS2_2 , 1);    BF(26, 29,-COS2_2 , 1);    /* pass 4 */    BF( 1,  2, COS3_1 , 2);    BF( 5,  6,-COS3_1 , 2);    BF( 9, 10, COS3_1 , 2);    BF(13, 14,-COS3_1 , 2);    BF(17, 18, COS3_1 , 2);    BF(21, 22,-COS3_1 , 2);    BF(25, 26, COS3_1 , 2);    BF(29, 30,-COS3_1 , 2);    /* pass 5 */    BF1( 0,  1,  2,  3);    BF2( 4,  5,  6,  7);    BF1( 8,  9, 10, 11);    BF2(12, 13, 14, 15);    BF1(16, 17, 18, 19);    BF2(20, 21, 22, 23);    BF1(24, 25, 26, 27);    BF2(28, 29, 30, 31);    /* pass 6 */    ADD( 8, 12);    ADD(12, 10);    ADD(10, 14);    ADD(14,  9);    ADD( 9, 13);    ADD(13, 11);    ADD(11, 15);    out[ 0] = val0;    out[16] = val1;    out[ 8] = val2;    out[24] = val3;    out[ 4] = val4;    out[20] = val5;    out[12] = val6;    out[28] = val7;    out[ 2] = val8;    out[18] = val9;    out[10] = val10;    out[26] = val11;    out[ 6] = val12;    out[22] = val13;    out[14] = val14;    out[30] = val15;    ADD(24, 28);    ADD(28, 26);    ADD(26, 30);    ADD(30, 25);    ADD(25, 29);    ADD(29, 27);    ADD(27, 31);    out[ 1] = val16 + val24;    out[17] = val17 + val25;    out[ 9] = val18 + val26;    out[25] = val19 + val27;    out[ 5] = val20 + val28;    out[21] = val21 + val29;    out[13] = val22 + val30;    out[29] = val23 + val31;    out[ 3] = val24 + val20;    out[19] = val25 + val21;    out[11] = val26 + val22;    out[27] = val27 + val23;    out[ 7] = val28 + val18;    out[23] = val29 + val19;    out[15] = val30 + val17;    out[31] = val31;}

RETf ADD( const __m128 x, const __m128 y, const __m128 z ) {  return ADD(ADD(x,y),z); }

/* * Initialize generic PHY media based on BMSR, called when a PHY is * attached.  We expect to be set up to print a comma-separated list * of media names.  Does not print a newline. */voidmii_phy_add_media(struct mii_softc *sc){	struct mii_data *mii = sc->mii_pdata;	const char *sep = "";	int fdx = 0;	if ((sc->mii_capabilities & BMSR_MEDIAMASK) == 0 &&	    (sc->mii_extcapabilities & EXTSR_MEDIAMASK) == 0) {		printf("no media present");		return;	}	/*	 * Set the autonegotiation timer for 10/100 media.  Gigabit media is	 * handled below.	 */	sc->mii_anegticks = MII_ANEGTICKS;#define	ADD(m, c)	ifmedia_add(&mii->mii_media, (m), (c), NULL)#define	PRINT(s)	printf("%s%s", sep, s); sep = ", "	if ((sc->mii_flags & MIIF_NOISOLATE) == 0)		ADD(IFM_MAKEWORD(IFM_ETHER, IFM_NONE, 0, sc->mii_inst),		    MII_MEDIA_NONE);	/*	 * There are different interpretations for the bits in	 * HomePNA PHYs.  And there is really only one media type	 * that is supported.	 */	if ((sc->mii_flags & MIIF_IS_HPNA) != 0) {		if ((sc->mii_capabilities & BMSR_10THDX) != 0) {			ADD(IFM_MAKEWORD(IFM_ETHER, IFM_HPNA_1, 0,			    sc->mii_inst), MII_MEDIA_10_T);			PRINT("HomePNA1");		}		return;	}	if ((sc->mii_capabilities & BMSR_10THDX) != 0) {		ADD(IFM_MAKEWORD(IFM_ETHER, IFM_10_T, 0, sc->mii_inst),		    MII_MEDIA_10_T);		PRINT("10baseT");	}	if ((sc->mii_capabilities & BMSR_10TFDX) != 0) {		ADD(IFM_MAKEWORD(IFM_ETHER, IFM_10_T, IFM_FDX, sc->mii_inst),		    MII_MEDIA_10_T_FDX);		PRINT("10baseT-FDX");		if ((sc->mii_flags & MIIF_DOPAUSE) != 0 &&		    (sc->mii_flags & MIIF_NOMANPAUSE) == 0) {			ADD(IFM_MAKEWORD(IFM_ETHER, IFM_10_T,			    IFM_FDX | IFM_FLOW, sc->mii_inst),			    MII_MEDIA_10_T_FDX);			PRINT("10baseT-FDX-flow");		}		fdx = 1;	}	if ((sc->mii_capabilities & BMSR_100TXHDX) != 0) {		ADD(IFM_MAKEWORD(IFM_ETHER, IFM_100_TX, 0, sc->mii_inst),		    MII_MEDIA_100_TX);		PRINT("100baseTX");	}	if ((sc->mii_capabilities & BMSR_100TXFDX) != 0) {		ADD(IFM_MAKEWORD(IFM_ETHER, IFM_100_TX, IFM_FDX, sc->mii_inst),		    MII_MEDIA_100_TX_FDX);		PRINT("100baseTX-FDX");		if ((sc->mii_flags & MIIF_DOPAUSE) != 0 &&		    (sc->mii_flags & MIIF_NOMANPAUSE) == 0) {			ADD(IFM_MAKEWORD(IFM_ETHER, IFM_100_TX,			    IFM_FDX | IFM_FLOW, sc->mii_inst),			    MII_MEDIA_100_TX_FDX);			PRINT("100baseTX-FDX-flow");		}		fdx = 1;	}	if ((sc->mii_capabilities & BMSR_100T4) != 0) {		ADD(IFM_MAKEWORD(IFM_ETHER, IFM_100_T4, 0, sc->mii_inst),		    MII_MEDIA_100_T4);		PRINT("100baseT4");	}	if ((sc->mii_extcapabilities & EXTSR_MEDIAMASK) != 0) {		/*		 * XXX Right now only handle 1000SX and 1000TX.  Need		 * XXX to handle 1000LX and 1000CX somehow.		 */		if ((sc->mii_extcapabilities & EXTSR_1000XHDX) != 0) {			sc->mii_anegticks = MII_ANEGTICKS_GIGE;			sc->mii_flags |= MIIF_IS_1000X;			ADD(IFM_MAKEWORD(IFM_ETHER, IFM_1000_SX, 0,			    sc->mii_inst), MII_MEDIA_1000_X);			PRINT("1000baseSX");		}		if ((sc->mii_extcapabilities & EXTSR_1000XFDX) != 0) {//.........这里部分代码省略.........

void Jit::Comp_FPULS(u32 op){	CONDITIONAL_DISABLE;	s32 offset = (s16)(op & 0xFFFF);	int ft = _FT;	int rs = _RS;	// u32 addr = R(rs) + offset;	// logBlocks = 1;	bool doCheck = false;	switch(op >> 26)	{	case 49: //FI(ft) = Memory::Read_U32(addr); break; //lwc1		fpr.MapReg(ft, MAP_NOINIT | MAP_DIRTY);		if (gpr.IsImm(rs)) {			u32 addr = (offset + gpr.GetImm(rs)) & 0x3FFFFFFF;			MOVI2R(R0, addr + (u32)Memory::base);		} else {			gpr.MapReg(rs);			if (g_Config.bFastMemory) {				SetR0ToEffectiveAddress(rs, offset);			} else {				SetCCAndR0ForSafeAddress(rs, offset, R1);				doCheck = true;			}			ADD(R0, R0, R11);		}#ifdef __ARM_ARCH_7S__        FixupBranch skip;        if (doCheck) {            skip = B_CC(CC_EQ);        }        VLDR(fpr.R(ft), R0, 0);        if (doCheck) {            SetJumpTarget(skip);            SetCC(CC_AL);        }#else		VLDR(fpr.R(ft), R0, 0);		if (doCheck) {			SetCC(CC_EQ);			MOVI2R(R0, 0);			VMOV(fpr.R(ft), R0);			SetCC(CC_AL);		}#endif		break;	case 57: //Memory::Write_U32(FI(ft), addr); break; //swc1		fpr.MapReg(ft);		if (gpr.IsImm(rs)) {			u32 addr = (offset + gpr.GetImm(rs)) & 0x3FFFFFFF;			MOVI2R(R0, addr + (u32)Memory::base);		} else {			gpr.MapReg(rs);			if (g_Config.bFastMemory) {				SetR0ToEffectiveAddress(rs, offset);			} else {				SetCCAndR0ForSafeAddress(rs, offset, R1);				doCheck = true;			}			ADD(R0, R0, R11);		}#ifdef __ARM_ARCH_7S__        FixupBranch skip2;        if (doCheck) {            skip2 = B_CC(CC_EQ);        }        VSTR(fpr.R(ft), R0, 0);        if (doCheck) {            SetJumpTarget(skip2);            SetCC(CC_AL);        }#else		VSTR(fpr.R(ft), R0, 0);		if (doCheck) {			SetCC(CC_AL);		}#endif		break;	default:		Comp_Generic(op);		return;	}}

RETf INC( __m128 &x, const __m128 y ) { return x = ADD(x,y); }

int main() {	// distribute bodies in space (randomly)	for(int i=0; i<N; i++) {		B[i].m = (i < L)?1:0;		B[i].pos = triple_rand();//		B[i].pos = (position) { 0, -10 + 20*(i/2), -10 + 20*(i%2) };		// for debugging!		B[i].v   = triple_zero();	}	// run simulation for M steps	#pragma omp parallel	for(int i=0; i<M; i++) {				// set forces to zero		#pragma omp for		for(int j=0; j<N; j++) {			F[j] = triple_zero();		}		// reset private copy		for(int j=0; j<N; j++) {			pF[j] = triple_zero();		}		// compute forces for each body (very naive)		#pragma omp for		for(int j=0; j<min(N,L); j++) {			for(int k=0; k<N; k++) {				if(j!=k) {					// comput distance vector					triple dist = SUB(B[k].pos, B[j].pos);					// compute absolute distance					double r = ABS(dist);									// compute strength of force (G = 1 (who cares))					//			F = G * (m1 * m2) / r^2					double f = (B[j].m * B[k].m) / (r*r);					// compute current contribution to force					//force cur = MULS(NORM(dist), f);					double s = f / r;					force cur = MULS(dist,s);					// accumulate force					pF[j] = ADD(pF[j], cur);				}			}		}		// aggregate local data		#pragma omp critical		for(int j=0; j<N; j++) {			F[j] = ADD(pF[j],F[j]);		}		// apply forces		#pragma omp for		for(int j=0; j<min(N,L); j++) {			// update speed			//		F = m * a			//		a = F / m		// m=1			//		v' = v + a			B[j].v = ADD(B[j].v, DIVS(F[j], B[j].m));			// update position			//		pos = pos + v * dt		// dt = 1			B[j].pos = ADD(B[j].pos, B[j].v);		}/*		// debug print of positions and speed		for(int i=0; i<N; i++) {			printf("%2d - ", i); 			triple_print(B[i].pos);			printf(" - ");			triple_print(B[i].v);			printf("/n");		}		printf("/n");*/	}	// check result (impulse has to be zero)	impulse sum = triple_zero();	for(int i=0; i<N; i++) {		// impulse = m * v		sum = ADD(sum, MULS(B[i].v,B[i].m));	}	int success = EQ(sum, triple_zero());	printf("Verification: %s/n", ((success)?"OK":"ERR"));	if (!success) {		triple_print(sum); printf(" should be (0,0,0)/n");		return EXIT_FAILURE;	}	return EXIT_SUCCESS;}

static int tnsCount(TNS_INFO *tnsInfo, int blockType){  int i,k;  int tnsPresent;  int numOfWindows;  int count;  int coefBits;  COUNT_sub_start("tnsCount");  MOVE(1);  count = 0;  ADD(1); BRANCH(1); MOVE(1);  numOfWindows=(blockType==2?8:1);  MOVE(1);  tnsPresent=0;  PTR_INIT(1); /* tnsInfo->numOfFilters[] */  LOOP(1);  for (i=0; i<numOfWindows; i++) {    ADD(1); BRANCH(1);    if (tnsInfo->tnsActive[i]==1) {      MOVE(1);      tnsPresent=1;    }  }  BRANCH(1);  if (tnsPresent==0) {    /* count+=1; */  }  else{ /* there is data to be written*/    /*count += 1; */    PTR_INIT(2); /* tnsInfo->tnsActive[]                    tnsInfo->coefRes[]                 */    LOOP(1);    for (i=0; i<numOfWindows; i++) {      ADD(1); BRANCH(1); /* .. == .. ? */ ADD(1);      count +=(blockType==SHORT_WINDOW?1:2);      BRANCH(1);      if (tnsInfo->tnsActive[i]) {        ADD(1);        count += 1;        ADD(1); BRANCH(1); /* .. == .. ? */ ADD(2);        count +=(blockType==SHORT_WINDOW?4:6);        count +=(blockType==SHORT_WINDOW?3:5);                BRANCH(1);        if (tnsInfo->order[i]){          ADD(2);          count +=1; /*direction*/          count +=1; /*coef_compression */                    ADD(1); BRANCH(1);          if(tnsInfo->coefRes[i] == 4) {            MOVE(1);            coefBits=3;                        PTR_INIT(1); /* tnsInfo->coef[]*/            LOOP(1);            for(k=0; k<tnsInfo->order[i]; k++) {                            ADD(2); LOGIC(1); BRANCH(1);              if (tnsInfo->coef[i*TNS_MAX_ORDER_SHORT+k]> 3 ||                  tnsInfo->coef[i*TNS_MAX_ORDER_SHORT+k]< -4) {                                MOVE(1);                coefBits = 4;                break;              }            }          }          else {                        MOVE(1);            coefBits = 2;                        PTR_INIT(1); /* tnsInfo->coef[]*/            LOOP(1);            for(k=0; k<tnsInfo->order[i]; k++) {                            ADD(2); LOGIC(1); BRANCH(1);              if (tnsInfo->coef[i*TNS_MAX_ORDER_SHORT+k]> 1 ||                  tnsInfo->coef[i*TNS_MAX_ORDER_SHORT+k]< -2) {                                MOVE(1);                coefBits = 3;//.........这里部分代码省略.........

/* Attach the PHY to the MII bus */static intbrgphy_attach(device_t dev){	struct brgphy_softc *bsc;	struct bge_softc *bge_sc = NULL;	struct bce_softc *bce_sc = NULL;	struct mii_softc *sc;	struct ifnet *ifp;	bsc = device_get_softc(dev);	sc = &bsc->mii_sc;	mii_phy_dev_attach(dev, MIIF_NOISOLATE | MIIF_NOMANPAUSE,	    &brgphy_funcs, 0);	bsc->serdes_flags = 0;	/* Handle any special cases based on the PHY ID */	switch (sc->mii_mpd_oui) {	case MII_OUI_BROADCOM:		switch (sc->mii_mpd_model) {		case MII_MODEL_BROADCOM_BCM5706:		case MII_MODEL_BROADCOM_BCM5714:			/*			 * The 5464 PHY used in the 5706 supports both copper			 * and fiber interfaces over GMII.  Need to check the			 * shadow registers to see which mode is actually			 * in effect, and therefore whether we have 5706C or			 * 5706S.			 */			PHY_WRITE(sc, BRGPHY_MII_SHADOW_1C,				BRGPHY_SHADOW_1C_MODE_CTRL);			if (PHY_READ(sc, BRGPHY_MII_SHADOW_1C) &				BRGPHY_SHADOW_1C_ENA_1000X) {				bsc->serdes_flags |= BRGPHY_5706S;				sc->mii_flags |= MIIF_HAVEFIBER;			}			break;		}		break;	case MII_OUI_BROADCOM2:		switch (sc->mii_mpd_model) {		case MII_MODEL_BROADCOM2_BCM5708S:			bsc->serdes_flags |= BRGPHY_5708S;			sc->mii_flags |= MIIF_HAVEFIBER;			break;		case MII_MODEL_BROADCOM2_BCM5709S:			bsc->serdes_flags |= BRGPHY_5709S;			sc->mii_flags |= MIIF_HAVEFIBER;			break;		}		break;	}	ifp = sc->mii_pdata->mii_ifp;	/* Find the MAC driver associated with this PHY. */	if (strcmp(ifp->if_dname, "bge") == 0)	{		bge_sc = ifp->if_softc;	} else if (strcmp(ifp->if_dname, "bce") == 0) {		bce_sc = ifp->if_softc;	}	PHY_RESET(sc);	/* Read the PHY's capabilities. */	sc->mii_capabilities = PHY_READ(sc, MII_BMSR) & sc->mii_capmask;	if (sc->mii_capabilities & BMSR_EXTSTAT)		sc->mii_extcapabilities = PHY_READ(sc, MII_EXTSR);	device_printf(dev, " ");#define	ADD(m, c)	ifmedia_add(&sc->mii_pdata->mii_media, (m), (c), NULL)	/* Add the supported media types */	if ((sc->mii_flags & MIIF_HAVEFIBER) == 0) {		mii_phy_add_media(sc);		printf("/n");	} else {		sc->mii_anegticks = MII_ANEGTICKS_GIGE;		ADD(IFM_MAKEWORD(IFM_ETHER, IFM_1000_SX, IFM_FDX, sc->mii_inst),			BRGPHY_S1000 | BRGPHY_BMCR_FDX);		printf("1000baseSX-FDX, ");		/* 2.5G support is a software enabled feature on the 5708S and 5709S. */		if (bce_sc && (bce_sc->bce_phy_flags & BCE_PHY_2_5G_CAPABLE_FLAG)) {			ADD(IFM_MAKEWORD(IFM_ETHER, IFM_2500_SX, IFM_FDX, sc->mii_inst), 0);			printf("2500baseSX-FDX, ");		} else if ((bsc->serdes_flags & BRGPHY_5708S) && bce_sc &&		    (detect_hs21(bce_sc) != 0)) {			/*			 * There appears to be certain silicon revision			 * in IBM HS21 blades that is having issues with			 * this driver wating for the auto-negotiation to			 * complete. This happens with a specific chip id			 * only and when the 1000baseSX-FDX is the only			 * mode. Workaround this issue since it's unlikely			 * to be ever addressed.			 */			printf("auto-neg workaround, ");			bsc->serdes_flags |= BRGPHY_NOANWAIT;//.........这里部分代码省略.........

void decodePlanarCode(unsigned short* code) {    /* complexity of method to determine inverse isn't that good, but will have to satisfy for now     */    int i, j, codePosition;    int edgeCounter = 0;    EDGE *inverse;    nv = code[0];    codePosition = 1;    for (i = 0; i < nv; i++) {        degree[i] = 0;        neighbourhood[i] = SINGLETON(code[codePosition] - 1);        firstedge[i] = edges + edgeCounter;        edges[edgeCounter].start = i;        edges[edgeCounter].end = code[codePosition] - 1;        edges[edgeCounter].vertices = UNION(SINGLETON(i), SINGLETON(code[codePosition] - 1));        edges[edgeCounter].next = edges + edgeCounter + 1;        if (code[codePosition] - 1 < i) {            inverse = edgeMatrix[code[codePosition] - 1][i];            edges[edgeCounter].inverse = inverse;            inverse->inverse = edges + edgeCounter;        } else {            edgeMatrix[i][code[codePosition] - 1] = edges + edgeCounter;            edges[edgeCounter].inverse = NULL;        }        edgeCounter++;        codePosition++;        for (j = 1; code[codePosition]; j++, codePosition++) {            if (j == MAXVAL) {                fprintf(stderr, "MAXVAL too small: %d/n", MAXVAL);                exit(0);            }            ADD(neighbourhood[i], code[codePosition] - 1);            edges[edgeCounter].start = i;            edges[edgeCounter].end = code[codePosition] - 1;            edges[edgeCounter].vertices = UNION(SINGLETON(i), SINGLETON(code[codePosition] - 1));            edges[edgeCounter].prev = edges + edgeCounter - 1;            edges[edgeCounter].next = edges + edgeCounter + 1;            if (code[codePosition] - 1 < i) {                inverse = edgeMatrix[code[codePosition] - 1][i];                edges[edgeCounter].inverse = inverse;                inverse->inverse = edges + edgeCounter;            } else {                edgeMatrix[i][code[codePosition] - 1] = edges + edgeCounter;                edges[edgeCounter].inverse = NULL;            }            edgeCounter++;        }        firstedge[i]->prev = edges + edgeCounter - 1;        edges[edgeCounter - 1].next = firstedge[i];        degree[i] = j;        codePosition++; /* read the closing 0 */    }    ne = edgeCounter;    makeDual();    // nv - ne/2 + nf = 2}

voidvec4_vs_visitor::emit_prolog(){   dst_reg sign_recovery_shift;   dst_reg normalize_factor;   dst_reg es3_normalize_factor;   for (int i = 0; i < VERT_ATTRIB_MAX; i++) {      if (vs_prog_data->inputs_read & BITFIELD64_BIT(i)) {         uint8_t wa_flags = vs_compile->key.gl_attrib_wa_flags[i];         dst_reg reg(ATTR, i);         dst_reg reg_d = reg;         reg_d.type = BRW_REGISTER_TYPE_D;         dst_reg reg_ud = reg;         reg_ud.type = BRW_REGISTER_TYPE_UD;         /* Do GL_FIXED rescaling for GLES2.0.  Our GL_FIXED attributes          * come in as floating point conversions of the integer values.          */         if (wa_flags & BRW_ATTRIB_WA_COMPONENT_MASK) {            dst_reg dst = reg;            dst.type = brw_type_for_base_type(glsl_type::vec4_type);            dst.writemask = (1 << (wa_flags & BRW_ATTRIB_WA_COMPONENT_MASK)) - 1;            emit(MUL(dst, src_reg(dst), src_reg(1.0f / 65536.0f)));         }         /* Do sign recovery for 2101010 formats if required. */         if (wa_flags & BRW_ATTRIB_WA_SIGN) {            if (sign_recovery_shift.file == BAD_FILE) {               /* shift constant: <22,22,22,30> */               sign_recovery_shift = dst_reg(this, glsl_type::uvec4_type);               emit(MOV(writemask(sign_recovery_shift, WRITEMASK_XYZ), src_reg(22u)));               emit(MOV(writemask(sign_recovery_shift, WRITEMASK_W), src_reg(30u)));            }            emit(SHL(reg_ud, src_reg(reg_ud), src_reg(sign_recovery_shift)));            emit(ASR(reg_d, src_reg(reg_d), src_reg(sign_recovery_shift)));         }         /* Apply BGRA swizzle if required. */         if (wa_flags & BRW_ATTRIB_WA_BGRA) {            src_reg temp = src_reg(reg);            temp.swizzle = BRW_SWIZZLE4(2,1,0,3);            emit(MOV(reg, temp));         }         if (wa_flags & BRW_ATTRIB_WA_NORMALIZE) {            /* ES 3.0 has different rules for converting signed normalized             * fixed-point numbers than desktop GL.             */            if (_mesa_is_gles3(ctx) && (wa_flags & BRW_ATTRIB_WA_SIGN)) {               /* According to equation 2.2 of the ES 3.0 specification,                * signed normalization conversion is done by:                *                * f = c / (2^(b-1)-1)                */               if (es3_normalize_factor.file == BAD_FILE) {                  /* mul constant: 1 / (2^(b-1) - 1) */                  es3_normalize_factor = dst_reg(this, glsl_type::vec4_type);                  emit(MOV(writemask(es3_normalize_factor, WRITEMASK_XYZ),                           src_reg(1.0f / ((1<<9) - 1))));                  emit(MOV(writemask(es3_normalize_factor, WRITEMASK_W),                           src_reg(1.0f / ((1<<1) - 1))));               }               dst_reg dst = reg;               dst.type = brw_type_for_base_type(glsl_type::vec4_type);               emit(MOV(dst, src_reg(reg_d)));               emit(MUL(dst, src_reg(dst), src_reg(es3_normalize_factor)));               emit_minmax(BRW_CONDITIONAL_G, dst, src_reg(dst), src_reg(-1.0f));            } else {               /* The following equations are from the OpenGL 3.2 specification:                *                * 2.1 unsigned normalization                * f = c/(2^n-1)                *                * 2.2 signed normalization                * f = (2c+1)/(2^n-1)                *                * Both of these share a common divisor, which is represented by                * "normalize_factor" in the code below.                */               if (normalize_factor.file == BAD_FILE) {                  /* 1 / (2^b - 1) for b=<10,10,10,2> */                  normalize_factor = dst_reg(this, glsl_type::vec4_type);                  emit(MOV(writemask(normalize_factor, WRITEMASK_XYZ),                           src_reg(1.0f / ((1<<10) - 1))));                  emit(MOV(writemask(normalize_factor, WRITEMASK_W),                           src_reg(1.0f / ((1<<2) - 1))));               }               dst_reg dst = reg;               dst.type = brw_type_for_base_type(glsl_type::vec4_type);               emit(MOV(dst, src_reg((wa_flags & BRW_ATTRIB_WA_SIGN) ? reg_d : reg_ud)));               /* For signed normalization, we want the numerator to be 2c+1. */               if (wa_flags & BRW_ATTRIB_WA_SIGN) {                  emit(MUL(dst, src_reg(dst), src_reg(2.0f)));                  emit(ADD(dst, src_reg(dst), src_reg(1.0f)));               }//.........这里部分代码省略.........

/** Do inverse transform on 8x4 part of block*/static void vc1_inv_trans_8x4_altivec(uint8_t *dest, int stride, int16_t *block){    vector signed short src0, src1, src2, src3, src4, src5, src6, src7;    vector signed int s0, s1, s2, s3, s4, s5, s6, s7;    vector signed int s8, s9, sA, sB, sC, sD, sE, sF;    vector signed int t0, t1, t2, t3, t4, t5, t6, t7;    const vector signed int vec_64 = vec_sl(vec_splat_s32(4), vec_splat_u32(4));    const vector unsigned int vec_7 = vec_splat_u32(7);    const vector unsigned int vec_5 = vec_splat_u32(5);    const vector unsigned int vec_4 = vec_splat_u32(4);    const vector  signed int vec_4s = vec_splat_s32(4);    const vector unsigned int vec_3 = vec_splat_u32(3);    const vector unsigned int vec_2 = vec_splat_u32(2);    const vector unsigned int vec_1 = vec_splat_u32(1);    vector unsigned char tmp;    vector signed short tmp2, tmp3;    vector unsigned char perm0, perm1, p0, p1, p;    src0 = vec_ld(  0, block);    src1 = vec_ld( 16, block);    src2 = vec_ld( 32, block);    src3 = vec_ld( 48, block);    src4 = vec_ld( 64, block);    src5 = vec_ld( 80, block);    src6 = vec_ld( 96, block);    src7 = vec_ld(112, block);    TRANSPOSE8(src0, src1, src2, src3, src4, src5, src6, src7);    s0 = vec_unpackl(src0);    s1 = vec_unpackl(src1);    s2 = vec_unpackl(src2);    s3 = vec_unpackl(src3);    s4 = vec_unpackl(src4);    s5 = vec_unpackl(src5);    s6 = vec_unpackl(src6);    s7 = vec_unpackl(src7);    s8 = vec_unpackh(src0);    s9 = vec_unpackh(src1);    sA = vec_unpackh(src2);    sB = vec_unpackh(src3);    sC = vec_unpackh(src4);    sD = vec_unpackh(src5);    sE = vec_unpackh(src6);    sF = vec_unpackh(src7);    STEP8(s0, s1, s2, s3, s4, s5, s6, s7, vec_4s);    SHIFT_HOR8(s0, s1, s2, s3, s4, s5, s6, s7);    STEP8(s8, s9, sA, sB, sC, sD, sE, sF, vec_4s);    SHIFT_HOR8(s8, s9, sA, sB, sC, sD, sE, sF);    src0 = vec_pack(s8, s0);    src1 = vec_pack(s9, s1);    src2 = vec_pack(sA, s2);    src3 = vec_pack(sB, s3);    src4 = vec_pack(sC, s4);    src5 = vec_pack(sD, s5);    src6 = vec_pack(sE, s6);    src7 = vec_pack(sF, s7);    TRANSPOSE8(src0, src1, src2, src3, src4, src5, src6, src7);    s0 = vec_unpackh(src0);    s1 = vec_unpackh(src1);    s2 = vec_unpackh(src2);    s3 = vec_unpackh(src3);    s8 = vec_unpackl(src0);    s9 = vec_unpackl(src1);    sA = vec_unpackl(src2);    sB = vec_unpackl(src3);    STEP4(s0, s1, s2, s3, vec_64);    SHIFT_VERT4(s0, s1, s2, s3);    STEP4(s8, s9, sA, sB, vec_64);    SHIFT_VERT4(s8, s9, sA, sB);    src0 = vec_pack(s0, s8);    src1 = vec_pack(s1, s9);    src2 = vec_pack(s2, sA);    src3 = vec_pack(s3, sB);    p0 = vec_lvsl (0, dest);    p1 = vec_lvsl (stride, dest);    p = vec_splat_u8 (-1);    perm0 = vec_mergeh (p, p0);    perm1 = vec_mergeh (p, p1);#define ADD(dest,src,perm)                                              /    /* *(uint64_t *)&tmp = *(uint64_t *)dest; */                        /    tmp = vec_ld (0, dest);                                             /    tmp2 = (vector signed short)vec_perm (tmp, vec_splat_u8(0), perm);  /    tmp3 = vec_adds (tmp2, src);                                        /    tmp = vec_packsu (tmp3, tmp3);                                      /    vec_ste ((vector unsigned int)tmp, 0, (unsigned int *)dest);        /    vec_ste ((vector unsigned int)tmp, 4, (unsigned int *)dest);    ADD (dest, src0, perm0)      dest += stride;    ADD (dest, src1, perm1)      dest += stride;    ADD (dest, src2, perm0)      dest += stride;    ADD (dest, src3, perm1)}

void CObjectFactory::register_classes	(){#ifndef NO_XR_GAME	// client entities	add<CLevel>													(CLSID_GAME_LEVEL				,"level");	add<CGamePersistent>										(CLSID_GAME_PERSISTANT			,"game");	add<CHUDManager>											(CLSID_HUDMANAGER				,"hud_manager");	//Server Game type	add<game_sv_Single>											(CLSID_SV_GAME_SINGLE			,"game_sv_single");	add<game_sv_Deathmatch>										(CLSID_SV_GAME_DEATHMATCH		,"game_sv_deathmatch");	add<game_sv_TeamDeathmatch>									(CLSID_SV_GAME_TEAMDEATHMATCH	,"game_sv_team_deathmatch");	add<game_sv_ArtefactHunt>									(CLSID_SV_GAME_ARTEFACTHUNT		,"game_sv_artefact_hunt");	//Client Game type	add<game_cl_Single>											(CLSID_CL_GAME_SINGLE			,"game_cl_single");	add<game_cl_Deathmatch>										(CLSID_CL_GAME_DEATHMATCH		,"game_cl_deathmatch");	add<game_cl_TeamDeathmatch>									(CLSID_CL_GAME_TEAMDEATHMATCH	,"game_cl_team_deathmatch");	add<game_cl_ArtefactHunt>									(CLSID_CL_GAME_ARTEFACTHUNT		,"game_cl_artefact_hunt");	//Game UI type	add<CUIGameSP>												(CLSID_GAME_UI_SINGLE			,"game_ui_single");	add<CUIGameDM>												(CLSID_GAME_UI_DEATHMATCH		,"game_ui_deathmatch");	add<CUIGameTDM>												(CLSID_GAME_UI_TEAMDEATHMATCH	,"game_ui_team_deathmatch");	add<CUIGameAHunt>											(CLSID_GAME_UI_ARTEFACTHUNT		,"game_ui_artefact_hunt");#endif	// server entities	add<CSE_ALifeGroupTemplate<CSE_ALifeMonsterBase> >			(CLSID_AI_FLESH_GROUP			,"flesh_group");//	add<CSE_SpawnGroup>											(CLSID_AI_SPAWN_GROUP			,"spawn_group");	add<CSE_ALifeGraphPoint>									(CLSID_AI_GRAPH					,"graph_point");	add<CSE_ALifeOnlineOfflineGroup>							(CLSID_ONLINE_OFFLINE_GROUP		,"online_offline_group");		// client and server entities	ADD(CActor					,CSE_ALifeCreatureActor			,CLSID_OBJECT_ACTOR				,"actor");	ADD(CSpectator				,CSE_Spectator					,CLSID_SPECTATOR				,"spectator");	ADD(CAI_Flesh				,CSE_ALifeMonsterBase			,CLSID_AI_FLESH					,"flesh");	ADD(CChimera				,CSE_ALifeMonsterBase			,CLSID_AI_CHIMERA				,"chimera");	ADD(CAI_Dog					,CSE_ALifeMonsterBase			,CLSID_AI_DOG_RED				,"dog_red");	ADD(CAI_Stalker				,CSE_ALifeHumanStalker			,CLSID_AI_STALKER				,"stalker");	ADD(CAI_Bloodsucker			,CSE_ALifeMonsterBase			,CLSID_AI_BLOODSUCKER			,"bloodsucker");	ADD(CAI_Boar				,CSE_ALifeMonsterBase			,CLSID_AI_BOAR					,"boar");	ADD(CAI_PseudoDog			,CSE_ALifeMonsterBase			,CLSID_AI_DOG_BLACK				,"dog_black");	ADD(CPsyDog					,CSE_ALifeMonsterBase			,CLSID_AI_DOG_PSY				,"psy_dog");	ADD(CPsyDogPhantom			,CSE_ALifePsyDogPhantom			,CLSID_AI_DOG_PSY_PHANTOM		,"psy_dog_phantom");	ADD(CBurer					,CSE_ALifeMonsterBase			,CLSID_AI_BURER					,"burer");	ADD(CPseudoGigant			,CSE_ALifeMonsterBase			,CLSID_AI_GIANT					,"pseudo_gigant");	ADD(CController				,CSE_ALifeMonsterBase			,CLSID_AI_CONTROLLER			,"controller");	ADD(CPoltergeist			,CSE_ALifeMonsterBase			,CLSID_AI_POLTERGEIST			,"poltergeist");	ADD(CZombie					,CSE_ALifeMonsterBase			,CLSID_AI_ZOMBIE				,"zombie");	ADD(CFracture				,CSE_ALifeMonsterBase			,CLSID_AI_FRACTURE				,"fracture");	ADD(CSnork					,CSE_ALifeMonsterBase			,CLSID_AI_SNORK					,"snork");	ADD(CCat					,CSE_ALifeMonsterBase			,CLSID_AI_CAT					,"cat");	ADD(CTushkano				,CSE_ALifeMonsterBase			,CLSID_AI_TUSHKANO				,"tushkano");		ADD(CPhantom				,CSE_ALifeCreaturePhantom		,CLSID_AI_PHANTOM				,"phantom");	// Trader	ADD(CAI_Trader				,CSE_ALifeTrader				,CLSID_AI_TRADER				,"trader");	ADD(CAI_Crow				,CSE_ALifeCreatureCrow			,CLSID_AI_CROW					,"crow");	ADD(CCar					,CSE_ALifeCar					,CLSID_CAR						,"car");	ADD(CHelicopter				,CSE_ALifeHelicopter			,CLSID_VEHICLE_HELICOPTER		,"helicopter");	// Artefacts	ADD(CMercuryBall			,CSE_ALifeItemArtefact			,CLSID_AF_MERCURY_BALL			,"art_mercury_ball");	ADD(CBlackDrops				,CSE_ALifeItemArtefact			,CLSID_AF_BLACKDROPS			,"art_black_drops");	ADD(CBlackGraviArtefact		,CSE_ALifeItemArtefact			,CLSID_AF_NEEDLES				,"art_needles");	ADD(CBastArtefact			,CSE_ALifeItemArtefact			,CLSID_AF_BAST					,"art_bast_artefact");	ADD(CBlackGraviArtefact		,CSE_ALifeItemArtefact			,CLSID_AF_BLACK_GRAVI			,"art_gravi_black");	ADD(CDummyArtefact			,CSE_ALifeItemArtefact			,CLSID_AF_DUMMY					,"art_dummy");	ADD(CZudaArtefact			,CSE_ALifeItemArtefact			,CLSID_AF_ZUDA					,"art_zuda");	ADD(CThornArtefact			,CSE_ALifeItemArtefact			,CLSID_AF_THORN					,"art_thorn");	ADD(CFadedBall				,CSE_ALifeItemArtefact			,CLSID_AF_FADED_BALL			,"art_faded_ball");	ADD(CElectricBall			,CSE_ALifeItemArtefact			,CLSID_AF_ELECTRIC_BALL			,"art_electric_ball");	ADD(CRustyHairArtefact		,CSE_ALifeItemArtefact			,CLSID_AF_RUSTY_HAIR			,"art_rusty_hair");	ADD(CGalantineArtefact		,CSE_ALifeItemArtefact			,CLSID_AF_GALANTINE				,"art_galantine");	ADD(CGraviArtefact			,CSE_ALifeItemArtefact			,CLSID_AF_GRAVI					,"art_gravi");	ADD(CGraviArtefact			,CSE_ALifeItemArtefact			,CLSID_ARTEFACT					,"artefact");	//  [8/15/2006]	ADD(CWeaponMagazined		,CSE_ALifeItemWeaponMagazined	,CLSID_OBJECT_W_MAGAZINED		,"wpn_wmagaz");	//  [8/15/2006]	//  [8/17/2006]	ADD(CWeaponMagazinedWGrenade,CSE_ALifeItemWeaponMagazinedWGL,CLSID_OBJECT_W_MAGAZWGL		,"wpn_wmaggl");	//  [8/17/2006]	ADD(CWeaponFN2000			,CSE_ALifeItemWeaponMagazinedWGL	,CLSID_OBJECT_W_FN2000			,"wpn_fn2000");	ADD(CWeaponAK74				,CSE_ALifeItemWeaponMagazinedWGL	,CLSID_OBJECT_W_AK74			,"wpn_ak74");	ADD(CWeaponLR300			,CSE_ALifeItemWeaponMagazined	,CLSID_OBJECT_W_LR300			,"wpn_lr300");	ADD(CWeaponHPSA				,CSE_ALifeItemWeaponMagazined	,CLSID_OBJECT_W_HPSA			,"wpn_hpsa");	ADD(CWeaponPM				,CSE_ALifeItemWeaponMagazined	,CLSID_OBJECT_W_PM				,"wpn_pm");	ADD(CWeaponFORT				,CSE_ALifeItemWeaponMagazined	,CLSID_OBJECT_W_FORT			,"wpn_fort");	ADD(CWeaponBinoculars		,CSE_ALifeItemWeaponMagazined	,CLSID_OBJECT_W_BINOCULAR		,"wpn_binocular");	ADD(CWeaponShotgun			,CSE_ALifeItemWeaponShotGun		,CLSID_OBJECT_W_SHOTGUN			,"wpn_shotgun");	ADD(CWeaponSVD				,CSE_ALifeItemWeaponMagazined	,CLSID_OBJECT_W_SVD				,"wpn_svd");	ADD(CWeaponSVU				,CSE_ALifeItemWeaponMagazined	,CLSID_OBJECT_W_SVU				,"wpn_svu");	ADD(CWeaponRPG7				,CSE_ALifeItemWeaponMagazined	,CLSID_OBJECT_W_RPG7			,"wpn_rpg7");	ADD(CWeaponVal				,CSE_ALifeItemWeaponMagazined	,CLSID_OBJECT_W_VAL				,"wpn_val");//.........这里部分代码省略.........

/* compute intersection of two convex polyhedrons */TRI* cvi (double *va, int nva, double *pa, int npa, double *vb, int nvb, double *pb, int npb, CVIKIND kind, int *m, double **pv, int *nv){  double e [6], p [3], q [3], eps, d, *nl, *pt, *nn, *yy;  PFV *pfv, *v, *w, *z;  int i, j, k, n;  TRI *tri, *t;  /* initialize */  eps = GEOMETRIC_EPSILON;  tri = t = NULL;  pfv = NULL;  yy = NULL;  /* compute closest points */  d = gjk (va, nva, vb, nvb, p, q);  if (d > GEOMETRIC_EPSILON) { *m = 0; return NULL; }  /* push 'p' deeper inside only if regularized intersection is sought */  if (kind == REGULARIZED && !refine_point (pa, npa, pb, npb, p, &eps)) { *m = 0; return NULL; }  /* vertices extents for a later sanity check */  vertices_extents (va, nva, vb, nvb, eps, e);  /* translate base points of planes so that   * p = q = 0; compute new normals 'yy' */  ERRMEM (yy = malloc (sizeof (double [3]) * (npa+npb)));  for (i = 0, nl = pa, pt = pa + 3, nn = yy;       i < npa; i ++, nl += 6, pt += 6, nn += 3)  {    SUB (pt, p, q); /* q => translated point of current plane */    d = - DOT (nl, q); /* d => zero offset */    if (d > -GEOMETRIC_EPSILON) d = -eps; /* regularisation (tiny swelling) */    DIV (nl, -d, nn);  /* <nn, x> <= 1 (yy stores vertices of polar polygon) */  }  for (i = 0, nl = pb, pt = pb + 3; i < npb;       i ++, nl += 6, pt += 6, nn += 3)  {    SUB (pt, p, q);    d = - DOT (nl, q);    if (d > -GEOMETRIC_EPSILON) d = -eps; /* regularisation (tiny swelling) */    DIV (nl, -d, nn);  }  /* compute and polarise convex   * hull of new normals 'yy' */  if (!(tri = hull (yy, npa+npb, &i))) goto error; /* tri = cv (polar (a) U polar (b)) */  if (!(pfv = TRI_Polarise (tri, i, &j))) goto error; /* pfv = polar (tri) => pfv = a * b */  /* normals in 'pfv' point to 'yy'; triangulate   * polar faces and set 'a' or 'b' flags */  /* count all face vertices */  for (k = n = 0; k < j; k ++)  {    v = &pfv [k]; n ++;    for (w = v->n; w != v; w = w->n) n ++;  }  /* there is (number of face vertices - 2) triangles per face,   * hence there is n - j * 2 triangles in total; vertex   * memory in 'pfv' is placed after n PFV items */#if GEOMDEBUG  ASSERT_DEBUG (n - j*2 > 3, "Inconsitent polar faces => too few vertices in some faces");#else  if (n - j*2 <= 3) goto error;#endif  ERRMEM (tri = realloc (tri, sizeof (TRI) * (n-j*2) + sizeof (double [3]) * i)); /* allocate space for triangles and vertices */  pt = (double*) (tri + (n - j*2)); /* this is where output vertices begin */  nn = (double*) (pfv + n); /* this is where coords begin in 'pfv' block */  memcpy (pt, nn, sizeof (double [3]) * i); /* copy vertex data */  if (pv) *pv = pt;  if (nv) *nv = i;  /* shift point coords to the old 'zero' */  for (k = 0, nl = pt; k < i; k ++, nl += 3)  {     ADD (nl, p, nl); /* 'nl' used as a point */    if (nl[0] < e [0] || nl[1] < e [1] || nl[2] < e [2] ||	nl[0] > e [3] || nl[1] > e [4] || nl[2] > e [5])    {#if GEOMDEBUG      printf ("CVI HAS GONE INSANE FOR THE INPUT:/n"), dump_input (va, nva, pa, npa, vb, nvb, pb, npb);#endif      goto error;    }  }  for (k = 0, t = tri; k < j; k ++)  {    v = &pfv [k]; /* fixed vertex 'v' */    for (w = v->n, z = w->n; z != v; w = w->n, z = z->n, t ++) /* remaining vertices 'w' & 'z' */    {      COPY (v->nl, t->out); /* copy normal */      NORMALIZE (t->out);      t->ver [0] = pt + (v->coord - nn); /* map vertices */      t->ver [1] = pt + (w->coord - nn);      t->ver [2] = pt + (z->coord - nn);      t->flg = ((v->nl - yy) / 3) + 1; /* first 'npa' entries in 'yy' come from 'a' => positive 1-based index in 'a' */      if (t->flg > npa) t->flg = -(t->flg - npa); /* last 'npb' ones come from 'b' => negative 1-based index in 'b' *///.........这里部分代码省略.........

void dec_10i40_35bits (    INT16 index[],    /* (i)     : index of 10 pulses (sign+position)       */    INT16 cod[]       /* (o)     : algebraic (fixed) codebook excitation    */){    static const INT16 dgray[8] = {0, 1, 3, 2, 5, 6, 4, 7};    INT16 i, j, pos1, pos2, sign, tmp;    VPP_EFR_PROFILE_FUNCTION_ENTER(dec_10i40_35bits);    for (i = 0; i < L_CODE; i++)    {        cod[i] = 0;    }    /* decode the positions and signs of pulses and build the codeword */    for (j = 0; j < NB_TRACK; j++)    {        /* compute index i */        tmp = index[j];        i = tmp & 7;        i = dgray[i];        //i = extract_l (L_shr (L_mult (i, 5), 1));        i = EXTRACT_L (L_SHR_D(L_MULT (i, 5), 1));		//pos1 = add(i, j); /* position of pulse "j" */        pos1 = ADD(i, j);        //i = shr (tmp, 3) & 1;		i = SHR_D(tmp, 3) & 1;        if (i == 0)        {            sign = 4096;        }        else        {            sign = -4096;        }        cod[pos1] = sign;        /* compute index i */        //i = index[add(j, 5)] & 7;		i = index[ADD(j, 5)] & 7;		i = dgray[i];        //i = extract_l (L_shr (L_mult (i, 5), 1));        i = EXTRACT_L (L_SHR_D(L_MULT(i, 5), 1));        //pos2 = add(i, j);      /* position of pulse "j+5" */        pos2 = ADD(i, j);        //if (sub (pos2, pos1) < 0)		if (SUB (pos2, pos1) < 0)        {           // sign = negate (sign);			sign = NEGATE(sign);        }		//cod[pos2] = add(cod[pos2], sign);		cod[pos2] = ADD(cod[pos2], sign);    }    VPP_EFR_PROFILE_FUNCTION_EXIT(dec_10i40_35bits);    return;}