// Consume the specified number of bytes from the buffers.
  void consume(std::size_t size)
  {
    // Remove buffers from the start until the specified size is reached.
    while (size > 0 && !at_end_)
    {
      if (buffer_size(first_) <= size)
      {
        size -= buffer_size(first_);
        if (begin_remainder_ == buffers_.end())
          at_end_ = true;
        else
          first_ = *begin_remainder_++;
      }
      else
      {
        first_ = first_ + size;
        size = 0;
      }
    }

    // Remove any more empty buffers at the start.
    while (!at_end_ && buffer_size(first_) == 0)
    {
      if (begin_remainder_ == buffers_.end())
        at_end_ = true;
      else
        first_ = *begin_remainder_++;
    }
  }
Beispiel #2
0
/// Create a new non-modifiable buffer from an existing buffer.
inline const_buffer_container_1 buffer(const const_buffer& b,
    std::size_t max_size_in_bytes)
{
  return const_buffer_container_1(
      const_buffer(buffer_cast<const void*>(b),
        buffer_size(b) < max_size_in_bytes
        ? buffer_size(b) : max_size_in_bytes));
}
Beispiel #3
0
/// Create a new modifiable buffer from an existing buffer.
inline mutable_buffer_container_1 buffer(const mutable_buffer& b,
    std::size_t max_size_in_bytes)
{
  return mutable_buffer_container_1(
      mutable_buffer(buffer_cast<void*>(b),
        buffer_size(b) < max_size_in_bytes
        ? buffer_size(b) : max_size_in_bytes));
}
Beispiel #4
0
/**
 * @relates const_buffer
 */
inline const_buffer operator+(std::size_t start, const const_buffer& b)
{
  if (start > buffer_size(b))
    return const_buffer();
  const char* new_data = buffer_cast<const char*>(b) + start;
  std::size_t new_size = buffer_size(b) - start;
  return const_buffer(new_data, new_size);
}
Beispiel #5
0
/**
 * @relates mutable_buffer
 */
inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
{
  if (start > buffer_size(b))
    return mutable_buffer();
  char* new_data = buffer_cast<char*>(b) + start;
  std::size_t new_size = buffer_size(b) - start;
  return mutable_buffer(new_data, new_size);
}
Beispiel #6
0
static bool need_wrap(struct buffer * buffer)
{
    if (buffer == &primary_buf)
	return buffer_size(buffer) + indent_size() == max_columns;
    else
	return (buffer_size(&primary_buf) + buffer_size(&tag_buf)
		+ buffer_size(buffer) + indent_size()) >= max_columns;
}
Beispiel #7
0
void Attribute::resize(Mesh *mesh, AttributePrimitive prim, bool reserve_only)
{
	if(reserve_only) {
		buffer.reserve(buffer_size(mesh, prim));
	}
	else {
		buffer.resize(buffer_size(mesh, prim), 0);
	}
}
Beispiel #8
0
mutable_buffer save(mutable_buffer& buffer, const mutable_buffer& v)
{
	if(buffer_size(buffer) < buffer_size(v)) {
		throw serialization_error("not enough buffer");
	}

	memcpy(buffer_cast<uint8*>(buffer), buffer_cast<uint8*>(v), buffer_size(v));
	return buffer + buffer_size(v);
}
Beispiel #9
0
/*
 * pconn is proxy --> server, and has no buffer.
 */
