*x = y.f;
}
-void
+__clib_export void
serialize_cstring (serialize_main_t * m, char *s)
{
u32 len = s ? strlen (s) : 0;
if (len > 0)
{
p = serialize_get (m, len);
- clib_memcpy (p, s, len);
+ clib_memcpy_fast (p, s, len);
}
}
-void
+__clib_export void
unserialize_cstring (serialize_main_t * m, char **s)
{
char *p, *r = 0;
{
r = vec_new (char, len + 1);
p = unserialize_get (m, len);
- clib_memcpy (r, p, len);
+ clib_memcpy_fast (r, p, len);
/* Null terminate. */
r[len] = 0;
u8 *s = va_arg (*va, u8 *);
u32 n = va_arg (*va, u32);
u8 *p = serialize_get (m, n * sizeof (u8));
- clib_memcpy (p, s, n * sizeof (u8));
+ clib_memcpy_fast (p, s, n * sizeof (u8));
}
void
u8 *s = va_arg (*va, u8 *);
u32 n = va_arg (*va, u32);
u8 *p = unserialize_get (m, n);
- clib_memcpy (s, p, n);
+ clib_memcpy_fast (s, p, n);
}
#define _(n_bits) \
#define SERIALIZE_VECTOR_CHUNK_SIZE 64
-void
+__clib_export void
serialize_vector (serialize_main_t * m, va_list * va)
{
void *vec = va_arg (*va, void *);
if (l > max_length)
serialize_error (&m->header,
clib_error_create ("bad vector length %d", l));
- p = v = _vec_resize (0, l, (uword) l * elt_bytes, header_bytes,
+ p = v = _vec_resize ((void *) 0, l, (uword) l * elt_bytes, header_bytes,
/* align */ align);
while (l != 0)
f);
}
-void
+__clib_export void
unserialize_vector (serialize_main_t * m, va_list * va)
{
void **vec = va_arg (*va, void **);
return 0;
}
- v = _vec_resize (0, l, (uword) l * elt_bytes, sizeof (p[0]), align);
+ v = _vec_resize ((void *) 0, l, (uword) l * elt_bytes, sizeof (p[0]),
+ align);
p = pool_header (v);
vec_unserialize (m, &p->free_indices, unserialize_vec_32);
return;
}
- memset (&h, 0, sizeof (h));
+ clib_memset (&h, 0, sizeof (h));
#define _(f) unserialize_integer (m, &h.f, sizeof (h.f));
foreach_serialize_heap_header_integer;
#undef _
void *p;
serialize_integer (m, magic_bytes, sizeof (magic_bytes));
p = serialize_get (m, magic_bytes);
- clib_memcpy (p, magic, magic_bytes);
+ clib_memcpy_fast (p, magic, magic_bytes);
}
void
goto bad;
}
-clib_error_t *
+__clib_export clib_error_t *
va_serialize (serialize_main_t * sm, va_list * va)
{
serialize_main_header_t *m = &sm->header;
return error;
}
-clib_error_t *
+__clib_export clib_error_t *
serialize (serialize_main_t * m, ...)
{
clib_error_t *error;
return error;
}
-clib_error_t *
+__clib_export clib_error_t *
unserialize (serialize_main_t * m, ...)
{
clib_error_t *error;
if (n_left_o > 0 && n_left_b > 0)
{
uword n = clib_min (n_left_b, n_left_o);
- clib_memcpy (s->buffer + cur_bi, s->overflow_buffer, n);
+ clib_memcpy_fast (s->buffer + cur_bi, s->overflow_buffer, n);
cur_bi += n;
n_left_b -= n;
n_left_o -= n;
return vec_elt_at_index (s->overflow_buffer, cur_oi);
}
-void *
+__clib_export void *
serialize_read_write_not_inline (serialize_main_header_t * m,
serialize_stream_t * s,
uword n_bytes, uword flags)
vec_free (s->overflow_buffer);
}
-void
+__clib_export void
serialize_close (serialize_main_t * m)
{
serialize_read_write_close (&m->header, &m->stream,
SERIALIZE_FLAG_IS_WRITE);
}
-void
+__clib_export void
unserialize_close (serialize_main_t * m)
{
serialize_read_write_close (&m->header, &m->stream, SERIALIZE_FLAG_IS_READ);
}
-void
+__clib_export void
serialize_open_data (serialize_main_t * m, u8 * data, uword n_data_bytes)
{
- memset (m, 0, sizeof (m[0]));
+ clib_memset (m, 0, sizeof (m[0]));
m->stream.buffer = data;
m->stream.n_buffer_bytes = n_data_bytes;
}
-void
+__clib_export void
unserialize_open_data (serialize_main_t * m, u8 * data, uword n_data_bytes)
{
serialize_open_data (m, data, n_data_bytes);
}
}
-void
+__clib_export void
serialize_open_vector (serialize_main_t * m, u8 * vector)
{
- memset (m, 0, sizeof (m[0]));
+ clib_memset (m, 0, sizeof (m[0]));
m->header.data_function = serialize_vector_write;
m->stream.buffer = vector;
m->stream.current_buffer_index = 0;
m->stream.n_buffer_bytes = vec_len (vector);
}
-void *
+__clib_export void *
serialize_close_vector (serialize_main_t * m)
{
serialize_stream_t *s = &m->stream;
if (s->buffer)
_vec_len (s->buffer) = s->current_buffer_index;
result = s->buffer;
- memset (m, 0, sizeof (m[0]));
+ clib_memset (m, 0, sizeof (m[0]));
return result;
}
-void
-serialize_multiple_1 (serialize_main_t * m,
- void *data, uword data_stride, uword n_data)
+__clib_export void
+serialize_multiple_1 (serialize_main_t *m, void *data, uword data_stride,
+ uword n_data)
{
u8 *d = data;
u8 *p;
}
}
-void
-serialize_multiple_2 (serialize_main_t * m,
- void *data, uword data_stride, uword n_data)
+__clib_export void
+serialize_multiple_2 (serialize_main_t *m, void *data, uword data_stride,
+ uword n_data)
{
void *d = data;
u16 *p;
}
}
-void
-serialize_multiple_4 (serialize_main_t * m,
- void *data, uword data_stride, uword n_data)
+__clib_export void
+serialize_multiple_4 (serialize_main_t *m, void *data, uword data_stride,
+ uword n_data)
{
void *d = data;
u32 *p;
}
}
-void
-unserialize_multiple_1 (serialize_main_t * m,
- void *data, uword data_stride, uword n_data)
+__clib_export void
+unserialize_multiple_1 (serialize_main_t *m, void *data, uword data_stride,
+ uword n_data)
{
u8 *d = data;
u8 *p;
}
}
-void
-unserialize_multiple_2 (serialize_main_t * m,
- void *data, uword data_stride, uword n_data)
+__clib_export void
+unserialize_multiple_2 (serialize_main_t *m, void *data, uword data_stride,
+ uword n_data)
{
void *d = data;
u16 *p;
}
}
-void
-unserialize_multiple_4 (serialize_main_t * m,
- void *data, uword data_stride, uword n_data)
+__clib_export void
+unserialize_multiple_4 (serialize_main_t *m, void *data, uword data_stride,
+ uword n_data)
{
void *d = data;
u32 *p;
serialize_open_clib_file_descriptor_helper (serialize_main_t * m, int fd,
uword is_read)
{
- memset (m, 0, sizeof (m[0]));
+ clib_memset (m, 0, sizeof (m[0]));
vec_resize (m->stream.buffer, 4096);
if (!is_read)
m->stream.data_function_opaque = fd;
}
-void
+__clib_export void
serialize_open_clib_file_descriptor (serialize_main_t * m, int fd)
{
serialize_open_clib_file_descriptor_helper (m, fd, /* is_read */ 0);
}
-void
+__clib_export void
unserialize_open_clib_file_descriptor (serialize_main_t * m, int fd)
{
serialize_open_clib_file_descriptor_helper (m, fd, /* is_read */ 1);
return 0;
}
-clib_error_t *
+__clib_export clib_error_t *
serialize_open_clib_file (serialize_main_t * m, char *file)
{
return serialize_open_clib_file_helper (m, file, /* is_read */ 0);
}
-clib_error_t *
+__clib_export clib_error_t *
unserialize_open_clib_file (serialize_main_t * m, char *file)
{
return serialize_open_clib_file_helper (m, file, /* is_read */ 1);