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;
}