int write_server_handle( conn_t *pconn )
{
	log_message( LOG_DEBUG, "in write_server_handle" );

	//如果client_conn已经关闭,还是需要把剩余数据发送给server端
	if ( NULL == pconn->write_buffer ) {
		log_message( LOG_ERROR, "write_server_handle: write_buffer is NULL." );
		return -1;
	}
	if ( 1 == pconn->write_closed ) {
		log_message( LOG_WARNING, "try writing to server[%s] fd[%d], but it closed write", 
				inet_ntoa(pconn->addr.sin_addr), pconn->fd );
		return -1;
	}

	int bytes;
	bytes = write_buffer( pconn->fd, pconn->write_buffer );
	log_message( LOG_DEBUG, "send to server[%s:%d] %d bytes.\n",  inet_ntoa(pconn->addr.sin_addr), ntohs(pconn->addr.sin_port), bytes );

	if ( g_errno < 0 ) {					//写出错
		CONN_CLOSE_WRITE( pconn );
		if ( 1 == pconn->read_closed )
			return -1;
	}
	else {
		if ( 0==buffer_size(pconn->write_buffer) &&			//发送完缓冲区中的数据
			( NULL==pconn->server_conn ||					//并且客户端不会再有数据过来
				1 == pconn->server_conn->read_closed ) )  {
			CONN_CLOSE_WRITE( pconn );
			if ( 1 == pconn->read_closed )
				return -1;
		}
	}

	/*
	 * it's very important
	 */
	uint32_t clientf = 0, serverf = 0;
	//写缓存中还有数据
	if ( 0 == pconn->write_closed && buffer_size( pconn->write_buffer ) > 0 )
		serverf |= EPOLLOUT;
	//读缓存未满并且未关闭读
	if ( 0 == pconn->read_closed && buffer_size( pconn->read_buffer ) < MAXBUFFSIZE )	
		serverf |= EPOLLIN;			//继续侦听读事件
	epoll_mod_connection( pconn, serverf );

	conn_t	*pclie_conn;
	if ( NULL != ( pclie_conn = pconn->server_conn ) ) {
		if ( 0 == pclie_conn->write_closed && buffer_size( pclie_conn->write_buffer ) > 0 )
			clientf |= EPOLLOUT;
		if ( 0 == pclie_conn->read_closed && buffer_size( pclie_conn->read_buffer ) < MAXBUFFSIZE )
			clientf |= EPOLLIN;
		epoll_mod_connection( pclie_conn, clientf );
	}

	return TRUE;
}
Beispiel #10
0
bool Lexer::skipComments()
{
	// We need to ensure that we have enough characters in the buffer.
	switch (buffer_size()) {
	case 0:
		buffer_put(m_input->get());
	case 1:
		buffer_put(m_input->get());
	case 2:
		buffer_put(m_input->get());
	case 3:
		buffer_put(m_input->get());
	}

	// We have a comment iff it begins with '<!--' sequence.
	if (!(buffer_at(0) == '<' &&
	      buffer_at(1) == '!' &&
	      buffer_at(2) == '-' &&
	      buffer_at(3) == '-'))
	{
		return false;
	}

	buffer_pop();
	buffer_pop();
	buffer_pop();
	buffer_pop();

	for (;;) {
		// TODO: Handle unclosed comments.

		// As above, we enusre that we have enough characters available.
		switch (buffer_size()) {
		case 0:
			buffer_put(m_input->get());
		case 1:
			buffer_put(m_input->get());
		case 2:
			buffer_put(m_input->get());
		}

		// The comment ends only with the '-->' sequence.
		if (buffer_at(0) == '-' &&
		    buffer_at(1) == '-' &&
		    buffer_at(2) == '>')
		{
			buffer_pop();
			buffer_pop();
			buffer_pop();
			break;
		}

		buffer_pop();
	}

	return true;
}
Beispiel #11
0
static void content(void)
{
    char current;

    /*
     * We should get one character at a time.
     */
    assert(strlen(yytext) == 1);

    current = yytext[0];
    if (current == EOF)
	return;
    
    if (is_newline(current)) {
	 newline();
	 return;
    }
    buffer_push_char(current_buf, current);

    /*
     * Forcing newline changes 'text' so lets do it after we've pushed
     * it to the buffer.
     */
    if (wrap_long_lines && need_wrap(current_buf)) {
	struct buffer tmp;
	buffer_init(&tmp, buffer_size(current_buf));
	/*
	 * Find last character that was not whitespace
	 */
	for (;;) {
	    int c;
	    if (buffer_size(current_buf) == 0)
		break;

	    c = buffer_pop_char(current_buf);
	    if (is_whitespace(c)) {
		/*
		 * Do not push whitespace because it would appear
		 * after the newline.
		 */
		break;
	    }
	    /*
	     * Characters are put in tmp buffer in reverse order.
	     */
	    buffer_push_char(&tmp, c);
	}
	force_newline_for_wrap(current_buf);
	/*
	 * Restore non-wrapped text into buffer.
	 */
	while (buffer_size(&tmp) > 0) {
	    buffer_push_char(current_buf, buffer_pop_char(&tmp));
	}
	buffer_release(&tmp);
    }
}
Beispiel #12
0
void Attribute::reserve(int numverts, int numtris, int numsteps, int numcurves, int numkeys, bool resize)
{
	if (resize) {
		buffer.resize(buffer_size(numverts, numtris, numsteps, numcurves, numkeys), 0);
	}
	else {
		buffer.reserve(buffer_size(numverts, numtris, numsteps, numcurves, numkeys));
	}
}
Beispiel #13
0
const_buffer load(const_buffer& buffer, const_buffer& v)
{
	if(buffer_size(buffer) < buffer_size(v)) {
		throw serialization_error("not enough buffer");
	}

	memcpy(const_cast<uint8*>(buffer_cast<const uint8*>(v))
		, buffer_cast<const uint8*>(buffer), buffer_size(v));
	return buffer + buffer_size(v);
}
Beispiel #14
0
 bool equal(const consuming_buffers_iterator& other) const
 {
   if (at_end_ && other.at_end_)
     return true;
   return !at_end_ && !other.at_end_
     && buffer_cast<const void*>(first_)
       == buffer_cast<const void*>(other.first_)
     && buffer_size(first_) == buffer_size(other.first_)
     && begin_remainder_ == other.begin_remainder_
     && end_remainder_ == other.end_remainder_;
 }
