bytes_t Mem :: copy ( const bytes_t & _amount, index_t dst_offset, const Mem & src, index_t src_offset ) { FUNC_ENTRY (); test_caps ( CAP_WRITE ); src . test_caps ( CAP_READ ); U64 amount = _amount; if ( dst_offset < 0 || ( U64 ) dst_offset >= bytes || src_offset < 0 || ( U64 ) src_offset >= src . bytes ) return bytes_t ( 0 ); if ( amount + dst_offset > bytes ) amount = ( U64 ) bytes - dst_offset; if ( amount + src_offset > src . bytes ) amount = ( U64 ) src . bytes - src_offset; if ( amount != 0 ) { char * dp = ( char * ) ptr; const char * sp = ( const char * ) src . ptr; memmove ( & dp [ dst_offset ], & sp [ src_offset ], ( size_t ) amount ); } return bytes_t ( amount ); }
Mem Mem :: subrange ( index_t offset, const bytes_t & _sz ) const { FUNC_ENTRY (); test_caps ( CAP_SUBRANGE ); U64 sz = _sz; Mem m ( * this ); if ( offset < ( I64 ) 0 || ( U64 ) offset >= bytes ) { m . ptr = ( void* ) & ( ( char* ) ptr ) [ bytes ]; m . bytes = ( U64 ) 0; } else { U64 b = ( U64 ) bytes - ( U64 ) offset; if ( sz > b ) sz = b; m . ptr = ( void* ) & ( ( char* ) ptr ) [ offset ]; m . bytes = sz; } return m; }
int sh1_read(void) { char c[4]; int ret; int key; t_win *term; term = g_memory(S_WIN, 0); if (initialize_read(term) == -1 || test_caps() == -1) return (-1); while (42) { ft_bzero(c, 4); if ((ret = read(STDIN_FILENO, c, 4)) < 0) return (int_error(EUNKNOW)); key = (c[3] << 24) + (c[2] << 16) + (c[1] << 8) + c[0]; ret = read_handler(term, key); if (ret == -1) return (-1); if (ret == ENDOF) return (end_of_read(term) == -1 ? -1 : 0); if (ret == RELAUNCH) if (relaunch_read(term) == -1) return (-1); } return (0); }
void Mem :: resize ( const bytes_t & sz, bool clear ) { FUNC_ENTRY (); test_caps ( CAP_RESIZE ); // early cheap detection of noop if ( sz == bytes ) return; // a null ref can be resized to allocate if ( ptr == 0 ) { assert ( bytes == ( U64 ) 0 ); #ifdef _hpp_vdb3_rsrc_ * this = rsrc -> mmgr . alloc ( sz, clear ); #else CONST_THROW ( xc_unimplemented_err, "unimplemented" ); #endif } else { assert ( bytes != ( U64 ) 0 ); MemoryItf * itf = get_itf ( CAP_RESIZE ); // there are cases when the obj can be null if ( itf == 0 ) { #ifdef _hpp_vdb3_rsrc_ // ref represents constant data, not heap data Mem tmp = rsrc -> mmgr . alloc ( sz, false ); // copy in data from self bytes_t num_writ = tmp . copy ( bytes, 0, * this, 0 ); if ( bytes >= sz ) assert ( num_writ == sz ); else { assert ( num_writ == bytes ); if ( clear ) { bytes_t num_zeroed = tmp . fill ( ( U64 ) sz - bytes, ( I64 ) ( U64 ) num_writ, 0 ); assert ( num_writ + num_zeroed == sz ); } } * this = tmp; #else CONST_THROW ( xc_unimplemented_err, "unimplemented" ); #endif } else { // normal case itf -> resize ( sz, clear ); ptr = itf -> get_mapped_memory ( & bytes ); } } }
index_t Mem :: find_first ( U8 byte ) const { FUNC_ENTRY (); test_caps ( CAP_READ ); void * loc = memchr ( ptr, byte, bytes ); if ( loc != 0 ) return ( char * ) loc - ( char * ) ptr; return ( I64 ) -1; }
index_t Mem :: find_first ( U8 byte, index_t offset ) const { FUNC_ENTRY (); test_caps ( CAP_READ ); if ( offset < ( I64 ) 0 || ( U64 ) offset >= bytes ) return -1; const char * p = ( const char * ) ptr; void * loc = memchr ( & p [ offset ], byte, bytes - ( U64 ) offset ); if ( loc != 0 ) return ( const char * ) loc - p; return ( I64 ) -1; }
bool Mem :: operator != ( const Mem & m ) const { FUNC_ENTRY (); test_caps ( CAP_READ ); m . test_caps ( CAP_READ ); if ( bytes == m . bytes ) { if ( ptr == m . ptr ) return false; return memcmp ( ptr, m . ptr, bytes ) != 0; } return true; }
int main(int argc, char *argv[]) { display = get_display(); /* get an appropriate EGL frame buffer configuration */ ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config)); DEBUG_MSG("num_config: %d", num_config); /* create an EGL rendering context */ ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list)); test_caps(); ECHK(eglTerminate(display)); }
bytes_t Mem :: fill ( count_t repeat, index_t offset, U8 byte ) { FUNC_ENTRY (); test_caps ( CAP_WRITE ); if ( offset < 0 || ( U64 ) offset >= bytes ) return bytes_t ( 0 ); if ( repeat + offset > bytes ) repeat = ( U64 ) bytes - offset; if ( repeat != 0 ) { char * p = ( char * ) ptr; memset ( & p [ offset ], byte, ( size_t ) repeat ); } return bytes_t ( repeat ); }
Mem Mem :: subrange ( index_t offset ) const { FUNC_ENTRY (); test_caps ( CAP_SUBRANGE ); Mem m ( * this ); if ( offset < ( I64 ) 0 || ( U64 ) offset >= bytes ) { m . ptr = ( void* ) & ( ( char* ) ptr ) [ bytes ]; m . bytes = ( U64 ) 0; } else { m . ptr = ( void* ) & ( ( char* ) ptr ) [ offset ]; m . bytes = ( U64 ) bytes - ( U64 ) offset; } return m; }
index_t Mem :: find_first ( U8 byte, index_t offset, const bytes_t & _sz ) const { FUNC_ENTRY (); test_caps ( CAP_READ ); size_t sz = _sz; if ( offset < ( I64 ) 0 || ( U64 ) offset >= bytes ) return -1; if ( sz + offset > bytes ) sz = bytes - ( U64 ) offset; const char * p = ( const char * ) ptr; void * loc = memchr ( & p [ offset ], byte, sz ); if ( loc != 0 ) return ( const char * ) loc - p; return ( I64 ) -1; }
CopyUntilRslt Mem :: copy_until ( const bytes_t & _amount, U8 stop_byte, index_t dst_offset, const Mem & src, index_t src_offset ) { FUNC_ENTRY (); test_caps ( CAP_WRITE ); src . test_caps ( CAP_READ ); U64 amount = _amount; bool found = false; if ( dst_offset < 0 || ( U64 ) dst_offset >= bytes || src_offset < 0 || ( U64 ) src_offset >= src . bytes ) return CopyUntilRslt ( 0, false ); if ( amount + dst_offset > bytes ) amount = ( U64 ) bytes - dst_offset; if ( amount + src_offset > src . bytes ) amount = ( U64 ) src . bytes - src_offset; if ( amount != 0 ) { U8 * dp = ( U8 * ) ptr + dst_offset; const U8 * sp = ( const U8 * ) src . ptr + src_offset; for ( U64 i = 0; i < amount; ++ i ) { if ( ( dp [ i ] = sp [ i ] ) == stop_byte ) { amount = i + 1; found = true; break; } } } return CopyUntilRslt ( amount, found ); }
T * get_itf ( caps_t required ) const { test_caps ( required ); return itf; }
bytes_t Mem :: size () const { FUNC_ENTRY (); test_caps ( CAP_PROP_READ ); return bytes; }