1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
/*
* upb - a minimalist implementation of protocol buffers.
*
* Copyright (c) 2009 Joshua Haberman. See LICENSE for details.
*/
#include <stdlib.h>
#include "upb_data.h"
INLINE void data_init(upb_data *d, int flags) {
d->v = flags;
}
static uint32_t round_up_to_pow2(uint32_t v)
{
/* cf. http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2 */
v--;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
v++;
return v;
}
static void check_not_frozen(upb_data *d) {
// On one hand I am reluctant to put abort() calls in a low-level library
// that are enabled in a production build. On the other hand, this is a bug
// in the client code that we cannot recover from, and it seems better to get
// the error here than later.
if(upb_data_hasflag(d, UPB_DATA_FROZEN)) abort();
}
static upb_strlen_t string_get_bytesize(upb_string *s) {
if(upb_data_hasflag(&s->common.base, UPB_DATA_REFCOUNTED)) {
return s->refcounted.byte_size;
} else {
return (s->norefcount.byte_size_and_flags & 0xFFFFFFF8) >> 3;
}
}
static void string_set_bytesize(upb_string *s, upb_strlen_t newsize) {
if(upb_data_hasflag(&s->common.base, UPB_DATA_REFCOUNTED)) {
s->refcounted.byte_size = newsize;
} else {
s->norefcount.byte_size_and_flags &= 0x7;
s->norefcount.byte_size_and_flags |= (newsize << 3);
}
}
upb_string *upb_string_new() {
upb_string *s = malloc(sizeof(upb_refcounted_string));
data_init(&s->common.base, UPB_DATA_HEAPALLOCATED | UPB_DATA_REFCOUNTED);
s->refcounted.byte_size = 0;
s->common.byte_len = 0;
s->common.ptr = NULL;
return s;
}
void _upb_string_free(upb_string *s)
{
if(string_get_bytesize(s) != 0) free(s->common.ptr);
free(s);
}
char *upb_string_getrwbuf(upb_string *s, upb_strlen_t byte_len)
{
check_not_frozen(&s->common.base);
if(string_get_bytesize(s) < byte_len) {
// Need to resize.
size_t new_byte_size = round_up_to_pow2(byte_len);
s->common.ptr = realloc(s->common.ptr, new_byte_size);
string_set_bytesize(s, new_byte_size);
}
s->common.byte_len = byte_len;
return s->common.ptr;
}
#if 0
void upb_msg_destroy(struct upb_msg *msg) {
for(upb_field_count_t i = 0; i < msg->def->num_fields; i++) {
struct upb_fielddef *f = &msg->def->fields[i];
if(!upb_msg_isset(msg, f) || !upb_field_ismm(f)) continue;
upb_mm_destroy(upb_msg_getptr(msg, f), upb_field_ptrtype(f));
}
upb_def_unref(UPB_UPCAST(msg->def));
free(msg);
}
void upb_array_destroy(struct upb_array *arr)
{
if(upb_elem_ismm(arr->fielddef)) {
upb_arraylen_t i;
/* Unref elements. */
for(i = 0; i < arr->size; i++) {
union upb_value_ptr p = upb_array_getelementptr(arr, i);
upb_mm_destroy(p, upb_elem_ptrtype(arr->fielddef));
}
}
if(arr->size != 0) free(arr->elements._void);
free(arr);
}
#endif
|