Beispiel #15
0
/**
 * VMNative: string_prealloc( workshop , newsize )
 * Accepts a workshop argument and a number. The newsize is the size to
 * reallocate the workshop buffer to. Preallocate buffer for best performance.
 */
static bool vmn_str_prealloc(VM * vm, VMArg * arg, int argc) {
  VMLibData * data;
  Buffer * buffer;
  int newSize;

  /* check for proper number of arguments */
  if(argc != 2) {
    vm_set_err(vm, VMERR_INCORRECT_NUMARGS);
    return false;
  }

  /* check argument 1 major type */
  if(vmarg_type(arg[0]) != TYPE_LIBDATA) {
    vm_set_err(vm, VMERR_INVALID_TYPE_ARGUMENT);
    return false;
  }

  /* extract the libdata from the argument */
  data = vmarg_libdata(arg[0]);

  /* check libdata type */
  if(!vmlibdata_is_type(data, LIBSTR_STRING_TYPE, LIBSTR_STRING_TYPE_LEN)) {
    vm_set_err(vm, VMERR_INVALID_TYPE_ARGUMENT);
    return false;
  }

  /* check argument 2 type */
  if(vmarg_type(arg[1]) != TYPE_NUMBER) {
    vm_set_err(vm, VMERR_INVALID_TYPE_ARGUMENT);
    return false;
  }

  newSize = (int)vmarg_number(arg[1], NULL);

  /* check buffer size range */
  if(newSize < 1) {
    vm_set_err(vm, VMERR_ARGUMENT_OUT_OF_RANGE);
    return false;
  }

  /* extract the workshop */
  buffer = vmlibdata_data(data);

  /* can't make it smaller, only bigger */
  buffer_resize(buffer, newSize >= buffer_size(buffer)
		? newSize : buffer_size(buffer));

  /* push null result */
  vmarg_push_null(vm);

  /* this function does return a value */
  return true;
}
void stream_check_test(Buffer_Set *buffers, void *scratch, int scratch_size){
    int i, page_size, size;
    
    size = buffer_size(&buffers->buffer);
    {
        int size2;
        size2 = buffer_size(&buffers->gap_buffer);
        hard_assert_4tech(size == size2);
        size2 = buffer_size(&buffers->multi_gap_buffer);
        hard_assert_4tech(size == size2);
        size2 = buffer_size(&buffers->rope_buffer);
        hard_assert_4tech(size == size2);
    }

    page_size = 1 << 10;

    char *page_1 = (char*)scratch;
    char *page_2 = page_1 + page_size;
    scratch_size -= page_size*2;
    hard_assert_4tech(scratch_size > 0);
    
    for (i = 0; i < size; i += page_size){
        int end = i + page_size;
        if (end > size) end = size;
        
        buffer_stringify(&buffers->buffer, i, end, page_1);
        
        buffer_stringify(&buffers->gap_buffer, i, end, page_2);
        page_compare(page_1, page_2, page_size);
        
        buffer_stringify(&buffers->multi_gap_buffer, i, end, page_2);
        page_compare(page_1, page_2, page_size);
        
        buffer_stringify(&buffers->rope_buffer, i, end, page_2);
        page_compare(page_1, page_2, page_size);
    }

    for (i = size-1; i > 0; i -= page_size){
        int end = i - page_size;
        if (end < 0) end = 0;
        
        buffer_backify(&buffers->buffer, i, end, page_1);
        
        buffer_backify(&buffers->gap_buffer, i, end, page_2);
        page_compare(page_1, page_2, page_size);
        
        buffer_backify(&buffers->multi_gap_buffer, i, end, page_2);
        page_compare(page_1, page_2, page_size);
        
        buffer_backify(&buffers->rope_buffer, i, end, page_2);
        page_compare(page_1, page_2, page_size);
    }
}
Beispiel #17
0
int qmux_fill(u16 cid, struct buffer *buf)
{
	struct qmux *qmux = buffer_data(buf);

	if (buffer_size(buf) < sizeof(*qmux))
		return -ENOMEM;

	qmux->tf = 1;
	qmux->len = buffer_size(buf) - 1;
	qmux->ctrl = 0;
	qmux->service = cid & 0xff;
	qmux->qmicid = cid >> 8;
	return 0;
}
Beispiel #18
0
static int
check_size(const struct buffer *b, size_t offset, size_t size, const char *desc)
{
	if (size == 0)
		return 0;

	if (offset >= buffer_size(b) || (offset + size) > buffer_size(b)) {
		ERROR("The file is not large enough for the '%s'. "
		      "%zu bytes @ offset %zu, input %zu bytes.\n",
		      desc, size, offset, buffer_size(b));
		return -1;
	}
	return 0;
}
Beispiel #19
0
void data_received(endpoint_t ep, int err, size_t bytes, size_t more_bytes, buffer_t *buffer, void *ctx) {
    context_t *context = ctx;

    fprintf(stdout, "Receival error: %d: %s\n", err, strerror(err));
    if(err) {
        io_service_stop(context->service, true);
        return;
    }

    fprintf(stdout, "Data received (size: %llu): %.*s\n",
            buffer_size(buffer), buffer_size(buffer), buffer_data(buffer));

    io_service_stop(context->service, true);
}
Beispiel #20
0
/*
 * pconn: client --> proxy, its buffer isn't NULL
 */
