static SANE_Status read_image_duplex(SANE_Handle handle) { struct scanner *s = (struct scanner *) handle; SANE_Status st = SANE_STATUS_GOOD; unsigned read, side; int i; struct side { unsigned mx, eof; u8 *p; struct buf *buf; } a[2], *b; for (i = 0; i < 2; i++) { a[i].mx = BUF_SIZE; a[i].eof = 0; a[i].buf = &s->buf[i]; st = new_buf(&s->buf[i], &a[i].p); if (st) goto err; } for (b = &a[0], side = SIDE_FRONT; (!a[0].eof || !a[1].eof);) { pthread_testcancel(); if (b->mx == 0) { push_buf(b->buf, BUF_SIZE); st = new_buf(b->buf, &b->p); if (st) goto err; b->mx = BUF_SIZE; } st = kvs40xx_read_image_data(s, s->page, side, b->p + BUF_SIZE - b->mx, b->mx, &read); b->mx -= read; if (st) { if (st != INCORRECT_LENGTH && st != SANE_STATUS_EOF) goto err; if (st == SANE_STATUS_EOF) { b->eof = 1; push_buf(b->buf, BUF_SIZE - b->mx); } side ^= SIDE_BACK; b = &a[side == SIDE_FRONT ? 0 : 1]; } } err: for (i = 0; i < 2; i++) buf_set_st(&s->buf[i], st); return st; }
void func_list_mail(USER_DATA *usr) { MAIL_DATA *pMail; char buf[STRING]; BUFFER *buffer; int vnum = 0; buffer = new_buf(); add_buf(buffer, " Num Date From Subject\n\r"); for (pMail = usr->pMailFirst; pMail; pMail = pMail->next) { if (pMail) { sprintf(buf, "%s %3d %s %-15s %s\n\r", pMail->marked ? "M" : (pMail->stamp_time > pMail->read_time) ? "N" : " ", vnum + 1, time_str(pMail->stamp_time), pMail->from, pMail->subject); add_buf(buffer, buf); vnum++; } } if (vnum > 0) { page_to_user(buf_string(buffer), usr); free_buf(buffer); return; } send_to_user("You don't have any mail.\n\r", usr); free_buf(buffer); return; }
void chk_rfsbitmap(device_t * devp) { void * buf = new_buf(FSYS_ALCBLKSZ); if(buf == NULL) { printfk("alloc buf failed\n\r"); return; } hal_memset(buf, FSYS_ALCBLKSZ, 0); if(read_rfsdevblk(devp, buf, 1) == DFCERRSTUS) { hal_sysdie("chkbitmap err1\n\r"); } u8_t * bmp = (u8_t *)buf; uint_t b = 0; for(uint_t i = 0; i<FSYS_ALCBLKSZ; i++) { if(bmp[i] == 0) { b++; } } printfk("chk bmp b:%x\n\r", b); del_buf(buf, FSYS_ALCBLKSZ); return; }
static const char *prep_find_entity_vnum(struct char_data *ch, const char *argument, char *arg, const char *entity, void (*help_entity_properties_fn)(struct char_data *ch), void (*entity_empty_fn)(struct char_data *ch, const char *arg, struct buf_type *buffer)) { if (ch == NULL || IS_NPC(ch)) return NULL; if (argument[0] == '\0') { char buf[200]; snprintf(buf, 200, "\n\r%s: Find what?\n\r", entity); send_to_char(buf, ch); return NULL; } argument = one_argument(argument, arg); if (arg[0] == '?' || !str_prefix(arg, "help")) { show_help(ch->desc, (char *)entity, NULL); return NULL; } if (!str_prefix(arg, "list")) { (*help_entity_properties_fn)(ch); return NULL; } else if (!str_prefix(arg, "empty")) { struct buf_type *buffer = new_buf(); argument = one_argument(argument, arg); (*entity_empty_fn)(ch, arg, buffer); page_to_char(buf_string(buffer), ch); free_buf(buffer); return NULL; } return argument; }
PC_DATA *new_pcdata( void ) { static PC_DATA pcdata_zero; PC_DATA *pcdata; int alias; /*~~~~~~~~~~~~~~~~~~~~~~~~*/ if ( pcdata_free == NULL ) pcdata = alloc_perm( sizeof(*pcdata) ); else { pcdata = pcdata_free; pcdata_free = pcdata_free->next; } *pcdata = pcdata_zero; for ( alias = 0; alias < MAX_ALIAS; alias++ ) { pcdata->alias[alias] = NULL; pcdata->alias_sub[alias] = NULL; } pcdata->buffer = new_buf( ); VALIDATE( pcdata ); return( pcdata ); }
void func_rnew_mail(USER_DATA *usr) { MAIL_DATA *pMail; char buf[STRING]; BUFFER *buffer; int vnum = 1; buffer = new_buf(); for (pMail = usr->pMailFirst; pMail; pMail = pMail->next) { if (pMail->stamp_time <= pMail->read_time) break; } if (pMail) { time_t *last_read = &pMail->read_time; *last_read = UMAX(*last_read, pMail->stamp_time); sprintf(buf, "Reading new message %d.\n\rDate: %s\n\rFrom: %s\n\r" "Subject: %s\n\r\n\r", vnum, time_str(pMail->stamp_time), pMail->from, pMail->subject); add_buf(buffer, buf); add_buf(buffer, pMail->message); add_buf(buffer, "#x\n\r"); page_to_user(buf_string(buffer), usr); free_buf(buffer); save_mail(usr); return; } send_to_user("No new messages.\n\r", usr); return; }
void *uade_ipc_set_output(const char *output) { if(!server_buf) { server_buf = new_buf(); client_buf = new_buf(); } if(strcmp(output, "server") == 0) return (void *)server_buf; else if(strcmp(output, "client") == 0) return (void *)client_buf; return NULL; }
void * get_rootdirfile_blk(device_t * devp) { void * retptr = NULL; rfsdir_t * rtdir = get_rootdir(devp); if(!rtdir) { printfk("get_rootdir failed\n\r"); return NULL; } void * buf = new_buf(FSYS_ALCBLKSZ); if(!buf) { printfk("new_buf failed\n\r"); retptr = NULL; goto err2; } hal_memset(buf, FSYS_ALCBLKSZ, 0); if(read_rfsdevblk(devp, buf, rtdir->rdr_blknr) == DFCERRSTUS) { printfk("read_rfsdevblk failed\n\r"); retptr = NULL; goto err1; } retptr = buf; goto err2; err1: del_buf(buf, FSYS_ALCBLKSZ); err2: del_rootdir(devp, rtdir); return retptr; }
PC_DATA *new_pcdata(void) { int cnt; static PC_DATA pcdata_zero; PC_DATA *pcdata; if (pcdata_free == NULL) pcdata = alloc_perm(sizeof(*pcdata)); else { pcdata = pcdata_free; pcdata_free = pcdata_free->next; } *pcdata = pcdata_zero; for (cnt = 0; cnt < MAX_ALIAS; cnt++) { pcdata->alias[cnt] = NULL; pcdata->alias_sub[cnt] = NULL; } for (cnt = 0; cnt < MAX_IGNORE; cnt++) { pcdata->ignore[cnt] = NULL; } for (cnt = 0; cnt < MAX_DISGUISE; cnt++) { pcdata->disguise[cnt] = NULL; } pcdata->buffer = new_buf(); pcdata->polls = str_dup(""); #if !defined(FIRST_BOOT) pcdata->learned = new_learned(); pcdata->group_known = new_gknown(); #endif pcdata->reward_multiplier = 0; pcdata->reward_time = current_time; pcdata->keepoldstats = FALSE; pcdata->referrer = str_dup(""); pcdata->forcespark = 0; pcdata->forceinsanity = 0; pcdata->timeoutstamp = 0; pcdata->rprewardtimer = 0; pcdata->rpbonus = 0; pcdata->bondcount = 0; pcdata->bondedbysex = 0; pcdata->createangrealcount = 0; pcdata->next_24hourangreal = 0; pcdata->next_createangreal = 0; pcdata->keys = NULL; VALIDATE(pcdata); return pcdata; }
struct buffer *new_payload (struct sockaddr_in peer) { struct buffer *tmp = new_buf (MAX_RECV_SIZE); if (!tmp) return NULL; tmp->peer = peer; tmp->start += sizeof (struct payload_hdr); tmp->len = 0; return tmp; }
bool_t create_rootdir(device_t * devp) { printfk("%s in \n\r", __func__); bool_t rets = FALSE; rfssublk_t * sbp = get_superblk(devp); if(!sbp) { printfk("%s get_superblk failed\n\r"); return FALSE; } void * buf = new_buf(FSYS_ALCBLKSZ); if(!buf) { rets = FALSE; goto errlable1; } hal_memset(buf, FSYS_ALCBLKSZ, 0); uint_t blk = rfs_new_blk(devp); if(blk == 0) { rets = FALSE; printfk("%s rfs_new_blk failed\n\r"); goto errlable; } sbp->rsb_rootdir.rdr_name[0] = '/'; sbp->rsb_rootdir.rdr_type = RDR_DIR_TYPE; sbp->rsb_rootdir.rdr_blknr = blk; fimgrhd_t * fmp = (fimgrhd_t *)buf; fimgrhd_t_init(fmp); fmp->fmd_type = FMD_DIR_TYPE; fmp->fmd_sfblk = blk; fmp->fmd_curfwritebk = blk; fmp->fmd_curfinwbkoff = 0x200; fmp->fmd_fleblk[0].fb_blkstart = blk; fmp->fmd_fleblk[0].fb_blknr = 1; if(write_rfsdevblk(devp, buf, blk) == DFCERRSTUS) { rets = FALSE; goto errlable; } rets = TRUE; errlable: del_buf(buf, FSYS_ALCBLKSZ); errlable1: del_superblk(devp, sbp); return rets; }
std::vector<cuda_linear_buffer_device::ptr> layer_updater_cuda::get_data(layer_data::const_ptr host_data) const { std::vector<cuda_linear_buffer_device::ptr> res; for(std::vector<std::vector<float> >::const_iterator it = host_data->begin(); it != host_data->end(); ++it) { size_t buffer_size = it->size() * sizeof(float); cuda_linear_buffer_device::ptr new_buf(new cuda_linear_buffer_device(buffer_size)); cuda_safe_call(cudaMemcpy(*new_buf, &(*it->begin()), buffer_size, cudaMemcpyHostToDevice)); res.push_back(new_buf); } return res; }
std::vector<cuda_linear_buffer_device::const_ptr> layer_updater_cuda::set_get_data_custom(layer_data_custom::const_ptr host_data_custom) { notify_data_custom(host_data_custom); std::vector<cuda_linear_buffer_device::const_ptr> res; for(std::vector<std::vector<int> >::const_iterator it = host_data_custom->begin(); it != host_data_custom->end(); ++it) { size_t buffer_size = it->size() * sizeof(int); cuda_linear_buffer_device::ptr new_buf(new cuda_linear_buffer_device(buffer_size)); cuda_safe_call(cudaMemcpy(*new_buf, &(*it->begin()), buffer_size, cudaMemcpyHostToDevice)); res.push_back(new_buf); } return res; }
PC_DATA::PC_DATA() { for (int alias = 0; alias < MAX_ALIAS; alias++) { this->alias[alias] = NULL; this->alias_sub[alias] = NULL; } for ( int i = 0; i < 4; i++ ) { this->condition[i] = 0; } for ( int skill = 0; skill < MAX_SKILL; skill++ ) { this->learned[skill] = 0; this->sk_level[skill] = 0; this->sk_rating[skill] = 0; } this->next = NULL; this->clan = NULL; this->buffer = new_buf(); this->pwd = NULL; this->bamfin = NULL; this->bamfout = NULL; this->title = NULL; this->perm_hit = 0; this->perm_mana = 0; this->perm_move = 0; this->true_sex = 0; this->last_level = 0; this->points = 0; this->confirm_delete = false; this->security = 0; this->board = NULL; this->in_progress = NULL; for ( int board = 0; board < MAX_BOARD; board++ ) { this->last_note[board] = 0; } for ( int group = 0; group < MAX_GROUP; group++ ) { this->group_known[group] = false; } VALIDATE(this); PC_DATA::active.push_back(this); }
static void help_mvnum_properties(struct char_data *ch) { struct buf_type *buffer = new_buf(); char buf[MAX_INPUT_LENGTH]; int iter; add_buf(buffer, "`#QUERY``: mvnum: searchable property list\n\r"); for (iter = 0; mob_idx_flags[iter].var[0] != '\0'; iter++) { sprintf(buf, "%-18.17s", mob_idx_flags[iter].var); add_buf(buffer, buf); if ((iter % 2) == 1) add_buf(buffer, "\n\r"); } add_buf(buffer, "\n\r"); page_to_char(buf_string(buffer), ch); free_buf(buffer); }
void do_matlist(CHAR_DATA *ch, char *argument) { MAT_TYPE *mat, *mat_next; BUFFER *output = new_buf(); int col = 0; for(mat = mat_list; mat; mat = mat_next) { mat_next = mat->next; add_buf(output, Format("%-15s", mat->name) ); if(++col == 5) { col = 0; add_buf(output, "\n\r"); } } page_to_char(buf_string(output), ch); free_buf(output); return; }
bool_t create_bitmap(device_t * devp) { printfk("%s in \n\r", __func__); bool_t rets = FALSE; rfssublk_t * sbp = get_superblk(devp); if(!sbp) { return FALSE; } void * buf = new_buf(FSYS_ALCBLKSZ); if(!buf) { printfk("%s alloc failed\n\r", __func__); return FALSE; } uint_t bitmapblk = sbp->rsb_bmpbks; uint_t devmaxblk = sbp->rsb_fsysallblk; if(devmaxblk > FSYS_ALCBLKSZ) { rets = FALSE; goto errlable; } hal_memset(buf, FSYS_ALCBLKSZ, 1); u8_t * bitmap = (u8_t *)buf; for(uint_t bi=2; bi<devmaxblk; bi++) { bitmap[bi] = 0; } /*缓冲区数据回写到存储介质的第bitmapblk存储块中*/ if(write_rfsdevblk(devp, buf, bitmapblk) == DFCERRSTUS) { rets = FALSE; goto errlable; } rets = TRUE; errlable: del_superblk(devp, sbp); del_buf(buf, FSYS_ALCBLKSZ); return rets; }
rfssublk_t * get_superblk(device_t * devp) { void * buf = new_buf(FSYS_ALCBLKSZ); if(!buf) { printfk("%s alloc failed\n\r", __func__); return NULL; } hal_memset(buf, FSYS_ALCBLKSZ, 0); if(read_rfsdevblk(devp, buf, 0)==DFCERRSTUS) { del_buf(buf, FSYS_ALCBLKSZ); return NULL; } return (rfssublk_t *)buf; }
void do_mplist (CHAR_DATA * ch, char *argument) { int count; MPROG_CODE *mprg; char buf[MAX_STRING_LENGTH]; BUFFER *buffer; buffer = new_buf (); for (count = 1, mprg = mprog_list; mprg != NULL; mprg = mprg->next) { sprintf (buf, "[%3d] %5d\n\r", count, mprg->vnum); add_buf (buffer, buf); count++; } page_to_char (buf_string (buffer), ch); free_buf (buffer); return; }
std::vector<const_cuda_linear_buffer_device_smart_ptr> layer_hessian_cuda::get_data_squared(const_layer_data_smart_ptr host_data) const { std::vector<const_cuda_linear_buffer_device_smart_ptr> res; for(std::vector<std::vector<float> >::const_iterator it = host_data->begin(); it != host_data->end(); ++it) { size_t buffer_size = it->size() * sizeof(float); cuda_linear_buffer_device_smart_ptr new_buf(new cuda_linear_buffer_device(buffer_size)); cuda_safe_call(cudaMemcpy(*new_buf, &(*it->begin()), buffer_size, cudaMemcpyHostToDevice)); cuda_util::multiply_by_itself( *cuda_config, *new_buf, *new_buf, new_buf->get_size() / sizeof(float), 0); cuda_safe_call(cudaStreamSynchronize(0)); res.push_back(new_buf); } return res; }
int main() { MyBuf buffer = new_buf(); char c = ' '; while(c != 'q') { c = getchar(); getchar(); // toss the return if(c == '1') { on(&buffer); } else if (c == '0') { off(&buffer); } else { printf("Enter 0s and 1s\r\n"); } printf("Value: %d\n", buffer.value); char str[BUFFER_LENGTH+1]; buffer_inputs_to_s(&buffer, str); printf("Inputs: %s\n", str); } return(0); }
static SANE_Status read_image_simplex(SANE_Handle handle) { struct scanner *s = (struct scanner *) handle; SANE_Status st = SANE_STATUS_GOOD; for (; (!st || st == INCORRECT_LENGTH);) { unsigned read, mx; unsigned char *p = NULL; st = new_buf(&s->buf[0], &p); for (read = 0, mx = BUF_SIZE; mx && (!st || st == INCORRECT_LENGTH); mx -= read) { pthread_testcancel(); st = kvs40xx_read_image_data(s, s->page, SIDE_FRONT, p + BUF_SIZE - mx, mx, &read); } push_buf(&s->buf[0], BUF_SIZE - mx); } buf_set_st(&s->buf[0], st); return st; }
bool_t create_superblk(device_t * devp) { printfk("%s in \n\r", __func__); void *buf = new_buf(FSYS_ALCBLKSZ); if(!buf) { printfk("alloc failed\n\r"); return FALSE; } hal_memset(buf, FSYS_ALCBLKSZ, 0); rfssublk_t * sbp = (rfssublk_t *)buf; rfssublk_t_init(sbp); sbp->rsb_fsysallblk = ret_rfsdevmaxblknr(devp); if(write_rfsdevblk(devp, buf, 0) == DFCERRSTUS) { printfk("write_rfsdevblk failed\n\r"); return FALSE; } del_buf(buf, FSYS_ALCBLKSZ); return TRUE; }
void test_dir(device_t * devp) { rfsdir_t * dr = get_rootdir(devp); void * buf = new_buf(FSYS_ALCBLKSZ); if(buf == NULL) { hal_sysdie("testdir1 err\n\r"); } hal_memset(buf, FSYS_ALCBLKSZ, 0); if(read_rfsdevblk(devp, buf, dr->rdr_blknr) == DFCERRSTUS) { hal_sysdie("testdir1 err\n\r"); } fimgrhd_t * fmp = (fimgrhd_t *)buf; printfk("fmp->fmd_type : %x fmd_filesz : %x fmd_fileifstbkoff : %x fmd_fileiendbkoff : %x\n\r", fmp->fmd_type, fmp->fmd_filesz, fmp->fmd_fileifstbkoff, fmp->fmd_fileiendbkoff); printfk("fmd_fleblk : %x : %x\n\r", fmp->fmd_fleblk[0].fb_blkstart, fmp->fmd_fleblk[0].fb_blknr); del_buf(buf, FSYS_ALCBLKSZ); del_rootdir(devp, dr); return; }
/* * H : 2 bit (unsigned short) * B : 1 bit (unsigned char) * I : 4 bit (unsigned int) * X : N bit (char* end up with '\0') * x : N bit (Buffer) */ Buffer Buffer::pack(const char * fmt, ...) { Buffer rtn_buf(0); uchar *cs = new uchar[4]; const char *str = NULL; va_list args; va_start(args,fmt); while(*fmt != '\0') { if(*fmt == 'B') { uchar byt = va_arg(args, uchar); qToBigEndian(byt,cs); rtn_buf.append(reinterpret_cast<const char *>(cs), 1); } if(*fmt == 'H') { ushort dbyt = va_arg(args, ushort); qToBigEndian(dbyt, cs); rtn_buf.append(reinterpret_cast<const char*>(cs), 2); } if(*fmt == 'X') { str = va_arg(args, const char*); rtn_buf.append(str); } if(*fmt == 'x') { Buffer new_buf(va_arg(args, Buffer)); rtn_buf.append(new_buf); } if(*fmt == 'I') { uint qbyt = va_arg(args, uint); qToBigEndian(qbyt, cs); rtn_buf.append(reinterpret_cast<const char*>(cs), 4); } ++fmt; }
void func_reply_mail(USER_DATA *usr, char *argument) { MAIL_DATA *pMail; char buf[STRING]; BUFFER *buffer; int vnum = 1; int anum = 0; if (argument[0] == '\0' || !is_number(argument)) { syntax("[#Wr#x]eply <mail number>", usr); return; } anum = atoi(argument); buffer = new_buf(); for (pMail = usr->pMailFirst; pMail; pMail = pMail->next) { if (pMail && (vnum++ == anum)) break; } mail_attach(usr); if (usr->pCurrentMail->to) free_string(usr->pCurrentMail->to); usr->pCurrentMail->to = str_dup(pMail->from); if (usr->pCurrentMail->subject) free_string(usr->pCurrentMail->subject); if (pMail->subject[0] == 'R' && pMail->subject[1] == 'e' && pMail->subject[2] == ':' && pMail->subject[3] == ' ') usr->pCurrentMail->subject = str_dup(pMail->subject); else { sprintf(buf, "Re: %s", pMail->subject); usr->pCurrentMail->subject = str_dup(buf); } print_to_user(usr, "To: %s\n\rSubject: %s\n\r", usr->pCurrentMail->to, usr->pCurrentMail->subject); EDIT_MODE(usr) = EDITOR_MAIL_WRITE; string_edit(usr, &usr->pCurrentMail->message); }
/*获取根目录文件数据结构*/ rfsdir_t * get_rootdir(device_t * devp) { rfsdir_t * retptr = NULL; rfssublk_t * sbp = get_superblk(devp); if(!sbp) { return NULL; } void * buf = new_buf(sizeof(rfsdir_t)); if(!buf) { printfk("new_buf failed\n\r"); retptr = NULL; goto err1; } hal_memcpy((void *)(&sbp->rsb_rootdir), buf, sizeof(rfsdir_t)); retptr = (rfsdir_t *)buf; err1: del_superblk(devp, sbp); return retptr; }
/***************************************************************************** * Name: show_olc_cmds * Purpose: Format up the commands from given table. * Called by: show_commands(olc_act.c). ****************************************************************************/ static void show_olc_cmds(struct char_data *ch, const struct olc_cmd_type *olc_table) { struct buf_type *out; char buf[MAX_STRING_LENGTH]; int cmd; int col; col = 0; out = new_buf(); for (cmd = 0; olc_table[cmd].name != NULL; cmd++) { sprintf(buf, "%-15.15s", olc_table[cmd].name); add_buf(out, buf); if (++col % 5 == 0) add_buf(out, "\n\r"); } if (col % 5 != 0) add_buf(out, "\n\r"); send_to_char(buf_string(out), ch); free_buf(out); return; }
PC_DATA * new_pcdata (void) { int alias; static PC_DATA pcdata_zero; PC_DATA *pcdata; if (pcdata_free == NULL) pcdata = alloc_perm (sizeof (*pcdata)); else { pcdata = pcdata_free; pcdata_free = pcdata_free->next; } *pcdata = pcdata_zero; for (alias = 0; alias < MAX_ALIAS; alias++) { pcdata->alias[alias] = NULL; pcdata->alias_sub[alias] = NULL; } for (alias = 0; alias < MAX_FORGET; alias++) { pcdata->forget[alias] = NULL; } for (alias = 0; alias < MAX_DUPES; alias++) { pcdata->dupes[alias] = NULL; } pcdata->buffer = new_buf (); VALIDATE (pcdata); return pcdata; }
void func_read_mail(USER_DATA *usr, char *argument) { MAIL_DATA *pMail; char buf[STRING]; BUFFER *buffer; int vnum = 1; int anum = 0; if (argument[0] == '\0' || !is_number(argument)) { syntax("[#Wre#x]ad <mail number>", usr); return; } anum = atoi(argument); buffer = new_buf(); for (pMail = usr->pMailFirst; pMail; pMail = pMail->next) { if (pMail && (vnum++ == anum)) { time_t *last_read = &pMail->read_time; *last_read = UMAX(*last_read, pMail->stamp_time); sprintf(buf, "Reading message %d.\n\rDate: %s\n\rFrom: %s\n\r" "Subject: %s\n\r\n\r", vnum - 1, time_str(pMail->stamp_time), pMail->from, pMail->subject); add_buf(buffer, buf); add_buf(buffer, pMail->message); add_buf(buffer, "#x\n\r"); page_to_user(buf_string(buffer), usr); free_buf(buffer); save_mail(usr); return; } } send_to_user("There aren't that many mail.\n\r", usr); return; }