/* * Reset USB Device Endpoint * Parameters: EPNum: Device Endpoint Number * EPNum.0..3: Address * EPNum.7: Dir * Return Value: None */ void USBD_ResetEP (U32 EPNum) { ep_buffer_t *desc = get_desc(EPNum); EPNum &= EPNUM_MASK; MXC_USB->ep[EPNum] |= MXC_F_USB_EP_DT; if (ep_info[EPNum].type == MXC_S_USB_EP_DIR_OUT) { // This is an OUT endpoint. Go ahead and register a request. desc = get_desc(EPNum); desc->buf0_address = (uint32_t)ep_buffer[EPNum]; desc->buf0_desc = sizeof(ep_buffer[EPNum]); MXC_USB->out_owner = (1 << EPNum); } }
D* mad_desc_newk(int nv, const ord_t var_ords[nv], const ord_t map_ords_[nv], str_t var_nam_[nv], int nk, const ord_t knb_ords[nk], ord_t dk) { // input validation ensure(nv && var_ords); // ensure(nk && knb_ords); ensure(dk <= mad_mono_ord(nk,knb_ords)); ensure(mad_mono_ord(nv,var_ords) + mad_mono_ord(nk,knb_ords) < desc_max_order); ord_t map_ords[nv]; // to parse optional param if (map_ords_) { for (int i = 0; i < nv; ++i) ensure(var_ords[i] <= map_ords_[i]); mad_mono_copy(nv,map_ords_,map_ords); } else { ord_t mo = mad_mono_max(nv,var_ords); mad_mono_fill(nv,map_ords,mo); } if (dk == 0) dk = mad_mono_max(nk,knb_ords); ensure(dk <= mad_mono_max(nv,map_ords)); ord_t ords[nv+nk]; int oidx = 0; for (int i = 0; i < nv; ++i) ords[oidx++] = var_ords[i]; for (int i = 0; i < nk; ++i) { ensure(knb_ords[i] != 0); ords[oidx++] = knb_ords[i]; } return get_desc(nv,map_ords,var_nam_, nv+nk,ords, dk); }
int blk_list_part(enum if_type if_type) { struct blk_driver *drv; struct blk_desc *desc; int devnum, ok; bool first = true; drv = blk_driver_lookup_type(if_type); if (!drv) return -ENOSYS; for (ok = 0, devnum = 0; devnum < drv->max_devs; ++devnum) { if (get_desc(drv, devnum, &desc)) continue; if (desc->part_type != PART_TYPE_UNKNOWN) { ++ok; if (!first) putc('\n'); part_print(desc); first = false; } } if (!ok) return -ENODEV; return 0; }
void idntfy(void) { short ch; object *obj; struct id *id_table; char desc[ROGUE_COLUMNS]; AGAIN: ch = pack_letter(mesg[260], ALL_OBJECTS); if (ch == CANCEL) { return; } if (!(obj = get_letter_object(ch))) { message(mesg[261], 0); message("", 0); check_message(); goto AGAIN; } obj->identified = 1; if (obj->what_is & (SCROL | POTION | WEAPON | ARMOR | WAND | RING)) { id_table = get_id_table(obj); id_table[obj->which_kind].id_status = IDENTIFIED; } get_desc(obj, desc, 1); message(desc, 0); }
int main() { srand(0); //seed generator with 0 for debugging dungeon *game = generate_dungeon(10, 20); tutorial(game); for(;;) { set_stage(game); get_desc(game); switch(input("", I_CHAR)) { case 'q': goto END_GAME; case 'n': move(game, D_NORTH); break; case 's': move(game, D_SOUTH); break; case 'e': move(game, D_EAST); break; case 'w': move(game, D_WEST); break; case 'i': action(game, A_INVENTORY); break; case 'd': action(game, A_DROP); break; case 'l': action(game, A_LOOT); break; case 'p': action(game, A_PUTON); break; case 'a': action(game, A_ARM); break; case 'c': action(game, A_CONSUME); break; case 'f': fight(game); break; case 'h': help(); break; case 'r': reflect(&(game->player)); break; case 'z': dump_dungeon(game); break; default: printf("Invalid Command!\n"); } } END_GAME: return 0; }
void identify_item( short ichar ) { short ch = 0 ; object *obj; struct id *id_table; char desc[DCOLS]; if( ichar ) ch = ichar ; while( !ch ) /* Until valid input is given...*/ { ch = pack_letter( "What would you like to identify?", ALL_OBJECTS ) ; if( ch == ROGUE_KEY_CANCEL ) { return ; } if( !(obj = get_letter_object(ch)) ) { message( "No such item. Try again.", 0 ) ; message( "", 0 ) ; check_message() ; ch = 0 ; } } obj->identified = 1; if (obj->what_is & (SCROLL | POTION | WEAPON | ARMOR | WAND | RING)) { id_table = get_id_table(obj); id_table[obj->which_kind].id_status = IDENTIFIED; } get_desc( obj, desc, 1 ) ; message(desc, 0); }
size_t get_phys_addrs( pid_t target, unsigned long virt_addr_start, unsigned long virt_addr_end, unsigned long *phys_addr, size_t num_addr) { FILE *pmap; size_t pagesize = getpagesize(); unsigned long phys_page_num; unsigned long offset_in_page; uint64_t page_desc; unsigned long virt_addr; size_t count = 0; pmap = open_pagemap(target); if (!pmap) { perror("fopen"); return 0; } virt_addr = virt_addr_start; while (virt_addr < virt_addr_end && count < num_addr) { offset_in_page = virt_addr % pagesize; page_desc = get_desc(pmap, pagesize, virt_addr); phys_page_num = page_desc & PFN_MASK; phys_addr[count++] = (phys_page_num * pagesize) + offset_in_page; virt_addr += pagesize; } fclose(pmap); return count; }
static void idntfy(void) { short ch; object *obj; struct id *id_table; char desc[DCOLS]; AGAIN: ch = pack_letter("what would you like to identify?", ALL_OBJECTS); if (ch == CANCEL) { return; } if (!(obj = get_letter_object(ch))) { message("no such item, try again", 0); message("", 0); check_message(); goto AGAIN; } obj->identified = 1; if (obj->what_is & (SCROL | POTION | WEAPON | ARMOR | WAND | RING)) { id_table = get_id_table(obj); id_table[obj->which_kind].id_status = IDENTIFIED; } get_desc(obj, desc); message(desc, 0); }
/// Set the new value of the specified resource limit. This function does _not_ multiply the limit // value by the multiplier constant used by the commandline ulimit. static int set(int resource, int hard, int soft, rlim_t value, io_streams_t &streams) { struct rlimit ls; getrlimit(resource, &ls); if (hard) { ls.rlim_max = value; } if (soft) { ls.rlim_cur = value; // Do not attempt to set the soft limit higher than the hard limit. if ((value == RLIM_INFINITY && ls.rlim_max != RLIM_INFINITY) || (value != RLIM_INFINITY && ls.rlim_max != RLIM_INFINITY && value > ls.rlim_max)) { ls.rlim_cur = ls.rlim_max; } } if (setrlimit(resource, &ls)) { if (errno == EPERM) streams.err.append_format( L"ulimit: Permission denied when changing resource of type '%ls'\n", get_desc(resource)); else builtin_wperror(L"ulimit", streams); return 1; } return 0; }
static int pv_desc(sip_msg_t* msg, pv_param_t* param, pv_value_t* res) { if (get_desc(&res->rs, msg) < 0) { return pv_get_null(msg, param, res); } res->flags = PV_VAL_STR; return 0; }
void input_context::display_help() { // Shamelessly stolen from help.cpp WINDOW *w_help = newwin(FULL_SCREEN_HEIGHT - 2, FULL_SCREEN_WIDTH - 2, 1 + (int)((TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0), 1 + (int)((TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0)); werase(w_help); // Draw win header and borders draw_border(w_help, c_white); mvwprintz(w_help, 0, (FULL_SCREEN_WIDTH - utf8_width(_("Keybindings"))) / 2 - 1, c_ltred, " %s ", _("Keybindings")); mvwprintz(w_help, 1, 51, c_ltred, _("Unbound keys")); mvwprintz(w_help, 2, 51, c_ltgreen, _("Keybinding active only")); mvwprintz(w_help, 3, 51, c_ltgreen, _("on this screen")); mvwprintz(w_help, 4, 51, c_ltgray, _("Keybinding active globally")); // Clear the lines. Don't touch borders for (int i = 1; i < FULL_SCREEN_HEIGHT - 3; i++) { mvwprintz(w_help, i, 1, c_black, " "); } for (int i = 0; i < registered_actions.size(); i++) { const std::string &action_id = registered_actions[i]; if(action_id == "ANY_INPUT") { continue; } bool overwrite_default; const std::vector<input_event> &input_events = inp_mngr.get_input_for_action(action_id, category, &overwrite_default); nc_color col = input_events.size() ? c_white : c_ltred; mvwprintz(w_help, i, 3, col, "%s: ", inp_mngr.get_action_name(action_id).c_str()); if (!input_events.size()) { mvwprintz(w_help, i, 30, c_ltred, _("Unbound!")); } else { // The color depends on whether this input draws from context-local or from // default settings. Default will be ltgray, overwrite will be ltgreen. col = overwrite_default ? c_ltgreen : c_ltgray; mvwprintz(w_help, i, 30, col, "%s", get_desc(action_id).c_str()); } } wrefresh(w_help); refresh(); long ch = getch(); while (ch != 'q' && ch != 'Q' && ch != KEY_ESCAPE) { ch = getch(); }; werase(w_help); wrefresh(w_help); delwin(w_help); }
struct blk_desc *blk_get_devnum_by_type(enum if_type if_type, int devnum) { struct blk_driver *drv = blk_driver_lookup_type(if_type); struct blk_desc *desc; if (!drv) return NULL; if (get_desc(drv, devnum, &desc)) return NULL; return desc; }
struct blk_desc *blk_get_devnum_by_typename(const char *if_typename, int devnum) { struct blk_driver *drv = blk_driver_lookup_typename(if_typename); struct blk_desc *desc; if (!drv) return NULL; if (get_desc(drv, devnum, &desc)) return NULL; return desc; }
int blk_select_hwpart_devnum(enum if_type if_type, int devnum, int hwpart) { struct blk_driver *drv = blk_driver_lookup_type(if_type); struct blk_desc *desc; int ret; if (!drv) return -ENOSYS; ret = get_desc(drv, devnum, &desc); if (ret) return ret; return drv->select_hwpart(desc, hwpart); }
void net_get(nut_ctype_t *client, int numarg, const char **arg) { if (numarg < 2) { send_err(client, NUT_ERR_INVALID_ARGUMENT); return; } /* GET NUMLOGINS UPS */ if (!strcasecmp(arg[0], "NUMLOGINS")) { get_numlogins(client, arg[1]); return; } /* GET UPSDESC UPS */ if (!strcasecmp(arg[0], "UPSDESC")) { get_upsdesc(client, arg[1]); return; } if (numarg < 3) { send_err(client, NUT_ERR_INVALID_ARGUMENT); return; } /* GET VAR UPS VARNAME */ if (!strcasecmp(arg[0], "VAR")) { get_var(client, arg[1], arg[2]); return; } /* GET TYPE UPS VARNAME */ if (!strcasecmp(arg[0], "TYPE")) { get_type(client, arg[1], arg[2]); return; } /* GET DESC UPS VARNAME */ if (!strcasecmp(arg[0], "DESC")) { get_desc(client, arg[1], arg[2]); return; } /* GET CMDDESC UPS CMDNAME */ if (!strcasecmp(arg[0], "CMDDESC")) { get_cmddesc(client, arg[1], arg[2]); return; } send_err(client, NUT_ERR_INVALID_ARGUMENT); return; }
ulong blk_write_devnum(enum if_type if_type, int devnum, lbaint_t start, lbaint_t blkcnt, const void *buffer) { struct blk_driver *drv = blk_driver_lookup_type(if_type); struct blk_desc *desc; int ret; if (!drv) return -ENOSYS; ret = get_desc(drv, devnum, &desc); if (ret) return ret; return desc->block_write(desc, start, blkcnt, buffer); }
int main (int argc, char *argv[]) { int i; OrcOpcodeSet *opcode_set; orc_init(); orc_test_init(); printf( "<!-- generated by " __FILE__ " -->\n" "<table frame=\"all\" id=\"table-basictypes\" xreflabel=\"Table of Opcodes\">\n" "<title>Table of Opcodes</title>\n" "<tgroup cols=\"3\" align=\"left\" colsep=\"1\" rowsep=\"1\">\n" "<thead>\n" "<row>\n" "<entry>opcode</entry>\n" "<entry>destination size</entry>\n" "<entry>source 1 size</entry>\n" "<entry>source 2 size</entry>\n" "<entry>description</entry>\n" "<entry>pseudo code</entry>\n" "</row>\n" "</thead>\n" "<tbody valign=\"top\">\n"); opcode_set = orc_opcode_set_get ("sys"); for(i=0;i<opcode_set->n_opcodes;i++){ printf("<row>\n"); printf("<entry>%s</entry>\n", opcode_set->opcodes[i].name); printf("<entry>%d</entry>\n", opcode_set->opcodes[i].dest_size[0]); printf("<entry>%d</entry>\n", opcode_set->opcodes[i].src_size[0]); if (opcode_set->opcodes[i].src_size[1]) { printf("<entry>%d%s</entry>\n", opcode_set->opcodes[i].src_size[1], (opcode_set->opcodes[i].flags & ORC_STATIC_OPCODE_SCALAR) ? "S" : ""); } else { printf("<entry></entry>\n"); } printf("<entry>%s</entry>\n", get_desc(&opcode_set->opcodes[i])); printf("<entry>%s</entry>\n", get_code(&opcode_set->opcodes[i])); printf("</row>\n"); } printf( "</tbody>\n" "</tgroup>\n" "</table>\n"); return 0; }
int createCon(struct node* arg_head) { struct node* loc_head = arg_head; // -0x18(rbp) struct node* n = loc_head; // -0x08(rbp) int i = 0; // -0x0c(rbp) while(node->in_use && i <= 9) { node += sizeof(struct node); i++; } puts("Contact info: "); get_name(node); get_phone(node); get_desc(node); node->in_use = 1; con_cnt++; return con_cnt; }
int blk_print_device_num(enum if_type if_type, int devnum) { struct blk_driver *drv = blk_driver_lookup_type(if_type); struct blk_desc *desc; int ret; if (!drv) return -ENOSYS; ret = get_desc(drv, devnum, &desc); if (ret) return ret; printf("\n%s device %d: ", drv->if_typename, devnum); dev_print(desc); return 0; }
int blk_print_part_devnum(enum if_type if_type, int devnum) { struct blk_driver *drv = blk_driver_lookup_type(if_type); struct blk_desc *desc; int ret; if (!drv) return -ENOSYS; ret = get_desc(drv, devnum, &desc); if (ret) return ret; if (desc->type == DEV_TYPE_UNKNOWN) return -ENOENT; part_print(desc); return 0; }
void blk_list_devices(enum if_type if_type) { struct blk_driver *drv = blk_driver_lookup_type(if_type); struct blk_desc *desc; int i; if (!drv) return; for (i = 0; i < drv->max_devs; ++i) { if (get_desc(drv, i, &desc)) continue; if (desc->type == DEV_TYPE_UNKNOWN) continue; /* list only known devices */ printf("Device %d: ", i); dev_print(desc); } }
/* * Read USB Device Endpoint Data * Parameters: EPNum: Device Endpoint Number * EPNum.0..3: Address * EPNum.7: Dir * pData: Pointer to Data Buffer * Return Value: Number of bytes read */ U32 USBD_ReadEP (U32 EPNum, U8 *pData, U32 size) { U32 cnt; ep_buffer_t *desc = get_desc(EPNum); USB_SETUP_PACKET *sup; EPNum &= EPNUM_MASK; if ((EPNum == 0) && setup_waiting) { cnt = USBD_MAX_PACKET0; if (size < cnt) { cnt = size; } setup_waiting = 0; memcpy(pData, (void*)&MXC_USB->setup0, cnt); sup = (USB_SETUP_PACKET*)pData; if ( (sup->bmRequestType.Dir == REQUEST_HOST_TO_DEVICE) && (sup->wLength > 0) ) { // There is an OUT stage for this setup packet. Register a request. if (!(MXC_USB->out_owner & 1)) { desc = &ep_buffer_descriptor.ep0.out_buffer; desc->buf0_address = (uint32_t)ep_buffer[0]; desc->buf0_desc = sup->wLength; MXC_USB->out_owner = 1; } } } else { cnt = desc->buf0_desc; if (size < cnt) { cnt = size; } memcpy(pData, ep_buffer[EPNum], cnt); // Register the next request. desc->buf0_address = (uint32_t)ep_buffer[EPNum]; desc->buf0_desc = sizeof(ep_buffer[EPNum]); MXC_USB->out_owner = (1 << EPNum); } return cnt; }
D* mad_desc_new(int nv, const ord_t var_ords[nv], const ord_t map_ords_[nv], str_t var_nam_[nv]) { ensure(var_ords); ord_t mo, map_ords[nv]; // to parse optional param if (map_ords_) { for (int i = 0; i < nv; ++i) ensure(var_ords[i] <= map_ords_[i]); mad_mono_copy(nv,map_ords_,map_ords); mo = mad_mono_max(nv,map_ords); } else { mo = mad_mono_max(nv,var_ords); mad_mono_fill(nv,map_ords,mo); } ensure(mo < desc_max_order); return get_desc(nv,map_ords,var_nam_, nv,var_ords, 0); }
ulong blk_read_devnum(enum if_type if_type, int devnum, lbaint_t start, lbaint_t blkcnt, void *buffer) { struct blk_driver *drv = blk_driver_lookup_type(if_type); struct blk_desc *desc; ulong n; int ret; if (!drv) return -ENOSYS; ret = get_desc(drv, devnum, &desc); if (ret) return ret; n = desc->block_read(desc, start, blkcnt, buffer); if (IS_ERR_VALUE(n)) return n; return n; }
/* * Write USB Device Endpoint Data * Parameters: EPNum: Endpoint Number * EPNum.0..3: Address * EPNum.7: Dir * pData: Pointer to Data Buffer * cnt: Number of bytes to write * Return Value: Number of bytes written */ U32 USBD_WriteEP (U32 EPNum, U8 *pData, U32 cnt) { ep_buffer_t *desc = get_desc(EPNum); uint32_t mask; EPNum &= EPNUM_MASK; mask = (1 << EPNum); if (MXC_USB->in_owner & mask) { return 0; } if (EPNum == 0) { // Prepare to ACK the status stage. MXC_USB->ep[0] |= MXC_F_USB_EP_ST_ACK; if ((cnt == 0) && !ep0_expect_zlp) { // This is a status stage ACK. Handled in hardware. return 0; } else if (cnt == USBD_MAX_PACKET0) { ep0_expect_zlp = 1; } else { ep0_expect_zlp = 0; } } if (cnt > MXC_USB_MAX_PACKET) { cnt = MXC_USB_MAX_PACKET; } /* prepare data to be sent */ memcpy(ep_buffer[EPNum], pData, cnt); desc->buf0_address = (uint32_t)ep_buffer[EPNum]; desc->buf0_desc = cnt; /* start the transaction */ MXC_USB->in_owner = mask; return cnt; }
int blk_show_device(enum if_type if_type, int devnum) { struct blk_driver *drv = blk_driver_lookup_type(if_type); struct blk_desc *desc; int ret; if (!drv) return -ENOSYS; printf("\nDevice %d: ", devnum); if (devnum >= drv->max_devs) { puts("unknown device\n"); return -ENODEV; } ret = get_desc(drv, devnum, &desc); if (ret) return ret; dev_print(desc); if (desc->type == DEV_TYPE_UNKNOWN) return -ENOENT; return 0; }
unsigned long get_phys_addr(pid_t target, unsigned long virt_addr) { FILE *pmap; size_t pagesize = getpagesize(); unsigned long phys_page_num; unsigned long offset_in_page; uint64_t page_desc; pmap = open_pagemap(target); if (!pmap) { perror("fopen"); return 0; } offset_in_page = virt_addr % pagesize; page_desc = get_desc(pmap, pagesize, virt_addr); phys_page_num = page_desc & PFN_MASK; fclose(pmap); return (phys_page_num * pagesize) + offset_in_page; }
struct drive_info *get_drive_list(void) { int total_devs, listed_devs; static struct usb_device **devs=NULL; int i; struct usb_device **dev; struct drive_info *drive; total_devs=fc5025_find(NULL,0); if(total_devs==0) return NULL; if(devs!=NULL) free(devs); devs=malloc(total_devs*sizeof(struct usb_device)); if(!devs) return NULL; listed_devs=fc5025_find(devs,total_devs); if(listed_devs==0) return NULL; if(drives!=NULL) free(drives); drives=malloc((listed_devs+1)*sizeof(struct drive_info)); if(!drives) return NULL; dev=devs; drive=drives; for(i=0;i<listed_devs;i++) { snprintf(drive->id,256,"%s/%s",(*dev)->bus->dirname,(*dev)->filename); drive->usbdev=*dev; if(get_desc(drive)==0) { dev++; drive++; } } drive->id[0]='\0'; drive->desc[0]='\0'; drive->usbdev=NULL; if(drive==drives) return NULL; return drives; }
void single_inv(short ichar) { short ch; char desc[DCOLS]; object *obj; ch = ichar ? ichar : pack_letter("Inventory what?", ALL_OBJECTS); if (ch == ROGUE_KEY_CANCEL) { return; } if (!(obj = get_letter_object(ch))) { message("No such item.", 0); return; } desc[0] = ch; desc[1] = ((obj->what_is & ARMOR) && obj->is_protected) ? '}' : ')'; desc[2] = ' '; desc[3] = 0; get_desc( obj, desc+3, 1 ); message(desc, 0); }
result_t* new_result_t(drizzle_con_st *con, drizzle_result_st *result) { result_t *r = NULL; PyObject *desc = NULL; r = PyMem_Malloc(sizeof(result_t)); if (r == NULL) { return NULL; } memset(r, 0, sizeof(result_t)); desc = get_desc(r, con, result); if (desc == NULL) { PyMem_Free(r); return NULL; } r->con = con; r->result = result; r->description = desc; return r; }