int write_client_handle( conn_t *pconn )
{
	log_message( LOG_DEBUG, "in write_client_handle" );

	if ( 1 == pconn->write_closed ) {
		log_message( LOG_WARNING, "try writing to client[%s:%d], but it closed write", inet_ntoa(pconn->addr.sin_addr), ntohs(pconn->addr.sin_port) );
		return -1;
	}

	int bytes;
	bytes = write_buffer( pconn->fd, pconn->write_buffer );
	log_message( LOG_DEBUG, "write %d bytes to client[%s:%d].", bytes, inet_ntoa(pconn->addr.sin_addr), ntohs(pconn->addr.sin_port) );

	if ( g_errno < 0 ) {		//写出错
		CONN_CLOSE_WRITE( pconn );
		if ( 1 == pconn->read_closed )
			return -1;
	}
	else {
		if ( 0==buffer_size(pconn->write_buffer) &&			//发送完缓冲区中的数据
			( NULL==pconn->server_conn ||					//并且server已经不再写
				( NULL!=pconn->server_conn && 1 == pconn->server_conn->read_closed )) )  {
			CONN_CLOSE_WRITE( pconn );
			if ( 1 == pconn->read_closed )
				return -1;
		}
	}

	/*
	 * it's very important
	 */
	uint32_t clientf = 0, serverf = 0;
	if ( NULL != pconn->server_conn ) {
		conn_t	*pserv_conn = pconn->server_conn;
		if ( 0 == pserv_conn->write_closed && buffer_size( pserv_conn->write_buffer ) > 0 )
			serverf |= EPOLLOUT;
		if ( 0 == pserv_conn->read_closed && buffer_size( pserv_conn->read_buffer ) < MAXBUFFSIZE )
			serverf |= EPOLLIN;
		epoll_mod_connection( pserv_conn, serverf );
	}

	if ( 0 == pconn->write_closed && buffer_size( pconn->write_buffer ) > 0 )
		clientf |= EPOLLOUT;
	if ( 0 == pconn->read_closed && buffer_size( pconn->read_buffer ) < MAXBUFFSIZE )
		clientf |= EPOLLIN;
	epoll_mod_connection( pconn, clientf );

	return 0;
}
Beispiel #21
0
//实现随机存取,迭代器可以直接跳跃n个距离
  self& operator+=(difference_type n)
  {
    difference_type offset = n + (cur - first);
    if (offset >= 0 && offset < difference_type(buffer_size()))
      cur += n; //目标位置在同一缓冲区内
    else {  //目标位置不在同一缓冲区内
      difference_type node_offset =
        offset > 0 ? offset / difference_type(buffer_size())
                   : -difference_type((-offset - 1) / buffer_size()) - 1;
      set_node(node + node_offset);  //切换到正确的节点(缓冲区)
	  //切换到正确的元素
      cur = first + (offset - node_offset * difference_type(buffer_size()));
    }
    return *this;
  }
