void parse_region(FILE *fp, World *w) { char texture_name[STRING_TOKEN_MAX_LENGTH]; int texture_index; Region r; if (get_real_token(fp, &r.floor) != Token_real) parse_error("number expected"); if (get_real_token(fp, &r.ceiling) != Token_real) parse_error("number expected"); /* floor texture */ if (get_string_token(fp, texture_name) != Token_string) parse_error("texture name expected"); texture_index = get_texture_index(texture_name); if (texture_index < 0 || texture_index > TABLE_SIZE(w->textures)) parse_error("non-existent texture"); else r.floor_tex = WORLD_TEXTURE(w, texture_index); /* ceiling texture */ if (get_string_token(fp, texture_name) != Token_string) parse_error("texture name expected"); if (strcmp(texture_name, "sky") == 0) r.ceiling_tex = NULL; else { texture_index = get_texture_index(texture_name); if (texture_index < 0 || texture_index > TABLE_SIZE(w->textures)) parse_error("non-existent texture"); else r.ceiling_tex = WORLD_TEXTURE(w, texture_index); } add_region(w, &r); }
void update_wall_scale(World *w, int wall_num, fixed xscale, fixed yscale) { Wall *wall; Texture *texture; fixed wall_length; if (wall_num < 0 || wall_num > TABLE_SIZE(w->walls)) fatal_error("invalid wall number"); wall = (Wall *) w->walls->table + wall_num; texture = wall->surface_texture; wall_length = FLOAT_TO_FIXED(sqrt(FIXED_TO_FLOAT(wall->vertex2->x - wall->vertex1->x) * FIXED_TO_FLOAT(wall->vertex2->x - wall->vertex1->x) + FIXED_TO_FLOAT(wall->vertex2->y - wall->vertex1->y) * FIXED_TO_FLOAT(wall->vertex2->y - wall->vertex1->y))); wall->yscale = fixmul(yscale, INT_TO_FIXED(texture->height)); wall->xscale = fixmul(fixmul(xscale, INT_TO_FIXED(texture->width)), wall_length); }
void parse_texture(FILE *fp, World *w) { char texture_name[STRING_TOKEN_MAX_LENGTH]; char filename[STRING_TOKEN_MAX_LENGTH]; char texture_path[PATH_MAX + STRING_TOKEN_MAX_LENGTH]; Texture *t; Texture_node *tn; if (get_string_token(fp, texture_name) != Token_string) parse_error("texture name expected"); if (strlen(texture_name) >= TEXTURE_NAME_MAX_LENGTH) parse_error("texture name too long"); if (get_string_token(fp, filename) != Token_string) parse_error("texture file name expected"); #ifdef WIN32 sprintf(texture_path, "%s%s/%s", szWTpath, TEXTURE_PATH, filename); #else sprintf(texture_path, "%s/%s", TEXTURE_PATH, filename); #endif t = read_texture_file(texture_path); tn = wtmalloc(sizeof(Texture_node)); strcpy(tn->name, texture_name); tn->index = TABLE_SIZE(w->textures); add_node(texture_list, tn); add_texture(w, t); }
/* * Wrapper functions for all standard and private IOCTL functions */ static int ath_iw_wrapper_handler(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { struct ath_softc_net80211 *scn = ath_netdev_priv(dev); int cmd_id; iw_handler handler; /* reject ioctls */ if ((!scn) || (scn && scn->sc_htc_delete_in_progress)){ printk("%s : #### delete is in progress, scn %p \n", __func__, scn); return -EINVAL; } /* private ioctls */ if (info->cmd >= SIOCIWFIRSTPRIV) { cmd_id = (info->cmd - SIOCIWFIRSTPRIV); if (cmd_id < 0 || cmd_id >= TABLE_SIZE(ath_iw_priv_handlers)) { printk("%s : #### wrong private ioctl 0x%x\n", __func__, info->cmd); return -EINVAL; } handler = ath_iw_priv_handlers[cmd_id]; if (handler) return handler(dev, info, wrqu, extra); printk("%s : #### no registered private ioctl function for cmd 0x%x\n", __func__, info->cmd); } printk("%s : #### unknown command 0x%x\n", __func__, info->cmd); return -EINVAL; }
int getFormatIdByString(char* str) { int i; for(i = 0; i < TABLE_SIZE(g_format); i++) { if(strncmp(str, g_format[i], 4) == 0) { return i; } } return 0; }
void cmu_bdd_init_cache(cmu_bdd_manager bddm) { long i; int j; bddm->op_cache.size_index=13; bddm->op_cache.size=TABLE_SIZE(bddm->op_cache.size_index); bddm->op_cache.table=(cache_bin *)mem_get_block((SIZE_T)(bddm->op_cache.size*sizeof(cache_bin))); for (i=0; i < bddm->op_cache.size; ++i) for (j=0; j < 2; ++j) bddm->op_cache.table[i].entry[j]=0; /* ITE cache control functions. */ bddm->op_cache.rehash_fn[CACHE_TYPE_ITE]=bdd_rehash3; bddm->op_cache.gc_fn[CACHE_TYPE_ITE]=cmu_bdd_ite_gc_fn; bddm->op_cache.purge_fn[CACHE_TYPE_ITE]=0; bddm->op_cache.return_fn[CACHE_TYPE_ITE]=RETURN_BDD_FN; bddm->op_cache.flush_fn[CACHE_TYPE_ITE]=0; /* Two argument op cache control functions. */ bddm->op_cache.rehash_fn[CACHE_TYPE_TWO]=bdd_rehash3; bddm->op_cache.gc_fn[CACHE_TYPE_TWO]=bdd_two_gc_fn; bddm->op_cache.purge_fn[CACHE_TYPE_TWO]=0; bddm->op_cache.return_fn[CACHE_TYPE_TWO]=RETURN_BDD_FN; bddm->op_cache.flush_fn[CACHE_TYPE_TWO]=bdd_two_flush_fn; /* One argument op w/ data result cache control functions. */ bddm->op_cache.rehash_fn[CACHE_TYPE_ONEDATA]=bdd_rehash2; bddm->op_cache.gc_fn[CACHE_TYPE_ONEDATA]=cmu_bdd_one_data_gc_fn; bddm->op_cache.purge_fn[CACHE_TYPE_ONEDATA]=0; bddm->op_cache.return_fn[CACHE_TYPE_ONEDATA]=0; bddm->op_cache.flush_fn[CACHE_TYPE_ONEDATA]=0; /* Two argument op w/ data result cache control functions. */ bddm->op_cache.rehash_fn[CACHE_TYPE_TWODATA]=bdd_rehash3; bddm->op_cache.gc_fn[CACHE_TYPE_TWODATA]=bdd_two_data_gc_fn; bddm->op_cache.purge_fn[CACHE_TYPE_TWODATA]=0; bddm->op_cache.return_fn[CACHE_TYPE_TWODATA]=0; bddm->op_cache.flush_fn[CACHE_TYPE_TWODATA]=0; /* User-defined cache control functions. */ for (j=CACHE_TYPE_USER1; j < CACHE_TYPE_USER1+USER_ENTRY_TYPES; ++j) { bddm->op_cache.rehash_fn[j]=0; bddm->op_cache.gc_fn[j]=0; bddm->op_cache.purge_fn[j]=0; bddm->op_cache.return_fn[j]=0; bddm->op_cache.flush_fn[j]=0; } bddm->op_cache.cache_ratio=4; bddm->op_cache.cache_level=0; bddm->op_cache.entries=0; bddm->op_cache.lookups=0; bddm->op_cache.hits=0; bddm->op_cache.inserts=0; bddm->op_cache.collisions=0; }
void update_wall_phase(World *w, int wall_num, fixed xphase, fixed yphase) { Wall *wall; if (wall_num < 0 || wall_num > TABLE_SIZE(w->walls)) fatal_error("invalid wall number"); wall = (Wall *) w->walls->table + wall_num; wall->xphase = xphase; wall->yphase = yphase; }
void ath_iw_attach(struct net_device *dev) { #ifdef ATH_SUPPORT_HTC int index; /* initialize handler array */ for(index = 0; index < TABLE_SIZE(ath_iw_priv_wrapper_handlers); index++) { if(ath_iw_priv_handlers[index]) ath_iw_priv_wrapper_handlers[index] = ath_iw_wrapper_handler; else ath_iw_priv_wrapper_handlers[index] = NULL; } #endif dev->wireless_handlers = &ath_iw_handler_def; }
void bdd_rehash_cache(cmu_bdd_manager bddm, int grow) { long i; long hash; int j; long oldsize; cache_bin *newtable; cache_entry *bin; cache_entry *newbin; cache_entry p; cache_entry q; oldsize=bddm->op_cache.size; if (grow) bddm->op_cache.size_index++; else bddm->op_cache.size_index--; bddm->op_cache.size=TABLE_SIZE(bddm->op_cache.size_index); newtable=(cache_bin *)mem_get_block((SIZE_T)(bddm->op_cache.size*sizeof(struct cache_bin_))); for (i=0; i < bddm->op_cache.size; ++i) for (j=0; j < 2; ++j) newtable[i].entry[j]=0; /* Rehash LRU first. */ for (j=1; j >= 0; --j) for (i=0; i < oldsize; ++i) { bin=bddm->op_cache.table[i].entry; if ((p=bin[j])) { q=CACHE_POINTER(p); hash=(*bddm->op_cache.rehash_fn[TAG(p)])(bddm, q); BDD_REDUCE(hash, bddm->op_cache.size); newbin=newtable[hash].entry; bdd_purge_lru(bddm, newbin); newbin[0]=p; } } mem_free_block((pointer)(bddm->op_cache.table)); bddm->op_cache.table=newtable; }
/* AUTELAN-Added-Begin : &tuqiang */ (iw_handler) ath_openessid_setblacklist, /* SIOCWFIRSTPRIV+6 */ (iw_handler) ath_openessid_distroyblacklist, /* SIOCWFIRSTPRIV+7 */ (iw_handler) ath_openessid_setwhitelist, /* SIOCWFIRSTPRIV+8 */ (iw_handler) ath_openessid_distroywhitelist, /* SIOCWFIRSTPRIV+9 */ /* AUTELAN-Added-End : [email protected] */ }; /* ** Wireless Handler Structure ** This table provides the Wireless tools the interface required to access ** parameters in the HAL. Each sub table contains the definition of various ** control tables that reference functions this module */ #ifdef ATH_SUPPORT_HTC static iw_handler ath_iw_priv_wrapper_handlers[TABLE_SIZE(ath_iw_priv_handlers)]; static struct iw_handler_def ath_iw_handler_def = { .standard = (iw_handler *) NULL, .num_standard = 0, .private = (iw_handler *) ath_iw_priv_wrapper_handlers, .num_private = TABLE_SIZE(ath_iw_priv_wrapper_handlers), .private_args = (struct iw_priv_args *) ath_iw_priv_args, .num_private_args = TABLE_SIZE(ath_iw_priv_args), .get_wireless_stats = NULL, }; #else static struct iw_handler_def ath_iw_handler_def = { .standard = (iw_handler *) NULL, .num_standard = 0, .private = (iw_handler *) ath_iw_priv_handlers,
{ "stw", OP_IDO5, "01011rrrrrriiiii", 2, 0x5800, 2, 2, CHG_NONE, ALL}, { "stw", OP_IDR, "01111rrrrrrrrrrr", 2, 0x7800, 2, 2, CHG_NONE, ALL}, { "sub", OP_TRI, "00011rrrrrrrrr00", 2, 0x1800, 1, 1, CHG_NZVC, ALL}, { "subh", OP_IMM8, "11001rrriiiiiiii", 2, 0xC800, 1, 1, CHG_NZVC, ALL}, { "subl", OP_IMM8, "11000rrriiiiiiii", 2, 0xC000, 1, 1, CHG_NZVC, ALL}, { "tfr", OP_MON_R_C, "00000rrr11111000", 2, 0x00F8, 1, 1, CHG_NONE, ALL}, { "tfr", OP_MON_C_R, "00000rrr11111001", 2, 0x00F9, 1, 1, CHG_NONE, ALL}, { "tfr", OP_MON_R_P, "00000rrr11111010", 2, 0x00FA, 1, 1, CHG_NONE, ALL}, { "xnor", OP_TRI, "00010rrrrrrrrr11", 2, 0x1003, 1, 1, CHG_NZV, ALL}, { "xnorh", OP_IMM8, "10111rrriiiiiiii", 2, 0xB800, 1, 1, CHG_NZV, ALL}, { "xnorl", OP_IMM8, "10110rrriiiiiiii", 2, 0xB000, 1, 1, CHG_NZV, ALL}, /* macro and alias codes */ { "add", OP_mADD, "----------------", 4, 0, 0, 0, CHG_NONE, ALL}, { "and", OP_mAND, "----------------", 4, 0, 0, 0, CHG_NONE, ALL}, { "bhs", OP_REL9, "0010000iiiiiiiii", 2, 0x2000, 0, 0, CHG_NONE, ALL}, { "blo", OP_REL9, "0010001iiiiiiiii", 2, 0x2200, 0, 0, CHG_NONE, ALL}, { "cmp", OP_mCPC, "----------------", 4, 0, 0, 0, CHG_NONE, ALL}, { "cmp", OP_DYA, "00011sssrrrrrr00", 2, 0x1800, 0, 0, CHG_NZVC, ALL}, { "com", OP_DM, "00010rrrsssrrr11", 2, 0x1003, 0, 0, CHG_NZVC, ALL}, { "com", OP_DYA, "00010rrrsssrrr11", 2, 0x1003, 0, 0, CHG_NZV, ALL}, { "cpc", OP_DYA, "00011sssrrrrrr01", 2, 0x1801, 0, 0, CHG_NZVC, ALL}, { "ldd", OP_mLDW, "----------------", 4, 0, 0, 0, CHG_NONE, ALL}, { "ldw", OP_mLDW, "----------------", 4, 0, 0, 0, CHG_NONE, ALL}, { "mov", OP_DYA, "00010rrrsssrrr10", 2, 0x1002, 0, 0, CHG_NZVC, ALL}, { "neg", OP_DYA, "00011rrrsssrrr00", 2, 0x1800, 0, 0, CHG_NZVC, ALL}, { "sub", OP_mSUB, "----------------", 4, 0, 0, 0, CHG_NONE, ALL}, { "tst", OP_MON, "00011sssrrrsss00", 2, 0x1800, 0, 0, CHG_NZV, ALL} }; const int xgate_num_opcodes = TABLE_SIZE (xgate_opcodes);
{ "movwf", 0xfe0, 0x020, INSN_CLASS_OPF5 }, { "nop", 0xfff, 0x000, INSN_CLASS_IMPLICIT }, { "option", 0xfff, 0x002, INSN_CLASS_IMPLICIT }, { "retlw", 0xf00, 0x800, INSN_CLASS_LIT8 }, { "return", 0xfff, 0x800, INSN_CLASS_IMPLICIT }, /* FIXME: special mnemonic */ { "rlf", 0xfc0, 0x340, INSN_CLASS_OPWF5 }, { "rrf", 0xfc0, 0x300, INSN_CLASS_OPWF5 }, { "sleep", 0xfff, 0x003, INSN_CLASS_IMPLICIT }, { "subwf", 0xfc0, 0x080, INSN_CLASS_OPWF5 }, { "swapf", 0xfc0, 0x380, INSN_CLASS_OPWF5 }, { "tris", 0xff8, 0x000, INSN_CLASS_OPF5 }, { "xorlw", 0xf00, 0xf00, INSN_CLASS_LIT8 }, { "xorwf", 0xfc0, 0x180, INSN_CLASS_OPWF5 } }; const int num_op_12c5xx = TABLE_SIZE(op_12c5xx); /* Scenix SX has a superset of the PIC 12-bit instruction set */ /* * It would be nice if there was a more elegant way to do this, * either by adding a flags field to struct insn, or by allowing a * processor to have more than one associated table. */ const struct insn op_sx[] = { { "addwf", 0xfc0, 0x1c0, INSN_CLASS_OPWF5 }, { "andlw", 0xf00, 0xe00, INSN_CLASS_LIT8 }, { "andwf", 0xfc0, 0x140, INSN_CLASS_OPWF5 }, { "bank", 0xff8, 0x018, INSN_CLASS_LIT3_BANK }, /* SX only */ { "bcf", 0xf00, 0x400, INSN_CLASS_B5 }, { "bsf", 0xf00, 0x500, INSN_CLASS_B5 }, { "btfsc", 0xf00, 0x600, INSN_CLASS_B5 },
{ "b", 0, (long int)do_b, INSN_CLASS_FUNC, 0 }, { "bc", 0, (long int)do_bc, INSN_CLASS_FUNC, 0 }, { "bdc", 0, (long int)do_bdc, INSN_CLASS_FUNC, 0 }, { "bz", 0, (long int)do_bz, INSN_CLASS_FUNC, 0 }, { "bnc", 0, (long int)do_bnc, INSN_CLASS_FUNC, 0 }, { "bndc", 0, (long int)do_bndc, INSN_CLASS_FUNC, 0 }, { "bnz", 0, (long int)do_bnz, INSN_CLASS_FUNC, 0 }, { "clrc", 0, (long int)do_clrc, INSN_CLASS_FUNC, 0 }, { "clrdc", 0, (long int)do_clrdc, INSN_CLASS_FUNC, 0 }, { "clrz", 0, (long int)do_clrz, INSN_CLASS_FUNC, 0 }, { "lcall", 0, (long int)do_lcall, INSN_CLASS_FUNC, 0 }, { "lgoto", 0, (long int)do_lgoto, INSN_CLASS_FUNC, 0 }, { "movfw", 0, (long int)do_movfw, INSN_CLASS_FUNC, 0 }, { "negf", 0, (long int)do_negf, INSN_CLASS_FUNC, 0 }, { "setc", 0, (long int)do_setc, INSN_CLASS_FUNC, 0 }, { "setdc", 0, (long int)do_setdc, INSN_CLASS_FUNC, 0 }, { "setz", 0, (long int)do_setz, INSN_CLASS_FUNC, 0 }, { "skpc", 0, (long int)do_skpc, INSN_CLASS_FUNC, 0 }, { "skpdc", 0, (long int)do_skpdc, INSN_CLASS_FUNC, 0 }, { "skpz", 0, (long int)do_skpz, INSN_CLASS_FUNC, 0 }, { "skpnc", 0, (long int)do_skpnc, INSN_CLASS_FUNC, 0 }, { "skpndc", 0, (long int)do_skpndc, INSN_CLASS_FUNC, 0 }, { "skpnz", 0, (long int)do_skpnz, INSN_CLASS_FUNC, 0 }, { "subcf", 0, (long int)do_subcf, INSN_CLASS_FUNC, 0 }, { "subdcf", 0, (long int)do_subdcf, INSN_CLASS_FUNC, 0 }, { "tstf", 0, (long int)do_tstf, INSN_CLASS_FUNC, 0 } }; const int num_op_special = TABLE_SIZE(special);
// Req. scancode, Capture scancode, Req. keycode, Capture keycode #ifndef KEYROUTER_TEST // On devices with a combined Power and End key, that key produces a // PowerOff code. Map capture requests for the End key to PowerOff. // At routing time, an End key event will automatically be delivered // to the capturing application. { EStdKeyPhoneEnd, EStdKeyPowerOff, EKeyPhoneEnd, EKeyPowerOff } #else // Entry for TEvent test case GRAPHICS-WSERV-0751. // Capture requests for psuedo key Device0 are mapped to capture // the real key Device1. { EStdKeyDevice0, EStdKeyDevice1, EKeyDevice0, EKeyDevice1 } #endif }; const TInt KNumTranslations = TABLE_SIZE(KTranslations); #endif // defined(KEYROUTER_TEST) || defined(COMBINED_POWER_END_KEY) /** Restricted Key Table The following keys may be captured only by the specified applications. More than one application may be listed for a given key-type combination. */ const TRestrictedKeyEntry KRestrictedKeys[] = { #ifndef KEYROUTER_TEST // Short Apps key events may only be captured by HomeScreen, SysApp, // AutoLock, Phone and AknCapServer. { EStdKeyApplication, ECaptureTypeKeyUpDown, KUidHomeScreen }, { EKeyApplication, ECaptureTypeKey, KUidHomeScreen },
void parse_wall(FILE *fp, World *w) { Wall wall; char texture_name[STRING_TOKEN_MAX_LENGTH]; int texture_index; int front_region, back_region; int vertex1, vertex2; fixed wall_length; /* vertices */ if (get_integer_token(fp, &vertex1) != Token_integer) parse_error("integer expected"); if (get_integer_token(fp, &vertex2) != Token_integer) parse_error("integer expected"); if (vertex1 < 0 || vertex1 > TABLE_SIZE(w->vertices)) parse_error("invalid vertex number"); if (vertex2 < 0 || vertex2 > TABLE_SIZE(w->vertices)) parse_error("invalid vertex number"); wall.vertex1 = &WORLD_VERTEX(w, vertex1); wall.vertex2 = &WORLD_VERTEX(w, vertex2); /* texture */ if (get_string_token(fp, texture_name) != Token_string) parse_error("texture name expected"); texture_index = get_texture_index(texture_name); if (texture_index < 0 || texture_index > TABLE_SIZE(w->textures)) parse_error("non-existent texture"); else wall.surface_texture = WORLD_TEXTURE(w, texture_index); if (strcmp(texture_name, "sky") == 0) wall.sky = True; else wall.sky = False; /* front and back regions */ if (get_integer_token(fp, &front_region) != Token_integer) fatal_error("non-existent region"); if (get_integer_token(fp, &back_region) != Token_integer) fatal_error("non-existent region"); if (front_region < 0 || front_region > TABLE_SIZE(w->regions)) fatal_error("non-existent region"); if (back_region < 0 || back_region > TABLE_SIZE(w->regions)) fatal_error("non-existent region"); wall.front = &WORLD_REGION(w, front_region); wall.back = &WORLD_REGION(w, back_region); /* Texture phase and scale. This code is somewhat more complicated than ** you'd expect, since the texture scale must be normalized to the ** wall length. */ if (get_real_token(fp, &wall.xscale) != Token_real) parse_error("number expected"); if (get_real_token(fp, &wall.yscale) != Token_real) parse_error("number expected"); if (get_real_token(fp, &wall.xphase) != Token_real) parse_error("number expected"); if (get_real_token(fp, &wall.yphase) != Token_real) parse_error("number expected"); wall_length = FLOAT_TO_FIXED(sqrt(FIXED_TO_FLOAT(wall.vertex2->x - wall.vertex1->x) * FIXED_TO_FLOAT(wall.vertex2->x - wall.vertex1->x) + FIXED_TO_FLOAT(wall.vertex2->y - wall.vertex1->y) * FIXED_TO_FLOAT(wall.vertex2->y - wall.vertex1->y))); wall.yscale = fixmul(wall.yscale, INT_TO_FIXED(wall.surface_texture->height)); wall.xscale = fixmul(fixmul(wall.xscale, INT_TO_FIXED(wall.surface_texture->width)), wall_length); add_wall(w, &wall); }
{ "movwf", 0xfe0, 0x020, INSN_CLASS_OPF5 }, { "nop", 0xfff, 0x000, INSN_CLASS_IMPLICIT }, { "option", 0xfff, 0x002, INSN_CLASS_IMPLICIT }, { "retlw", 0xf00, 0x800, INSN_CLASS_LIT8 }, { "return", 0xfff, 0x800, INSN_CLASS_IMPLICIT }, /* FIXME: special mnemonic */ { "rlf", 0xfc0, 0x340, INSN_CLASS_OPWF5 }, { "rrf", 0xfc0, 0x300, INSN_CLASS_OPWF5 }, { "sleep", 0xfff, 0x003, INSN_CLASS_IMPLICIT }, { "subwf", 0xfc0, 0x080, INSN_CLASS_OPWF5 }, { "swapf", 0xfc0, 0x380, INSN_CLASS_OPWF5 }, { "tris", 0xff8, 0x000, INSN_CLASS_OPF5 }, { "xorlw", 0xf00, 0xf00, INSN_CLASS_LIT8 }, { "xorwf", 0xfc0, 0x180, INSN_CLASS_OPWF5 } }; const int num_op_12c5xx = TABLE_SIZE(op_12c5xx); /* Scenix SX has a superset of the PIC 12-bit instruction set */ /* * It would be nice if there was a more elegant way to do this, * either by adding a flags field to struct insn, or by allowing a * processor to have more than one associated table. */ struct insn op_sx[] = { { "addwf", 0xfc0, 0x1c0, INSN_CLASS_OPWF5 }, { "andlw", 0xf00, 0xe00, INSN_CLASS_LIT8 }, { "andwf", 0xfc0, 0x140, INSN_CLASS_OPWF5 }, { "bank", 0xff8, 0x018, INSN_CLASS_LIT3_BANK }, /* SX only */ { "bcf", 0xf00, 0x400, INSN_CLASS_B5 }, { "bsf", 0xf00, 0x500, INSN_CLASS_B5 }, { "btfsc", 0xf00, 0x600, INSN_CLASS_B5 },
PE_UNINITIALIZED, "PE has not been initialized yet" }, { PE_UNKNOWN, "I have no information about PE" }, { PE_RUNNING, "PE is running" }, { PE_SHUTDOWN, "PE has been cleanly shut down" }, { PE_FAILED, "PE has failed" }, }; static const int nd = TABLE_SIZE (d); /** * translate PE status to human description */ const char * __shmem_state_as_string (pe_status_t s) { struct state_desc *dp = d; int i; for (i = 0; i < nd; i += 1) { if (s == dp->s)
int checkwalls( World *w, View *v ) { extern fixed view_height; Wall *wall = (Wall *) w->walls->table, *mem_wall; double x1, y1, tmp, min = 512.0; int i; x1 = FIXED_TO_FLOAT(v->x); y1 = FIXED_TO_FLOAT(v->y); if ( x1 == x && y1 == y ) return DONT_INTERSECT; for (i = 0; i < TABLE_SIZE(w->walls); i++, wall++ ) { /* Check Distance */ tmp = LineDistance( x1, y1, FIXED_TO_FLOAT(wall->vertex1->x ), FIXED_TO_FLOAT(wall->vertex1->y ), FIXED_TO_FLOAT(wall->vertex2->x ), FIXED_TO_FLOAT(wall->vertex2->y ) ); if ( fabs(tmp) < fabs( min ) ) { min = tmp; mem_wall = wall; } } /* is there any point in checking further. */ if ( fabs( min ) < VECTOR_LEN ) { /* start examine the wall */ fixed ceiling, floor; /* Check the outher side of the object */ if ( min > 0.0 ) { floor = mem_wall->front->floor; ceiling = mem_wall->front->ceiling; } else { floor = mem_wall->back->floor; ceiling = mem_wall->back->ceiling; } /* if the stair is less than FIXED_ONE_QUARTER and the head has goes free and there are enought room. */ if ( FIXED_ONE_QUARTER >= (floor-v->height) && ( ceiling > v->height ) && ( MAN_SIZE <= (ceiling-floor) ) ) { if ( s_wall != mem_wall || ( min > 0.0 && side <= 0.0 ) || (min <= 0.0 && side > 0.0 ) ) { if ( min < 0.0 ) view_height = mem_wall->front->floor+MAN_SIZE; else view_height = mem_wall->back->floor+MAN_SIZE; s_wall = mem_wall; } } else /* am i running towards the wall? */ if ( fabs( min ) < fabs( side ) ) { s_wall = mem_wall; slide_wall( &x, &y, x1, y1, side, min ); v->x = FLOAT_TO_FIXED( x ); v->y = FLOAT_TO_FIXED( y ); return 0; } } side = min; x = x1; y = y1; return 0; }