const char* session::get(const char* name) { const session_string* bf = get_buf(name); if (bf == NULL) return ""; return bf->c_str(); }
static PyObject * buffer_repeat(PyBufferObject *self, Py_ssize_t count) { PyObject *ob; register char *p; void *ptr; Py_ssize_t size; if ( count < 0 ) count = 0; if (!get_buf(self, &ptr, &size, ANY_BUFFER)) return NULL; if (count > PY_SSIZE_T_MAX / size) { PyErr_SetString(PyExc_MemoryError, "result too large"); return NULL; } ob = PyString_FromStringAndSize(NULL, size * count); if ( ob == NULL ) return NULL; p = PyString_AS_STRING(ob); while ( count-- ) { memcpy(p, ptr, size); p += size; } /* there is an extra byte in the string object, so this is safe */ *p = '\0'; return ob; }
static PyObject * buffer_repeat(PyBufferObject *self, int count) { PyObject *ob; register char *p; void *ptr; int size; if ( count < 0 ) count = 0; if (!get_buf(self, &ptr, &size)) return NULL; ob = PyString_FromStringAndSize(NULL, size * count); if ( ob == NULL ) return NULL; p = PyString_AS_STRING(ob); while ( count-- ) { memcpy(p, ptr, size); p += size; } /* there is an extra byte in the string object, so this is safe */ *p = '\0'; return ob; }
static void mouse_push_event_thread(void *arg) { (void) arg; t_current_set_name("MouEvents"); t_current_set_priority(PHANTOM_SYS_THREAD_PRIO); while(1) { hal_sem_acquire( &mouse_sem ); if(video_drv->mouse_redraw_cursor != NULL) video_drv->mouse_redraw_cursor(); //hal_mutex_lock( &mouse_mutex ); struct ui_event e, e1; while( get_buf(&e) ) { if( peek_buf( &e1 ) ) { // We already have one more event and buttons state is the same? // Throw away current event, use next one. if( e1.m.buttons == e.m.buttons ) continue; } ev_q_put_any( &e ); } //hal_mutex_unlock( &mouse_mutex ); } }
int get_next_line(int const fd, char **line) { size_t i; static t_list *fds = NULL; char *tmp; t_fd *current; if (line == NULL || BUFF_SIZE <= 0) return (-1); *line = NULL; current = get_current_fd(fd, &fds); if (current->res && current->res[0]) { i = 0; while (current->res[i] && current->res[i] != '\n') *line = ft_strfjoin(*line, ft_chartostar(current->res[i++]), 3); if (i == 0) *line = ft_strnew(0); if ((tmp = ft_strchr(¤t->res[i], '\n'))) { current->res = ft_strcpy(current->res, &tmp[1]); return (1); } current->res = NULL; } return (get_buf(fd, line, current)); }
int get_next_line(int const fd, char **line) { static t_list *list; static int pos; static int start; char *str; static int ilk; if (start == -2) { *line = ft_strnew(0); return (0); } if (fd < 0) return (-1); ilk = 0; pos = get_buf(&list, start, fd, &ilk); str = get_copy(&list, pos, &start); *line = str; if (ilk == -1) { start = -2; ft_putstr(*line); return (0); } return (1); }
CAMLprim value bin_prot_blit_buf_string_stub( value v_src_pos, value v_buf, value v_dst_pos, value v_str, value v_len) { char *buf = get_buf(v_buf, v_src_pos); char *str = String_val(v_str) + Long_val(v_dst_pos); memcpy(str, buf, (size_t) Long_val(v_len)); return Val_unit; }
CAMLprim value bin_prot_blit_buf_float_array_stub( value v_src_pos, value v_buf, value v_dst_pos, value v_arr, value v_len) { char *buf = get_buf(v_buf, v_src_pos); char *arr = (char*)v_arr + Long_val(v_dst_pos) * sizeof(double); memcpy(arr, buf, (size_t) (Long_val(v_len) * sizeof(double))); return Val_unit; }
int mpx_test (int argc, const char **argv) { int *p; rd (get_buf (), 100); return 0; }
static int buffer_length(PyBufferObject *self) { void *ptr; int size; if (!get_buf(self, &ptr, &size)) return -1; return size; }
static PyObject * buffer_str(PyBufferObject *self) { void *ptr; int size; if (!get_buf(self, &ptr, &size)) return NULL; return PyString_FromStringAndSize(ptr, size); }
static int buffer_compare(PyBufferObject *self, PyBufferObject *other) { void *p1, *p2; int len_self, len_other, min_len, cmp; if (!get_buf(self, &p1, &len_self)) return -1; if (!get_buf(other, &p2, &len_other)) return -1; min_len = (len_self < len_other) ? len_self : len_other; if (min_len > 0) { cmp = memcmp(p1, p2, min_len); if (cmp != 0) return cmp < 0 ? -1 : 1; } return (len_self < len_other) ? -1 : (len_self > len_other) ? 1 : 0; }
//!Constructor. //!Does not throw. basic_obufferstream(std::ios_base::openmode mode = std::ios_base::out) : //basic_ios_t() is called first (lefting it uninitialized) as it's a //virtual base of basic_istream. The class will be initialized when //basic_istream is constructed calling basic_ios_t::init(). //As bufferbuf_t's constructor does not throw there is no risk of //calling the basic_ios_t's destructor without calling basic_ios_t::init() bufferbuf_t(mode | std::ios_base::out) , base_t(&get_buf()) {}
static PyObject * buffer_str(PyBufferObject *self) { void *ptr; Py_ssize_t size; if (!get_buf(self, &ptr, &size, ANY_BUFFER)) return NULL; return PyString_FromStringAndSize((const char *)ptr, size); }
static int buffer_ass_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right, PyObject *other) { PyBufferProcs *pb; void *ptr1, *ptr2; Py_ssize_t size; Py_ssize_t slice_len; Py_ssize_t count; if ( self->b_readonly ) { PyErr_SetString(PyExc_TypeError, "buffer is read-only"); return -1; } pb = other ? other->ob_type->tp_as_buffer : NULL; if ( pb == NULL || pb->bf_getreadbuffer == NULL || pb->bf_getsegcount == NULL ) { PyErr_BadArgument(); return -1; } if ( (*pb->bf_getsegcount)(other, NULL) != 1 ) { /* ### use a different exception type/message? */ PyErr_SetString(PyExc_TypeError, "single-segment buffer object expected"); return -1; } if (!get_buf(self, &ptr1, &size, ANY_BUFFER)) return -1; if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 ) return -1; if ( left < 0 ) left = 0; else if ( left > size ) left = size; if ( right < left ) right = left; else if ( right > size ) right = size; slice_len = right - left; if ( count != slice_len ) { PyErr_SetString( PyExc_TypeError, "right operand length must match slice length"); return -1; } if ( slice_len ) memcpy((char *)ptr1 + left, ptr2, slice_len); return 0; }
static int buffer_getbuffer(PyBufferObject *self, Py_buffer *buf, int flags) { void *ptr; Py_ssize_t size; if (!get_buf(self, &ptr, &size, ANY_BUFFER)) return -1; return PyBuffer_FillInfo(buf, (PyObject*)self, ptr, size, self->b_readonly, flags); }
static Py_ssize_t buffer_length(PyBufferObject *self) { void *ptr; Py_ssize_t size; if (!get_buf(self, &ptr, &size, ANY_BUFFER)) return -1; return size; }
char * clnt_spcreateerror(char *s) { char *str = get_buf(); char *strend; if (str == 0) return(0); strend = str+BUFSIZ; (void) snprintf(str, strend-str, "%s: ", s); str[BUFSIZ - 1] = '\0'; (void) strncat(str, clnt_sperrno(rpc_createerr.cf_stat), BUFSIZ - 1); switch (rpc_createerr.cf_stat) { case RPC_PMAPFAILURE: (void) strncat(str, " - ", BUFSIZ - 1 - strlen(str)); (void) strncat(str, clnt_sperrno(rpc_createerr.cf_error.re_status), BUFSIZ - 1 - strlen(str)); break; case RPC_SYSTEMERROR: (void) strncat(str, " - ", BUFSIZ - 1 - strlen(str)); { const char *m = strerror(rpc_createerr.cf_error.re_errno); if (m) (void) strncat(str, m, BUFSIZ - 1 - strlen(str)); else (void) snprintf(&str[strlen(str)], BUFSIZ - strlen(str), "Error %d", rpc_createerr.cf_error.re_errno); } break; case RPC_CANTSEND: case RPC_CANTDECODERES: case RPC_CANTENCODEARGS: case RPC_SUCCESS: case RPC_UNKNOWNPROTO: case RPC_PROGNOTREGISTERED: case RPC_FAILED: case RPC_UNKNOWNHOST: case RPC_CANTDECODEARGS: case RPC_PROCUNAVAIL: case RPC_PROGVERSMISMATCH: case RPC_PROGUNAVAIL: case RPC_AUTHERROR: case RPC_VERSMISMATCH: case RPC_TIMEDOUT: case RPC_CANTRECV: default: break; } (void) strncat(str, "\n", BUFSIZ - 1 - strlen(str)); return (str); }
SANE_Status sane_read(SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int * len) { struct scanner *s = (struct scanner *) handle; int duplex = s->val[DUPLEX].w; struct buf *b = s->side == SIDE_FRONT ? &s->buf[0] : &s->buf[1]; SANE_Status err = buf_get_err(b); SANE_Int inbuf = 0; *len = 0; if (!s->scanning) return SANE_STATUS_EOF; if (err) goto out; if (s->read) { *len = max_len < (SANE_Int) s->read ? max_len : (SANE_Int) s->read; memcpy(buf, s->data + BUF_SIZE - s->read, *len); s->read -= *len; if (!s->read) pop_buf(b); goto out; } s->data = get_buf(b, &inbuf); if (!s->data) goto out; *len = max_len < inbuf ? max_len : inbuf; if (*len > BUF_SIZE) *len = BUF_SIZE; memcpy(buf, s->data, *len); s->read = inbuf > BUF_SIZE ? BUF_SIZE - *len : inbuf - *len; if (!s->read) pop_buf(b); out: err = *len ? SANE_STATUS_GOOD : buf_get_err(b); if (err == SANE_STATUS_EOF) { if (strcmp(s->val[FEEDER_MODE].s, SANE_I18N("continuous"))) { if (!duplex || s->side == SIDE_BACK) s->scanning = 0; } buf_deinit(b); } else if (err) { unsigned i; for (i = 0; i < sizeof(s->buf) / sizeof(s->buf[0]); i++) buf_deinit(&s->buf[i]); } return err; }
static int buffer_getsegcount(PyBufferObject *self, int *lenp) { void *ptr; int size; if (!get_buf(self, &ptr, &size)) return -1; if (lenp) *lenp = size; return 1; }
static Py_ssize_t buffer_getsegcount(PyBufferObject *self, Py_ssize_t *lenp) { void *ptr; Py_ssize_t size; if (!get_buf(self, &ptr, &size, ANY_BUFFER)) return -1; if (lenp) *lenp = size; return 1; }
static PyObject * buffer_subscript(PyBufferObject *self, PyObject *item) { void *p; Py_ssize_t size; if (!get_buf(self, &p, &size, ANY_BUFFER)) return NULL; if (PyIndex_Check(item)) { Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); if (i == -1 && PyErr_Occurred()) return NULL; if (i < 0) i += size; return buffer_item(self, i); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength, cur, i; if (PySlice_GetIndicesEx((PySliceObject*)item, size, &start, &stop, &step, &slicelength) < 0) { return NULL; } if (slicelength <= 0) return PyString_FromStringAndSize("", 0); else if (step == 1) return PyString_FromStringAndSize((char *)p + start, stop - start); else { PyObject *result; char *source_buf = (char *)p; char *result_buf = (char *)PyMem_Malloc(slicelength); if (result_buf == NULL) return PyErr_NoMemory(); for (cur = start, i = 0; i < slicelength; cur += step, i++) { result_buf[i] = source_buf[cur]; } result = PyString_FromStringAndSize(result_buf, slicelength); PyMem_Free(result_buf); return result; } } else { PyErr_SetString(PyExc_TypeError, "sequence index must be integer"); return NULL; } }
/*当接收中断来时调用此函数*/ static void get_recv_irg(void) { int i; for(i = 0; i < MAX_PORT; i++) { if(UART_GET_RST(i) & (i%8)) { get_buf(&serial_devp[i]); } } }
odp_buffer_t buffer_alloc(void *pool, size_t size) { struct pool_entry_s *pool_s = &((pool_entry_t *)pool)->s; uintmax_t totsize = size + pool_s->room_size; odp_buffer_hdr_t *buf; /* Reject oversized allocation requests */ if (odp_unlikely(size > pool_s->max_size)) return ODP_BUFFER_INVALID; /* Try to satisfy request from the local cache */ buf = get_local_buf(&pool_s->local_cache[local_id], pool_s, totsize); /* If cache is empty, satisfy request from the pool */ if (odp_unlikely(buf == NULL)) { buf = get_buf(pool_s); if (odp_unlikely(buf == NULL)) return ODP_BUFFER_INVALID; /* Get blocks for this buffer, if pool uses application data */ if (buf->size < totsize) { intmax_t needed = totsize - buf->size; do { uint8_t *blk = get_blk(pool_s); if (blk == NULL) { ret_buf(pool_s, buf); return ODP_BUFFER_INVALID; } buf->addr[buf->segcount++] = blk; needed -= pool_s->seg_size; } while (needed > 0); buf->size = buf->segcount * pool_s->seg_size; /* Record the hdr before the buffer head */ *(unsigned long *)(buf->addr[0] - ODP_HDR_BACK_PTR_SIZE) = (unsigned long)buf; } } /* Mark buffer as allocated */ buf->allocator = local_id; /* By default, buffers inherit their pool's zeroization setting */ buf->flags.zeroized = pool_s->flags.zeroized; /* By default, buffers are not associated with an ordered queue */ buf->origin_qe = NULL; return (odp_buffer_t)buf; }
/* * read_message -- read message sent over file descriptor fd * The message has the format outlined in vp_hdr.h * The caller specifies which message types she wants * by placing the relevant ids in msg_ids (e.g. "HDO" * means that we are interested in HELLO, DECISION and * OFFER messages only. * If the message being received is not of the ids * specidied, reception is aborted and read_message * returns an error. * * If the message is read in its entirety, pbuf * contains the payload, plen the length, and the * return value is the actuall message if received. * * Since pbuf is allocated here, it must be freed by * the caller. */ int read_message(FILE *fd, char *msg_ids, char **pbuf_p, int *plen_p) { char c; char cmd; int rval; char *pbuf; int plen; printf("reading message\n"); if ((cmd=getc(fd)) < 0) { perror("read_message: getc"); return(MSG_CMD_ERROR); } // here we only look at messages that have their ids in msg_ids if (strchr(msg_ids, cmd) == NULL) { int i; fprintf(stderr, "process_message: invalid message id '%c'\n", cmd); for (i=1; i < 20; i++) { if ((cmd=getc(fd)) < 0) { perror("read_message: getc"); return(MSG_CMD_ERROR); } putchar(cmd); } putchar('\n'); return(MSG_CMD_ERROR); } // read message length for (plen = 0; isdigit((c=getc(fd))); ) plen = plen *10 + (c - '0'); if (c != ':') { fprintf(stderr, "process_message: sync error, expected ':', got '%c'\n", c); return; } // get message if ((pbuf = malloc(plen+1)) == NULL) // need one extra byte for the EOS perror("calloc failed"); if ((rval = get_buf(fd, pbuf, plen)) < 0) perror("reading stream message"); pbuf[plen] = '\0'; *pbuf_p = pbuf; *plen_p = plen; return(cmd); }
static PyObject * buffer_concat(PyBufferObject *self, PyObject *other) { PyBufferProcs *pb = other->ob_type->tp_as_buffer; void *ptr1, *ptr2; char *p; PyObject *ob; Py_ssize_t size, count; if ( pb == NULL || pb->bf_getreadbuffer == NULL || pb->bf_getsegcount == NULL ) { PyErr_BadArgument(); return NULL; } if ( (*pb->bf_getsegcount)(other, NULL) != 1 ) { /* ### use a different exception type/message? */ PyErr_SetString(PyExc_TypeError, "single-segment buffer object expected"); return NULL; } if (!get_buf(self, &ptr1, &size, ANY_BUFFER)) return NULL; /* optimize special case */ if ( size == 0 ) { Py_INCREF(other); return other; } if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 ) return NULL; // Pyston change: no PY_SIZE_MAX // assert(count <= PY_SIZE_MAX - size); ob = PyString_FromStringAndSize(NULL, size + count); if ( ob == NULL ) return NULL; p = PyString_AS_STRING(ob); memcpy(p, ptr1, size); memcpy(p + size, ptr2, count); /* there is an extra byte in the string object, so this is safe */ p[size + count] = '\0'; return ob; }
static Py_ssize_t buffer_getreadbuf(PyBufferObject *self, Py_ssize_t idx, void **pp) { Py_ssize_t size; if ( idx != 0 ) { PyErr_SetString(PyExc_SystemError, "accessing non-existent buffer segment"); return -1; } if (!get_buf(self, pp, &size, READ_BUFFER)) return -1; return size; }
static PyObject * buffer_item(PyBufferObject *self, Py_ssize_t idx) { void *ptr; Py_ssize_t size; if (!get_buf(self, &ptr, &size, ANY_BUFFER)) return NULL; if ( idx < 0 || idx >= size ) { PyErr_SetString(PyExc_IndexError, "buffer index out of range"); return NULL; } return PyString_FromStringAndSize((char *)ptr + idx, 1); }
static int buffer_ass_item(PyBufferObject *self, Py_ssize_t idx, PyObject *other) { PyBufferProcs *pb; void *ptr1, *ptr2; Py_ssize_t size; Py_ssize_t count; if ( self->b_readonly ) { PyErr_SetString(PyExc_TypeError, "buffer is read-only"); return -1; } if (!get_buf(self, &ptr1, &size, ANY_BUFFER)) return -1; if (idx < 0 || idx >= size) { PyErr_SetString(PyExc_IndexError, "buffer assignment index out of range"); return -1; } pb = other ? other->ob_type->tp_as_buffer : NULL; if ( pb == NULL || pb->bf_getreadbuffer == NULL || pb->bf_getsegcount == NULL ) { PyErr_BadArgument(); return -1; } if ( (*pb->bf_getsegcount)(other, NULL) != 1 ) { /* ### use a different exception type/message? */ PyErr_SetString(PyExc_TypeError, "single-segment buffer object expected"); return -1; } if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 ) return -1; if ( count != 1 ) { PyErr_SetString(PyExc_TypeError, "right operand must be a single byte"); return -1; } ((char *)ptr1)[idx] = *(char *)ptr2; return 0; }
static long buffer_hash(PyBufferObject *self) { void *ptr; Py_ssize_t size; register Py_ssize_t len; register unsigned char *p; register long x; if ( self->b_hash != -1 ) return self->b_hash; /* XXX potential bugs here, a readonly buffer does not imply that the * underlying memory is immutable. b_readonly is a necessary but not * sufficient condition for a buffer to be hashable. Perhaps it would * be better to only allow hashing if the underlying object is known to * be immutable (e.g. PyString_Check() is true). Another idea would * be to call tp_hash on the underlying object and see if it raises * an error. */ if ( !self->b_readonly ) { PyErr_SetString(PyExc_TypeError, "writable buffers are not hashable"); return -1; } if (!get_buf(self, &ptr, &size, ANY_BUFFER)) return -1; p = (unsigned char *) ptr; len = size; /* We make the hash of the empty buffer be 0, rather than using (prefix ^ suffix), since this slightly obfuscates the hash secret */ if (len == 0) { self->b_hash = 0; return 0; } x = _Py_HashSecret.prefix; x ^= *p << 7; while (--len >= 0) x = (1000003*x) ^ *p++; x ^= size; x ^= _Py_HashSecret.suffix; if (x == -1) x = -2; self->b_hash = x; return x; }