Beispiel #22
0
void
ramp_request_proxy (void* state, void* param, bid_t bid)
{
  ramp_t* ramp = state;
  assert (ramp != NULL);

  assert (buffer_size (bid) == sizeof (proxy_request_t));

  const proxy_request_t* request = buffer_read_ptr (bid);
  ramp_proxy_t* ramp_proxy = malloc (sizeof (ramp_proxy_t));
  ramp_proxy->request = *request;
  assert (automan_declare (ramp->automan,
			   &ramp_proxy->composed,
			   ramp_proxy,
			   ramp_declared,
			   ramp_proxy) == 0);
  assert (automan_create (ramp->automan,
			  &ramp_proxy->aid,
			  &ramp_proxy_descriptor,
			  NULL,
			  ramp_proxy_created,
			  ramp_proxy) == 0);
  assert (automan_compose (ramp->automan,
			   &ramp_proxy->composed,
			   &ramp->self,
			   ramp_integer_out,
			   ramp_proxy,
			   &ramp_proxy->aid,
			   ramp_proxy_integer_in,
			   NULL,
			   NULL,
			   NULL) == 0);
  assert (schedule_system_output () == 0);
}
Beispiel #23
0
/**
	file_read : 'file -> s:string -> p:int -> l:int -> int
	<doc>
	Read up to [l] chars into the string [s] starting at position [p].
	Returns the number of chars readed which is > 0 (or 0 if l == 0).
	</doc>
**/
static value file_read( value o, value s, value pp, value n ) {
	fio *f;
	int p;
	int len;
	int buf_len;
	val_check_kind(o,k_file);
	val_check(s,buffer);
	buffer buf = val_to_buffer(s);
	buf_len = buffer_size(buf);
	val_check(pp,int);
	val_check(n,int);
	f = val_file(o);
	p = val_int(pp);
	len = val_int(n);
	if( p < 0 || len < 0 || p > buf_len || p + len > buf_len )
		return alloc_null();
	gc_enter_blocking();
	while( len > 0 ) {
		int d;
		POSIX_LABEL(file_read_again);
		d = (int)fread(buffer_data(buf)+p,1,len,f->io);
		if( d <= 0 ) {
			int size = val_int(n) - len;
			HANDLE_FINTR(f->io,file_read_again);
			if( size == 0 )
				file_error("file_read",f);
			return alloc_int(size);
		}
		p += d;
		len -= d;
	}
	gc_exit_blocking();
	return n;
}
Beispiel #24
0
 void increment()
 {
   if (!at_end_)
   {
     if (begin_remainder_ == end_remainder_
         || offset_ + buffer_size(first_) >= max_size_)
     {
       at_end_ = true;
     }
     else
     {
       offset_ += buffer_size(first_);
       first_ = buffer(*begin_remainder_++, max_size_ - offset_);
     }
   }
 }
Beispiel #25
0
size_t
octstr_len(const octstr_t *octstr)
{
	assert(octstr != NULL);

	return buffer_size(octstr->buf);
}
Beispiel #26
0
static value socket_recv_from( value o, value dataBuf, value pos, value len, value addr ) {
	int p,l,ret;
	int retry = 0;
	struct sockaddr_in saddr;
	SockLen slen = sizeof(saddr);
	val_check_kind(o,k_socket);
	val_check(dataBuf,buffer);
	buffer buf = val_to_buffer(dataBuf);
   char *data = buffer_data(buf);
   int dlen = buffer_size(buf);
	val_check(pos,int);
	val_check(len,int);
	val_check(addr,object);
	p = val_int(pos);
	l = val_int(len);

	if( p < 0 || l < 0 || p > dlen || p + l > dlen )
		neko_error();
   SOCKET sock = val_sock(o);
   gc_enter_blocking();
	POSIX_LABEL(recv_from_again);
	if( retry++ > NRETRYS ) {
      ret = recv(sock,data+p,l,MSG_NOSIGNAL);
	} else
		ret = recvfrom(sock, data + p , l, MSG_NOSIGNAL, (struct sockaddr*)&saddr, &slen);
	if( ret == SOCKET_ERROR ) {
		HANDLE_EINTR(recv_from_again);
		return block_error();
	}
   gc_exit_blocking();
	alloc_field(addr,f_host,alloc_int32(*(int*)&saddr.sin_addr));
	alloc_field(addr,f_port,alloc_int(ntohs(saddr.sin_port)));
	return alloc_int(ret);
}
Beispiel #27
0
/**
	socket_send_to : 'socket -> buf:string -> pos:int -> length:int -> addr:{host:'int32,port:int} -> int
	<doc>
	Send data from an unconnected UDP socket to the given address.
	</doc>
**/
static value socket_send_to( value o, value dataBuf, value pos, value len, value vaddr ) {
	int p,l;
	value host, port;
	struct sockaddr_in addr;
	val_check_kind(o,k_socket);
   buffer buf = val_to_buffer(dataBuf);
	const char *cdata = buffer_data(buf);
	int dlen = buffer_size(buf);
	val_check(pos,int);
	val_check(len,int);
	val_check(vaddr,object);
	host = val_field(vaddr, f_host);
	port = val_field(vaddr, f_port);
	val_check(host,int);
	val_check(port,int);
	p = val_int(pos);
	l = val_int(len);
	memset(&addr,0,sizeof(addr));
	addr.sin_family = AF_INET;
	addr.sin_port = htons(val_int(port));
	*(int*)&addr.sin_addr.s_addr = val_int(host);
	if( p < 0 || l < 0 || p > dlen || p + l > dlen )
		neko_error();

   SOCKET sock = val_sock(o);
	gc_enter_blocking();
	POSIX_LABEL(send_again);
	dlen = sendto(sock, cdata + p , l, MSG_NOSIGNAL, (struct sockaddr*)&addr, sizeof(addr));
	if( dlen == SOCKET_ERROR ) {
		HANDLE_EINTR(send_again);
		return block_error();
	}
	gc_exit_blocking();
	return alloc_int(dlen);
}
    DEFINE_FUNC_1(webp_decode_argb, data_buffer_value) {
        if (!val_is_buffer(data_buffer_value)) {
            val_throw(alloc_string("webp_decode_argb: Expected to be a buffer"));
            return alloc_null();
        }
        buffer data_buffer = val_to_buffer(data_buffer_value);
        int    data_len = buffer_size(data_buffer);
        char  *data_ptr = buffer_data(data_buffer);
        int webp_width = -1, webp_height = -1;
        char *webp_data_ptr = (char *)WebPDecodeARGB((const unsigned char *)data_ptr, data_len, &webp_width, &webp_height);
        int webp_data_len = webp_width * webp_height * 4;

        if (webp_data_ptr == NULL) {
            val_throw(alloc_string("webp_decode_argb: Invalid webp data"));
            return alloc_null();
        }

        buffer webp_buffer = alloc_buffer_len(0);
        buffer_append_sub(webp_buffer, webp_data_ptr, webp_data_len);
        buffer_set_size(webp_buffer, webp_data_len);

        value array = alloc_array(3);
        val_array_set_i(array, 0, alloc_int(webp_width));
        val_array_set_i(array, 1, alloc_int(webp_height));
        val_array_set_i(array, 2, buffer_val(webp_buffer));

        if (webp_data_ptr != NULL) free(webp_data_ptr);

        return array;
    }
void BufferedFile::refill_buffer() {
  if (at_eof()) {
    return;
  }
  int bytes_to_read = buffer_size();
  int max = file_size() - file_pos();
  if (bytes_to_read > max) {
    bytes_to_read = max;
  }

  int count_read;
  {
    // The file_pointer() may be shared with a FileDecoder
    // object. This may cause BufferedFile::file_pos() to become out
    // of date. A call to OsFile_seek() makes everything consistent again.
    AllocationDisabler raw_pointers_used_in_this_block;
    Buffer::Raw fb = data_buffer();
    OsFile_seek(file_pointer(), file_pos(), SEEK_SET);
    count_read = OsFile_read(file_pointer(), fb().base_address(),
                             1, bytes_to_read);
  }

  set_count(count_read);
  set_file_pos(long(file_pos() + count_read));
  set_index(0);
  if (count_read <= 0) {
     set_at_eof(true);
  }
  return;
}
Beispiel #30
0
int fix_message_parse(struct fix_message *self, struct buffer *buffer)
{
	int ret = FIX_MSG_STATE_PARTIAL;
	unsigned long size;
	const char *start;

	self->head_buf = buffer;

retry:
	start	= buffer_start(buffer);
	size	= buffer_size(buffer);

	if (!size)
		goto fail;

	ret = first_three_fields(self);
	if (ret)
		goto fail;

	ret = checksum(self, buffer);
	if (ret)
		goto fail;

	rest_of_message(self, buffer);

	return 0;

fail:
	if (ret != FIX_MSG_STATE_PARTIAL)
		goto retry;

	buffer_advance(buffer, start - buffer_start(buffer));

	return -1;
}