PROTON-896: declare functions static that are only referred to in one file, and change their names to have pni_ prefix.
Project: http://git-wip-us.apache.org/repos/asf/qpid-proton/repo Commit: http://git-wip-us.apache.org/repos/asf/qpid-proton/commit/d921c6bc Tree: http://git-wip-us.apache.org/repos/asf/qpid-proton/tree/d921c6bc Diff: http://git-wip-us.apache.org/repos/asf/qpid-proton/diff/d921c6bc Branch: refs/heads/master Commit: d921c6bc8a05663daa2bc0ff38e6d8808b029802 Parents: 5a6c8da Author: Mick Goulish <[email protected]> Authored: Mon Jun 8 10:05:50 2015 -0400 Committer: Mick Goulish <[email protected]> Committed: Mon Jun 8 10:05:50 2015 -0400 ---------------------------------------------------------------------- proton-c/src/buffer.c | 56 ++++----- proton-c/src/codec/codec.c | 190 ++++++++++++++--------------- proton-c/src/codec/decoder.c | 28 ++--- proton-c/src/engine/engine-internal.h | 2 - proton-c/src/engine/engine.c | 124 ++++++++++--------- proton-c/src/object/list.c | 11 +- proton-c/src/object/map.c | 4 +- proton-c/src/parser.c | 119 +++++++++--------- proton-c/src/scanner.c | 90 +++++++------- proton-c/src/transport/transport.c | 174 +++++++++++++------------- 10 files changed, 390 insertions(+), 408 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d921c6bc/proton-c/src/buffer.c ---------------------------------------------------------------------- diff --git a/proton-c/src/buffer.c b/proton-c/src/buffer.c index 145292a..64fa61f 100644 --- a/proton-c/src/buffer.c +++ b/proton-c/src/buffer.c @@ -81,12 +81,12 @@ size_t pn_buffer_available(pn_buffer_t *buf) return buf->capacity - buf->size; } -size_t pn_buffer_head(pn_buffer_t *buf) +static size_t pni_buffer_head(pn_buffer_t *buf) { return buf->start; } -size_t pn_buffer_tail(pn_buffer_t *buf) +static size_t pni_buffer_tail(pn_buffer_t *buf) { size_t tail = buf->start + buf->size; if (tail >= buf->capacity) @@ -94,42 +94,42 @@ size_t pn_buffer_tail(pn_buffer_t *buf) return tail; } -bool pn_buffer_wrapped(pn_buffer_t *buf) +static bool pni_buffer_wrapped(pn_buffer_t *buf) { - return buf->size && pn_buffer_head(buf) >= pn_buffer_tail(buf); + return buf->size && pni_buffer_head(buf) >= pni_buffer_tail(buf); } -size_t pn_buffer_tail_space(pn_buffer_t *buf) +static size_t pni_buffer_tail_space(pn_buffer_t *buf) { - if (pn_buffer_wrapped(buf)) { + if (pni_buffer_wrapped(buf)) { return pn_buffer_available(buf); } else { - return buf->capacity - pn_buffer_tail(buf); + return buf->capacity - pni_buffer_tail(buf); } } -size_t pn_buffer_head_space(pn_buffer_t *buf) +static size_t pni_buffer_head_space(pn_buffer_t *buf) { - if (pn_buffer_wrapped(buf)) { + if (pni_buffer_wrapped(buf)) { return pn_buffer_available(buf); } else { - return pn_buffer_head(buf); + return pni_buffer_head(buf); } } -size_t pn_buffer_head_size(pn_buffer_t *buf) +static size_t pni_buffer_head_size(pn_buffer_t *buf) { - if (pn_buffer_wrapped(buf)) { - return buf->capacity - pn_buffer_head(buf); + if (pni_buffer_wrapped(buf)) { + return buf->capacity - pni_buffer_head(buf); } else { - return pn_buffer_tail(buf) - pn_buffer_head(buf); + return pni_buffer_tail(buf) - pni_buffer_head(buf); } } -size_t pn_buffer_tail_size(pn_buffer_t *buf) +static size_t pni_buffer_tail_size(pn_buffer_t *buf) { - if (pn_buffer_wrapped(buf)) { - return pn_buffer_tail(buf); + if (pni_buffer_wrapped(buf)) { + return pni_buffer_tail(buf); } else { return 0; } @@ -138,8 +138,8 @@ size_t pn_buffer_tail_size(pn_buffer_t *buf) int pn_buffer_ensure(pn_buffer_t *buf, size_t size) { size_t old_capacity = buf->capacity; - size_t old_head = pn_buffer_head(buf); - bool wrapped = pn_buffer_wrapped(buf); + size_t old_head = pni_buffer_head(buf); + bool wrapped = pni_buffer_wrapped(buf); while (pn_buffer_available(buf) < size) { buf->capacity = 2*(buf->capacity ? buf->capacity : 16); @@ -166,8 +166,8 @@ int pn_buffer_append(pn_buffer_t *buf, const char *bytes, size_t size) int err = pn_buffer_ensure(buf, size); if (err) return err; - size_t tail = pn_buffer_tail(buf); - size_t tail_space = pn_buffer_tail_space(buf); + size_t tail = pni_buffer_tail(buf); + size_t tail_space = pni_buffer_tail_space(buf); size_t n = pn_min(tail_space, size); memmove(buf->bytes + tail, bytes, n); @@ -183,8 +183,8 @@ int pn_buffer_prepend(pn_buffer_t *buf, const char *bytes, size_t size) int err = pn_buffer_ensure(buf, size); if (err) return err; - size_t head = pn_buffer_head(buf); - size_t head_space = pn_buffer_head_space(buf); + size_t head = pni_buffer_head(buf); + size_t head_space = pni_buffer_head_space(buf); size_t n = pn_min(head_space, size); memmove(buf->bytes + head - n, bytes + size - n, n); @@ -201,7 +201,7 @@ int pn_buffer_prepend(pn_buffer_t *buf, const char *bytes, size_t size) return 0; } -size_t pn_buffer_index(pn_buffer_t *buf, size_t index) +static size_t pni_buffer_index(pn_buffer_t *buf, size_t index) { size_t result = buf->start + index; if (result >= buf->capacity) result -= buf->capacity; @@ -211,8 +211,8 @@ size_t pn_buffer_index(pn_buffer_t *buf, size_t index) size_t pn_buffer_get(pn_buffer_t *buf, size_t offset, size_t size, char *dst) { size = pn_min(size, buf->size); - size_t start = pn_buffer_index(buf, offset); - size_t stop = pn_buffer_index(buf, offset + size); + size_t start = pni_buffer_index(buf, offset); + size_t stop = pni_buffer_index(buf, offset + size); if (size == 0) return 0; @@ -303,8 +303,8 @@ pn_buffer_memory_t pn_buffer_memory(pn_buffer_t *buf) int pn_buffer_print(pn_buffer_t *buf) { printf("pn_buffer(\""); - pn_print_data(buf->bytes + pn_buffer_head(buf), pn_buffer_head_size(buf)); - pn_print_data(buf->bytes, pn_buffer_tail_size(buf)); + pn_print_data(buf->bytes + pni_buffer_head(buf), pni_buffer_head_size(buf)); + pn_print_data(buf->bytes, pni_buffer_tail_size(buf)); printf("\")"); return 0; } http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d921c6bc/proton-c/src/codec/codec.c ---------------------------------------------------------------------- diff --git a/proton-c/src/codec/codec.c b/proton-c/src/codec/codec.c index e8750fe..c00e79a 100644 --- a/proton-c/src/codec/codec.c +++ b/proton-c/src/codec/codec.c @@ -415,14 +415,14 @@ void pn_data_clear(pn_data_t *data) } } -int pn_data_grow(pn_data_t *data) +static int pni_data_grow(pn_data_t *data) { data->capacity = 2*(data->capacity ? data->capacity : 2); data->nodes = (pni_node_t *) realloc(data->nodes, data->capacity * sizeof(pni_node_t)); return 0; } -ssize_t pn_data_intern(pn_data_t *data, const char *start, size_t size) +static ssize_t pni_data_intern(pn_data_t *data, const char *start, size_t size) { size_t offset = pn_buffer_size(data->buf); int err = pn_buffer_append(data->buf, start, size); @@ -432,7 +432,7 @@ ssize_t pn_data_intern(pn_data_t *data, const char *start, size_t size) return offset; } -pn_bytes_t *pn_data_bytes(pn_data_t *data, pni_node_t *node) +static pn_bytes_t *pni_data_bytes(pn_data_t *data, pni_node_t *node) { switch (node->atom.type) { case PN_BINARY: @@ -443,23 +443,23 @@ pn_bytes_t *pn_data_bytes(pn_data_t *data, pni_node_t *node) } } -void pn_data_rebase(pn_data_t *data, char *base) +static void pni_data_rebase(pn_data_t *data, char *base) { for (unsigned i = 0; i < data->size; i++) { pni_node_t *node = &data->nodes[i]; if (node->data) { - pn_bytes_t *bytes = pn_data_bytes(data, node); + pn_bytes_t *bytes = pni_data_bytes(data, node); bytes->start = base + node->data_offset; } } } -int pn_data_intern_node(pn_data_t *data, pni_node_t *node) +static int pni_data_intern_node(pn_data_t *data, pni_node_t *node) { - pn_bytes_t *bytes = pn_data_bytes(data, node); + pn_bytes_t *bytes = pni_data_bytes(data, node); if (!bytes) return 0; size_t oldcap = pn_buffer_capacity(data->buf); - ssize_t offset = pn_data_intern(data, bytes->start, bytes->size); + ssize_t offset = pni_data_intern(data, bytes->start, bytes->size); if (offset < 0) return offset; node->data = true; node->data_offset = offset; @@ -468,7 +468,7 @@ int pn_data_intern_node(pn_data_t *data, pni_node_t *node) bytes->start = buf.start + offset; if (pn_buffer_capacity(data->buf) != oldcap) { - pn_data_rebase(data, buf.start); + pni_data_rebase(data, buf.start); } return 0; @@ -696,7 +696,7 @@ static bool pn_scan_next(pn_data_t *data, pn_type_t *type, bool suspend) } } -pni_node_t *pn_data_peek(pn_data_t *data); +static pni_node_t *pni_data_peek(pn_data_t *data); int pn_data_vscan(pn_data_t *data, const char *fmt, va_list ap) { @@ -1037,7 +1037,7 @@ int pn_data_vscan(pn_data_t *data, const char *fmt, va_list ap) pn_data_t *dst = va_arg(ap, pn_data_t *); if (!suspend) { size_t old = pn_data_size(dst); - pni_node_t *next = pn_data_peek(data); + pni_node_t *next = pni_data_peek(data); if (next && next->atom.type != PN_NULL) { pn_data_narrow(data); int err = pn_data_appendn(dst, data, 1); @@ -1104,23 +1104,15 @@ int pn_data_format(pn_data_t *data, char *bytes, size_t *size) } } -int pn_data_resize(pn_data_t *data, size_t size) -{ - if (!data || size > data->capacity) return PN_ARG_ERR; - data->size = size; - return 0; -} - - -size_t pn_data_id(pn_data_t *data, pni_node_t *node) +static size_t pni_data_id(pn_data_t *data, pni_node_t *node) { return node - data->nodes + 1; } -pni_node_t *pn_data_new(pn_data_t *data) +static pni_node_t *pni_data_new(pn_data_t *data) { if (data->capacity <= data->size) { - pn_data_grow(data); + pni_data_grow(data); } pni_node_t *node = pn_data_node(data, ++(data->size)); node->next = 0; @@ -1135,7 +1127,7 @@ void pn_data_rewind(pn_data_t *data) data->current = data->base_current; } -pni_node_t *pn_data_current(pn_data_t *data) +static pni_node_t *pni_data_current(pn_data_t *data) { return pn_data_node(data, data->current); } @@ -1170,7 +1162,7 @@ bool pn_data_restore(pn_data_t *data, pn_handle_t point) return true; } else if (point && point <= data->size) { data->current = point; - pni_node_t *current = pn_data_current(data); + pni_node_t *current = pni_data_current(data); data->parent = current->parent; return true; } else { @@ -1178,9 +1170,9 @@ bool pn_data_restore(pn_data_t *data, pn_handle_t point) } } -pni_node_t *pn_data_peek(pn_data_t *data) +static pni_node_t *pni_data_peek(pn_data_t *data) { - pni_node_t *current = pn_data_current(data); + pni_node_t *current = pni_data_current(data); if (current) { return pn_data_node(data, current->next); } @@ -1195,7 +1187,7 @@ pni_node_t *pn_data_peek(pn_data_t *data) bool pn_data_next(pn_data_t *data) { - pni_node_t *current = pn_data_current(data); + pni_node_t *current = pni_data_current(data); pni_node_t *parent = pn_data_node(data, data->parent); size_t next; @@ -1219,7 +1211,7 @@ bool pn_data_next(pn_data_t *data) bool pn_data_prev(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->prev) { data->current = node->prev; return true; @@ -1270,7 +1262,7 @@ int pni_data_traverse(pn_data_t *data, pn_type_t pn_data_type(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node) { return node->atom.type; } else { @@ -1366,9 +1358,9 @@ void pn_data_dump(pn_data_t *data) } } -pni_node_t *pn_data_add(pn_data_t *data) +static pni_node_t *pni_data_add(pn_data_t *data) { - pni_node_t *current = pn_data_current(data); + pni_node_t *current = pni_data_current(data); pni_node_t *parent = pn_data_node(data, data->parent); pni_node_t *node; @@ -1376,16 +1368,16 @@ pni_node_t *pn_data_add(pn_data_t *data) if (current->next) { node = pn_data_node(data, current->next); } else { - node = pn_data_new(data); + node = pni_data_new(data); // refresh the pointers in case we grew - current = pn_data_current(data); + current = pni_data_current(data); parent = pn_data_node(data, data->parent); node->prev = data->current; - current->next = pn_data_id(data, node); + current->next = pni_data_id(data, node); node->parent = data->parent; if (parent) { if (!parent->down) { - parent->down = pn_data_id(data, node); + parent->down = pni_data_id(data, node); } parent->children++; } @@ -1394,18 +1386,18 @@ pni_node_t *pn_data_add(pn_data_t *data) if (parent->down) { node = pn_data_node(data, parent->down); } else { - node = pn_data_new(data); + node = pni_data_new(data); // refresh the pointers in case we grew parent = pn_data_node(data, data->parent); node->prev = 0; node->parent = data->parent; - parent->down = pn_data_id(data, node); + parent->down = pni_data_id(data, node); parent->children++; } } else if (data->size) { node = pn_data_node(data, 1); } else { - node = pn_data_new(data); + node = pni_data_new(data); node->prev = 0; node->parent = 0; } @@ -1415,7 +1407,7 @@ pni_node_t *pn_data_add(pn_data_t *data) node->data = false; node->data_offset = 0; node->data_size = 0; - data->current = pn_data_id(data, node); + data->current = pni_data_id(data, node); return node; } @@ -1436,21 +1428,21 @@ ssize_t pn_data_decode(pn_data_t *data, const char *bytes, size_t size) int pn_data_put_list(pn_data_t *data) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_LIST; return 0; } int pn_data_put_map(pn_data_t *data) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_MAP; return 0; } int pn_data_put_array(pn_data_t *data, bool described, pn_type_t type) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_ARRAY; node->described = described; node->type = type; @@ -1459,27 +1451,27 @@ int pn_data_put_array(pn_data_t *data, bool described, pn_type_t type) void pni_data_set_array_type(pn_data_t *data, pn_type_t type) { - pni_node_t *array = pn_data_current(data); + pni_node_t *array = pni_data_current(data); if (array) array->type = type; } int pn_data_put_described(pn_data_t *data) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_DESCRIBED; return 0; } int pn_data_put_null(pn_data_t *data) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); pni_atom_init(&node->atom, PN_NULL); return 0; } int pn_data_put_bool(pn_data_t *data, bool b) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_BOOL; node->atom.u.as_bool = b; return 0; @@ -1487,7 +1479,7 @@ int pn_data_put_bool(pn_data_t *data, bool b) int pn_data_put_ubyte(pn_data_t *data, uint8_t ub) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_UBYTE; node->atom.u.as_ubyte = ub; return 0; @@ -1495,7 +1487,7 @@ int pn_data_put_ubyte(pn_data_t *data, uint8_t ub) int pn_data_put_byte(pn_data_t *data, int8_t b) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_BYTE; node->atom.u.as_byte = b; return 0; @@ -1503,7 +1495,7 @@ int pn_data_put_byte(pn_data_t *data, int8_t b) int pn_data_put_ushort(pn_data_t *data, uint16_t us) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_USHORT; node->atom.u.as_ushort = us; return 0; @@ -1511,7 +1503,7 @@ int pn_data_put_ushort(pn_data_t *data, uint16_t us) int pn_data_put_short(pn_data_t *data, int16_t s) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_SHORT; node->atom.u.as_short = s; return 0; @@ -1519,7 +1511,7 @@ int pn_data_put_short(pn_data_t *data, int16_t s) int pn_data_put_uint(pn_data_t *data, uint32_t ui) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_UINT; node->atom.u.as_uint = ui; return 0; @@ -1527,7 +1519,7 @@ int pn_data_put_uint(pn_data_t *data, uint32_t ui) int pn_data_put_int(pn_data_t *data, int32_t i) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_INT; node->atom.u.as_int = i; return 0; @@ -1535,7 +1527,7 @@ int pn_data_put_int(pn_data_t *data, int32_t i) int pn_data_put_char(pn_data_t *data, pn_char_t c) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_CHAR; node->atom.u.as_char = c; return 0; @@ -1543,7 +1535,7 @@ int pn_data_put_char(pn_data_t *data, pn_char_t c) int pn_data_put_ulong(pn_data_t *data, uint64_t ul) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_ULONG; node->atom.u.as_ulong = ul; return 0; @@ -1551,7 +1543,7 @@ int pn_data_put_ulong(pn_data_t *data, uint64_t ul) int pn_data_put_long(pn_data_t *data, int64_t l) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_LONG; node->atom.u.as_long = l; return 0; @@ -1559,7 +1551,7 @@ int pn_data_put_long(pn_data_t *data, int64_t l) int pn_data_put_timestamp(pn_data_t *data, pn_timestamp_t t) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_TIMESTAMP; node->atom.u.as_timestamp = t; return 0; @@ -1567,7 +1559,7 @@ int pn_data_put_timestamp(pn_data_t *data, pn_timestamp_t t) int pn_data_put_float(pn_data_t *data, float f) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_FLOAT; node->atom.u.as_float = f; return 0; @@ -1575,7 +1567,7 @@ int pn_data_put_float(pn_data_t *data, float f) int pn_data_put_double(pn_data_t *data, double d) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_DOUBLE; node->atom.u.as_double = d; return 0; @@ -1583,7 +1575,7 @@ int pn_data_put_double(pn_data_t *data, double d) int pn_data_put_decimal32(pn_data_t *data, pn_decimal32_t d) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_DECIMAL32; node->atom.u.as_decimal32 = d; return 0; @@ -1591,7 +1583,7 @@ int pn_data_put_decimal32(pn_data_t *data, pn_decimal32_t d) int pn_data_put_decimal64(pn_data_t *data, pn_decimal64_t d) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_DECIMAL64; node->atom.u.as_decimal64 = d; return 0; @@ -1599,7 +1591,7 @@ int pn_data_put_decimal64(pn_data_t *data, pn_decimal64_t d) int pn_data_put_decimal128(pn_data_t *data, pn_decimal128_t d) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_DECIMAL128; memmove(node->atom.u.as_decimal128.bytes, d.bytes, 16); return 0; @@ -1607,7 +1599,7 @@ int pn_data_put_decimal128(pn_data_t *data, pn_decimal128_t d) int pn_data_put_uuid(pn_data_t *data, pn_uuid_t u) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_UUID; memmove(node->atom.u.as_uuid.bytes, u.bytes, 16); return 0; @@ -1615,38 +1607,38 @@ int pn_data_put_uuid(pn_data_t *data, pn_uuid_t u) int pn_data_put_binary(pn_data_t *data, pn_bytes_t bytes) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_BINARY; node->atom.u.as_bytes = bytes; - return pn_data_intern_node(data, node); + return pni_data_intern_node(data, node); } int pn_data_put_string(pn_data_t *data, pn_bytes_t string) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_STRING; node->atom.u.as_bytes = string; - return pn_data_intern_node(data, node); + return pni_data_intern_node(data, node); } int pn_data_put_symbol(pn_data_t *data, pn_bytes_t symbol) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom.type = PN_SYMBOL; node->atom.u.as_bytes = symbol; - return pn_data_intern_node(data, node); + return pni_data_intern_node(data, node); } int pn_data_put_atom(pn_data_t *data, pn_atom_t atom) { - pni_node_t *node = pn_data_add(data); + pni_node_t *node = pni_data_add(data); node->atom = atom; - return pn_data_intern_node(data, node); + return pni_data_intern_node(data, node); } size_t pn_data_get_list(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_LIST) { return node->children; } else { @@ -1656,7 +1648,7 @@ size_t pn_data_get_list(pn_data_t *data) size_t pn_data_get_map(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_MAP) { return node->children; } else { @@ -1666,7 +1658,7 @@ size_t pn_data_get_map(pn_data_t *data) size_t pn_data_get_array(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_ARRAY) { if (node->described) { return node->children - 1; @@ -1680,7 +1672,7 @@ size_t pn_data_get_array(pn_data_t *data) bool pn_data_is_array_described(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_ARRAY) { return node->described; } else { @@ -1690,7 +1682,7 @@ bool pn_data_is_array_described(pn_data_t *data) pn_type_t pn_data_get_array_type(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_ARRAY) { return node->type; } else { @@ -1700,19 +1692,19 @@ pn_type_t pn_data_get_array_type(pn_data_t *data) bool pn_data_is_described(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); return node && node->atom.type == PN_DESCRIBED; } bool pn_data_is_null(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); return node && node->atom.type == PN_NULL; } bool pn_data_get_bool(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_BOOL) { return node->atom.u.as_bool; } else { @@ -1722,7 +1714,7 @@ bool pn_data_get_bool(pn_data_t *data) uint8_t pn_data_get_ubyte(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_UBYTE) { return node->atom.u.as_ubyte; } else { @@ -1732,7 +1724,7 @@ uint8_t pn_data_get_ubyte(pn_data_t *data) int8_t pn_data_get_byte(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_BYTE) { return node->atom.u.as_byte; } else { @@ -1742,7 +1734,7 @@ int8_t pn_data_get_byte(pn_data_t *data) uint16_t pn_data_get_ushort(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_USHORT) { return node->atom.u.as_ushort; } else { @@ -1752,7 +1744,7 @@ uint16_t pn_data_get_ushort(pn_data_t *data) int16_t pn_data_get_short(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_SHORT) { return node->atom.u.as_short; } else { @@ -1762,7 +1754,7 @@ int16_t pn_data_get_short(pn_data_t *data) uint32_t pn_data_get_uint(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_UINT) { return node->atom.u.as_uint; } else { @@ -1772,7 +1764,7 @@ uint32_t pn_data_get_uint(pn_data_t *data) int32_t pn_data_get_int(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_INT) { return node->atom.u.as_int; } else { @@ -1782,7 +1774,7 @@ int32_t pn_data_get_int(pn_data_t *data) pn_char_t pn_data_get_char(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_CHAR) { return node->atom.u.as_char; } else { @@ -1792,7 +1784,7 @@ pn_char_t pn_data_get_char(pn_data_t *data) uint64_t pn_data_get_ulong(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_ULONG) { return node->atom.u.as_ulong; } else { @@ -1802,7 +1794,7 @@ uint64_t pn_data_get_ulong(pn_data_t *data) int64_t pn_data_get_long(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_LONG) { return node->atom.u.as_long; } else { @@ -1812,7 +1804,7 @@ int64_t pn_data_get_long(pn_data_t *data) pn_timestamp_t pn_data_get_timestamp(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_TIMESTAMP) { return node->atom.u.as_timestamp; } else { @@ -1822,7 +1814,7 @@ pn_timestamp_t pn_data_get_timestamp(pn_data_t *data) float pn_data_get_float(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_FLOAT) { return node->atom.u.as_float; } else { @@ -1832,7 +1824,7 @@ float pn_data_get_float(pn_data_t *data) double pn_data_get_double(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_DOUBLE) { return node->atom.u.as_double; } else { @@ -1842,7 +1834,7 @@ double pn_data_get_double(pn_data_t *data) pn_decimal32_t pn_data_get_decimal32(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_DECIMAL32) { return node->atom.u.as_decimal32; } else { @@ -1852,7 +1844,7 @@ pn_decimal32_t pn_data_get_decimal32(pn_data_t *data) pn_decimal64_t pn_data_get_decimal64(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_DECIMAL64) { return node->atom.u.as_decimal64; } else { @@ -1862,7 +1854,7 @@ pn_decimal64_t pn_data_get_decimal64(pn_data_t *data) pn_decimal128_t pn_data_get_decimal128(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_DECIMAL128) { return node->atom.u.as_decimal128; } else { @@ -1873,7 +1865,7 @@ pn_decimal128_t pn_data_get_decimal128(pn_data_t *data) pn_uuid_t pn_data_get_uuid(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_UUID) { return node->atom.u.as_uuid; } else { @@ -1884,7 +1876,7 @@ pn_uuid_t pn_data_get_uuid(pn_data_t *data) pn_bytes_t pn_data_get_binary(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_BINARY) { return node->atom.u.as_bytes; } else { @@ -1895,7 +1887,7 @@ pn_bytes_t pn_data_get_binary(pn_data_t *data) pn_bytes_t pn_data_get_string(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_STRING) { return node->atom.u.as_bytes; } else { @@ -1906,7 +1898,7 @@ pn_bytes_t pn_data_get_string(pn_data_t *data) pn_bytes_t pn_data_get_symbol(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && node->atom.type == PN_SYMBOL) { return node->atom.u.as_bytes; } else { @@ -1917,7 +1909,7 @@ pn_bytes_t pn_data_get_symbol(pn_data_t *data) pn_bytes_t pn_data_get_bytes(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node && (node->atom.type == PN_BINARY || node->atom.type == PN_STRING || node->atom.type == PN_SYMBOL)) { @@ -1930,7 +1922,7 @@ pn_bytes_t pn_data_get_bytes(pn_data_t *data) pn_atom_t pn_data_get_atom(pn_data_t *data) { - pni_node_t *node = pn_data_current(data); + pni_node_t *node = pni_data_current(data); if (node) { return *((pn_atom_t *) &node->atom); } else { http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d921c6bc/proton-c/src/codec/decoder.c ---------------------------------------------------------------------- diff --git a/proton-c/src/codec/decoder.c b/proton-c/src/codec/decoder.c index dbbb13f..b0c8d79 100644 --- a/proton-c/src/codec/decoder.c +++ b/proton-c/src/codec/decoder.c @@ -189,11 +189,11 @@ static inline pn_type_t pn_code2type(uint8_t code) } } -int pn_decoder_decode_type(pn_decoder_t *decoder, pn_data_t *data, uint8_t *code); -int pn_decoder_single(pn_decoder_t *decoder, pn_data_t *data); +static int pni_decoder_decode_type(pn_decoder_t *decoder, pn_data_t *data, uint8_t *code); +static int pni_decoder_single(pn_decoder_t *decoder, pn_data_t *data); void pni_data_set_array_type(pn_data_t *data, pn_type_t type); -int pn_decoder_decode_value(pn_decoder_t *decoder, pn_data_t *data, uint8_t code) +static int pni_decoder_decode_value(pn_decoder_t *decoder, pn_data_t *data, uint8_t code) { int err; conv_t conv; @@ -392,13 +392,13 @@ int pn_decoder_decode_value(pn_decoder_t *decoder, pn_data_t *data, uint8_t code pn_data_enter(data); uint8_t acode; - int e = pn_decoder_decode_type(decoder, data, &acode); + int e = pni_decoder_decode_type(decoder, data, &acode); if (e) return e; pn_type_t type = pn_code2type(acode); if ((int)type < 0) return (int)type; for (size_t i = 0; i < count; i++) { - e = pn_decoder_decode_value(decoder, data, acode); + e = pni_decoder_decode_value(decoder, data, acode); if (e) return e; } pn_data_exit(data); @@ -423,7 +423,7 @@ int pn_decoder_decode_value(pn_decoder_t *decoder, pn_data_t *data, uint8_t code pn_data_enter(data); for (size_t i = 0; i < count; i++) { - int e = pn_decoder_single(decoder, data); + int e = pni_decoder_single(decoder, data); if (e) return e; } pn_data_exit(data); @@ -438,7 +438,7 @@ int pn_decoder_decode_value(pn_decoder_t *decoder, pn_data_t *data, uint8_t code pn_type_t pni_data_parent_type(pn_data_t *data); -int pn_decoder_decode_type(pn_decoder_t *decoder, pn_data_t *data, uint8_t *code) +static int pni_decoder_decode_type(pn_decoder_t *decoder, pn_data_t *data, uint8_t *code) { int err; @@ -452,12 +452,12 @@ int pn_decoder_decode_type(pn_decoder_t *decoder, pn_data_t *data, uint8_t *code if (pni_data_parent_type(data) != PN_ARRAY) { err = pn_data_put_described(data); if (err) return err; - // pn_decoder_single has the corresponding exit + // pni_decoder_single has the corresponding exit pn_data_enter(data); } - err = pn_decoder_single(decoder, data); + err = pni_decoder_single(decoder, data); if (err) return err; - err = pn_decoder_decode_type(decoder, data, code); + err = pni_decoder_decode_type(decoder, data, code); if (err) return err; } else { *code = next; @@ -468,12 +468,12 @@ int pn_decoder_decode_type(pn_decoder_t *decoder, pn_data_t *data, uint8_t *code size_t pn_data_siblings(pn_data_t *data); -int pn_decoder_single(pn_decoder_t *decoder, pn_data_t *data) +int pni_decoder_single(pn_decoder_t *decoder, pn_data_t *data) { uint8_t code; - int err = pn_decoder_decode_type(decoder, data, &code); + int err = pni_decoder_decode_type(decoder, data, &code); if (err) return err; - err = pn_decoder_decode_value(decoder, data, code); + err = pni_decoder_decode_value(decoder, data, code); if (err) return err; if (pni_data_parent_type(data) == PN_DESCRIBED && pn_data_siblings(data) > 1) { pn_data_exit(data); @@ -487,7 +487,7 @@ ssize_t pn_decoder_decode(pn_decoder_t *decoder, const char *src, size_t size, p decoder->size = size; decoder->position = src; - int err = pn_decoder_single(decoder, dst); + int err = pni_decoder_single(decoder, dst); if (err == PN_UNDERFLOW) return pn_error_format(pn_data_error(dst), PN_UNDERFLOW, "not enough data to decode"); http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d921c6bc/proton-c/src/engine/engine-internal.h ---------------------------------------------------------------------- diff --git a/proton-c/src/engine/engine-internal.h b/proton-c/src/engine/engine-internal.h index 2f0cc56..4c72310 100644 --- a/proton-c/src/engine/engine-internal.h +++ b/proton-c/src/engine/engine-internal.h @@ -334,9 +334,7 @@ void pn_connection_bound(pn_connection_t *conn); void pn_connection_unbound(pn_connection_t *conn); int pn_do_error(pn_transport_t *transport, const char *condition, const char *fmt, ...); void pn_set_error_layer(pn_transport_t *transport); -void pn_session_bound(pn_session_t* ssn); void pn_session_unbound(pn_session_t* ssn); -void pn_link_bound(pn_link_t* link); void pn_link_unbound(pn_link_t* link); void pn_ep_incref(pn_endpoint_t *endpoint); void pn_ep_decref(pn_endpoint_t *endpoint); http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d921c6bc/proton-c/src/engine/engine.c ---------------------------------------------------------------------- diff --git a/proton-c/src/engine/engine.c b/proton-c/src/engine/engine.c index 67cc882..c5228a5 100644 --- a/proton-c/src/engine/engine.c +++ b/proton-c/src/engine/engine.c @@ -32,9 +32,14 @@ #include "platform_fmt.h" #include "transport/transport.h" + +static void pni_session_bound(pn_session_t *ssn); +static void pni_link_bound(pn_link_t *link); + + // endpoints -pn_connection_t *pn_ep_get_connection(pn_endpoint_t *endpoint) +static pn_connection_t *pni_ep_get_connection(pn_endpoint_t *endpoint) { switch (endpoint->type) { case CONNECTION: @@ -68,7 +73,7 @@ static void pn_endpoint_open(pn_endpoint_t *endpoint) { if (!(endpoint->state & PN_LOCAL_ACTIVE)) { PN_SET_LOCAL(endpoint->state, PN_LOCAL_ACTIVE); - pn_connection_t *conn = pn_ep_get_connection(endpoint); + pn_connection_t *conn = pni_ep_get_connection(endpoint); pn_collector_put(conn->collector, PN_OBJECT, endpoint, endpoint_event(endpoint->type, true)); pn_modified(conn, endpoint, true); @@ -79,7 +84,7 @@ static void pn_endpoint_close(pn_endpoint_t *endpoint) { if (!(endpoint->state & PN_LOCAL_CLOSED)) { PN_SET_LOCAL(endpoint->state, PN_LOCAL_CLOSED); - pn_connection_t *conn = pn_ep_get_connection(endpoint); + pn_connection_t *conn = pni_ep_get_connection(endpoint); pn_collector_put(conn->collector, PN_OBJECT, endpoint, endpoint_event(endpoint->type, false)); pn_modified(conn, endpoint, true); @@ -105,7 +110,7 @@ void pn_connection_close(pn_connection_t *connection) pn_endpoint_close(&connection->endpoint); } -void pn_endpoint_tini(pn_endpoint_t *endpoint); +static void pni_endpoint_tini(pn_endpoint_t *endpoint); void pn_connection_release(pn_connection_t *connection) { @@ -149,7 +154,7 @@ void pn_connection_bound(pn_connection_t *connection) size_t nsessions = pn_list_size(connection->sessions); for (size_t i = 0; i < nsessions; i++) { - pn_session_bound((pn_session_t *) pn_list_get(connection->sessions, i)); + pni_session_bound((pn_session_t *) pn_list_get(connection->sessions, i)); } } @@ -210,7 +215,7 @@ void pn_condition_tini(pn_condition_t *condition) pn_free(condition->name); } -void pn_add_session(pn_connection_t *conn, pn_session_t *ssn) +static void pni_add_session(pn_connection_t *conn, pn_session_t *ssn) { pn_list_add(conn->sessions, ssn); ssn->connection = conn; @@ -218,7 +223,7 @@ void pn_add_session(pn_connection_t *conn, pn_session_t *ssn) pn_ep_incref(&conn->endpoint); } -void pn_remove_session(pn_connection_t *conn, pn_session_t *ssn) +static void pni_remove_session(pn_connection_t *conn, pn_session_t *ssn) { if (pn_list_remove(conn->sessions, ssn)) { pn_ep_decref(&conn->endpoint); @@ -251,7 +256,7 @@ void pn_session_free(pn_session_t *session) pn_link_t *link = (pn_link_t *)pn_list_get(session->links, 0); pn_link_free(link); } - pn_remove_session(session->connection, session); + pni_remove_session(session->connection, session); pn_list_add(session->connection->freed, session); session->endpoint.freed = true; pn_ep_decref(&session->endpoint); @@ -280,14 +285,14 @@ void pn_session_set_context(pn_session_t *session, void *context) } -void pn_add_link(pn_session_t *ssn, pn_link_t *link) +static void pni_add_link(pn_session_t *ssn, pn_link_t *link) { pn_list_add(ssn->links, link); link->session = ssn; pn_ep_incref(&ssn->endpoint); } -void pn_remove_link(pn_session_t *ssn, pn_link_t *link) +static void pni_remove_link(pn_session_t *ssn, pn_link_t *link) { if (pn_list_remove(ssn->links, link)) { pn_ep_decref(&ssn->endpoint); @@ -316,7 +321,7 @@ void pn_link_detach(pn_link_t *link) } -void pn_terminus_free(pn_terminus_t *terminus) +static void pni_terminus_free(pn_terminus_t *terminus) { pn_free(terminus->address); pn_free(terminus->properties); @@ -328,7 +333,7 @@ void pn_terminus_free(pn_terminus_t *terminus) void pn_link_free(pn_link_t *link) { assert(!link->endpoint.freed); - pn_remove_link(link->session, link); + pni_remove_link(link->session, link); pn_list_add(link->session->freed, link); pn_delivery_t *delivery = link->unsettled_head; while (delivery) { @@ -423,12 +428,12 @@ void pn_ep_decref(pn_endpoint_t *endpoint) assert(endpoint->refcount > 0); endpoint->refcount--; if (endpoint->refcount == 0) { - pn_connection_t *conn = pn_ep_get_connection(endpoint); + pn_connection_t *conn = pni_ep_get_connection(endpoint); pn_collector_put(conn->collector, PN_OBJECT, endpoint, pn_final_type(endpoint->type)); } } -void pn_endpoint_tini(pn_endpoint_t *endpoint) +static void pni_endpoint_tini(pn_endpoint_t *endpoint) { pn_error_free(endpoint->error); pn_condition_tini(&endpoint->remote_condition); @@ -479,7 +484,7 @@ static void pn_connection_finalize(void *object) pn_free(conn->offered_capabilities); pn_free(conn->desired_capabilities); pn_free(conn->properties); - pn_endpoint_tini(endpoint); + pni_endpoint_tini(endpoint); pn_free(conn->delivery_pool); } @@ -654,7 +659,7 @@ pn_delivery_t *pn_work_next(pn_delivery_t *delivery) return pn_work_head(delivery->link->session->connection); } -void pn_add_work(pn_connection_t *connection, pn_delivery_t *delivery) +static void pni_add_work(pn_connection_t *connection, pn_delivery_t *delivery) { if (!delivery->work) { @@ -664,7 +669,7 @@ void pn_add_work(pn_connection_t *connection, pn_delivery_t *delivery) } } -void pn_clear_work(pn_connection_t *connection, pn_delivery_t *delivery) +static void pni_clear_work(pn_connection_t *connection, pn_delivery_t *delivery) { if (delivery->work) { @@ -678,23 +683,23 @@ void pn_work_update(pn_connection_t *connection, pn_delivery_t *delivery) pn_link_t *link = pn_delivery_link(delivery); pn_delivery_t *current = pn_link_current(link); if (delivery->updated && !delivery->local.settled) { - pn_add_work(connection, delivery); + pni_add_work(connection, delivery); } else if (delivery == current) { if (link->endpoint.type == SENDER) { if (pn_link_credit(link) > 0) { - pn_add_work(connection, delivery); + pni_add_work(connection, delivery); } else { - pn_clear_work(connection, delivery); + pni_clear_work(connection, delivery); } } else { - pn_add_work(connection, delivery); + pni_add_work(connection, delivery); } } else { - pn_clear_work(connection, delivery); + pni_clear_work(connection, delivery); } } -void pn_add_tpwork(pn_delivery_t *delivery) +static void pni_add_tpwork(pn_delivery_t *delivery) { pn_connection_t *connection = delivery->link->session->connection; if (!delivery->tpwork) @@ -755,7 +760,7 @@ void pn_clear_modified(pn_connection_t *connection, pn_endpoint_t *endpoint) } } -bool pn_matches(pn_endpoint_t *endpoint, pn_endpoint_type_t type, pn_state_t state) +static bool pni_matches(pn_endpoint_t *endpoint, pn_endpoint_type_t type, pn_state_t state) { if (endpoint->type != type) return false; @@ -772,7 +777,7 @@ pn_endpoint_t *pn_find(pn_endpoint_t *endpoint, pn_endpoint_type_t type, pn_stat { while (endpoint) { - if (pn_matches(endpoint, type, state)) + if (pni_matches(endpoint, type, state)) return endpoint; endpoint = endpoint->endpoint_next; } @@ -803,7 +808,7 @@ pn_link_t *pn_link_head(pn_connection_t *conn, pn_state_t state) while (endpoint) { - if (pn_matches(endpoint, SENDER, state) || pn_matches(endpoint, RECEIVER, state)) + if (pni_matches(endpoint, SENDER, state) || pni_matches(endpoint, RECEIVER, state)) return (pn_link_t *) endpoint; endpoint = endpoint->endpoint_next; } @@ -819,7 +824,7 @@ pn_link_t *pn_link_next(pn_link_t *link, pn_state_t state) while (endpoint) { - if (pn_matches(endpoint, SENDER, state) || pn_matches(endpoint, RECEIVER, state)) + if (pni_matches(endpoint, SENDER, state) || pni_matches(endpoint, RECEIVER, state)) return (pn_link_t *) endpoint; endpoint = endpoint->endpoint_next; } @@ -840,7 +845,7 @@ static void pn_session_incref(void *object) static bool pn_ep_bound(pn_endpoint_t *endpoint) { - pn_connection_t *conn = pn_ep_get_connection(endpoint); + pn_connection_t *conn = pni_ep_get_connection(endpoint); pn_session_t *ssn; pn_link_t *lnk; @@ -892,7 +897,7 @@ static bool pni_endpoint_live(pn_endpoint_t *endpoint) { static bool pni_preserve_child(pn_endpoint_t *endpoint) { - pn_connection_t *conn = pn_ep_get_connection(endpoint); + pn_connection_t *conn = pni_ep_get_connection(endpoint); pn_endpoint_t *parent = pn_ep_parent(endpoint); if (pni_endpoint_live(parent) && (!endpoint->freed || (pn_ep_bound(endpoint))) && endpoint->referenced) { @@ -917,12 +922,12 @@ static void pn_session_finalize(void *object) pn_free(session->context); pni_free_children(session->links, session->freed); - pn_endpoint_tini(endpoint); + pni_endpoint_tini(endpoint); pn_delivery_map_free(&session->state.incoming); pn_delivery_map_free(&session->state.outgoing); pn_free(session->state.local_handles); pn_free(session->state.remote_handles); - pn_remove_session(session->connection, session); + pni_remove_session(session->connection, session); pn_list_remove(session->connection->freed, session); if (session->connection->transport) { @@ -955,7 +960,7 @@ pn_session_t *pn_session(pn_connection_t *conn) if (!ssn) return NULL; pn_endpoint_init(&ssn->endpoint, SESSION, conn); - pn_add_session(conn, ssn); + pni_add_session(conn, ssn); ssn->links = pn_list(PN_WEAKREF, 0); ssn->freed = pn_list(PN_WEAKREF, 0); ssn->context = pn_record(); @@ -977,18 +982,18 @@ pn_session_t *pn_session(pn_connection_t *conn) pn_collector_put(conn->collector, PN_OBJECT, ssn, PN_SESSION_INIT); if (conn->transport) { - pn_session_bound(ssn); + pni_session_bound(ssn); } pn_decref(ssn); return ssn; } -void pn_session_bound(pn_session_t *ssn) +static void pni_session_bound(pn_session_t *ssn) { assert(ssn); size_t nlinks = pn_list_size(ssn->links); for (size_t i = 0; i < nlinks; i++) { - pn_link_bound((pn_link_t *) pn_list_get(ssn->links, i)); + pni_link_bound((pn_link_t *) pn_list_get(ssn->links, i)); } } @@ -1038,7 +1043,7 @@ pn_error_t *pn_session_error(pn_session_t *session) return session->endpoint.error; } -void pn_terminus_init(pn_terminus_t *terminus, pn_terminus_type_t type) +static void pni_terminus_init(pn_terminus_t *terminus, pn_terminus_type_t type) { terminus->type = type; terminus->address = pn_string(NULL); @@ -1079,13 +1084,13 @@ static void pn_link_finalize(void *object) } pn_free(link->context); - pn_terminus_free(&link->source); - pn_terminus_free(&link->target); - pn_terminus_free(&link->remote_source); - pn_terminus_free(&link->remote_target); + pni_terminus_free(&link->source); + pni_terminus_free(&link->target); + pni_terminus_free(&link->remote_source); + pni_terminus_free(&link->remote_target); pn_free(link->name); - pn_endpoint_tini(endpoint); - pn_remove_link(link->session, link); + pni_endpoint_tini(endpoint); + pni_remove_link(link->session, link); pn_hash_del(link->session->state.local_handles, link->state.local_handle); pn_hash_del(link->session->state.remote_handles, link->state.remote_handle); pn_list_remove(link->session->freed, link); @@ -1112,13 +1117,13 @@ pn_link_t *pn_link_new(int type, pn_session_t *session, const char *name) pn_link_t *link = (pn_link_t *) pn_class_new(&clazz, sizeof(pn_link_t)); pn_endpoint_init(&link->endpoint, type, session->connection); - pn_add_link(session, link); + pni_add_link(session, link); pn_incref(session); // keep session until link finalized link->name = pn_string(name); - pn_terminus_init(&link->source, PN_SOURCE); - pn_terminus_init(&link->target, PN_TARGET); - pn_terminus_init(&link->remote_source, PN_UNSPECIFIED); - pn_terminus_init(&link->remote_target, PN_UNSPECIFIED); + pni_terminus_init(&link->source, PN_SOURCE); + pni_terminus_init(&link->target, PN_TARGET); + pni_terminus_init(&link->remote_source, PN_UNSPECIFIED); + pni_terminus_init(&link->remote_target, PN_UNSPECIFIED); link->unsettled_head = link->unsettled_tail = link->current = NULL; link->unsettled_count = 0; link->available = 0; @@ -1143,15 +1148,14 @@ pn_link_t *pn_link_new(int type, pn_session_t *session, const char *name) pn_collector_put(session->connection->collector, PN_OBJECT, link, PN_LINK_INIT); if (session->connection->transport) { - pn_link_bound(link); + pni_link_bound(link); } pn_decref(link); return link; } -void pn_link_bound(pn_link_t *link) +static void pni_link_bound(pn_link_t *link) { - } void pn_link_unbound(pn_link_t* link) @@ -1678,17 +1682,17 @@ pn_delivery_t *pn_link_current(pn_link_t *link) return link->current; } -void pn_advance_sender(pn_link_t *link) +static void pni_advance_sender(pn_link_t *link) { link->current->done = true; link->queued++; link->credit--; link->session->outgoing_deliveries++; - pn_add_tpwork(link->current); + pni_add_tpwork(link->current); link->current = link->current->unsettled_next; } -void pn_advance_receiver(pn_link_t *link) +static void pni_advance_receiver(pn_link_t *link) { link->credit--; link->queued--; @@ -1699,7 +1703,7 @@ void pn_advance_receiver(pn_link_t *link) pn_buffer_clear(current->bytes); if (!link->session->state.incoming_window) { - pn_add_tpwork(current); + pni_add_tpwork(current); } link->current = link->current->unsettled_next; @@ -1710,9 +1714,9 @@ bool pn_link_advance(pn_link_t *link) if (link && link->current) { pn_delivery_t *prev = link->current; if (link->endpoint.type == SENDER) { - pn_advance_sender(link); + pni_advance_sender(link); } else { - pn_advance_receiver(link); + pni_advance_receiver(link); } pn_delivery_t *next = link->current; pn_work_update(link->session->connection, prev); @@ -1795,7 +1799,7 @@ void pn_delivery_settle(pn_delivery_t *delivery) link->unsettled_count--; delivery->local.settled = true; - pn_add_tpwork(delivery); + pni_add_tpwork(delivery); pn_work_update(delivery->link->session->connection, delivery); pn_incref(delivery); pn_decref(delivery); @@ -1814,7 +1818,7 @@ ssize_t pn_link_send(pn_link_t *sender, const char *bytes, size_t n) if (!bytes || !n) return 0; pn_buffer_append(current->bytes, bytes, n); sender->session->outgoing_bytes += n; - pn_add_tpwork(current); + pni_add_tpwork(current); return n; } @@ -1849,7 +1853,7 @@ ssize_t pn_link_recv(pn_link_t *receiver, char *bytes, size_t n) if (size) { receiver->session->incoming_bytes -= size; if (!receiver->session->state.incoming_window) { - pn_add_tpwork(delivery); + pni_add_tpwork(delivery); } return size; } else { @@ -1947,7 +1951,7 @@ void pn_delivery_update(pn_delivery_t *delivery, uint64_t state) { if (!delivery) return; delivery->local.type = state; - pn_add_tpwork(delivery); + pni_add_tpwork(delivery); } bool pn_delivery_writable(pn_delivery_t *delivery) http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d921c6bc/proton-c/src/object/list.c ---------------------------------------------------------------------- diff --git a/proton-c/src/object/list.c b/proton-c/src/object/list.c index 14231f6..76c70d2 100644 --- a/proton-c/src/object/list.c +++ b/proton-c/src/object/list.c @@ -51,7 +51,7 @@ void pn_list_set(pn_list_t *list, int index, void *value) pn_class_incref(list->clazz, value); } -void pn_list_ensure(pn_list_t *list, size_t capacity) +static void pni_list_ensure(pn_list_t *list, size_t capacity) { assert(list); if (list->capacity < capacity) { @@ -66,7 +66,7 @@ void pn_list_ensure(pn_list_t *list, size_t capacity) int pn_list_add(pn_list_t *list, void *value) { assert(list); - pn_list_ensure(list, list->size + 1); + pni_list_ensure(list, list->size + 1); list->elements[list->size++] = value; pn_class_incref(list->clazz, value); return 0; @@ -130,13 +130,6 @@ void pn_list_clear(pn_list_t *list) pn_list_del(list, 0, list->size); } -void pn_list_fill(pn_list_t *list, void *value, int n) -{ - for (int i = 0; i < n; i++) { - pn_list_add(list, value); - } -} - void pn_list_minpush(pn_list_t *list, void *value) { assert(list); http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d921c6bc/proton-c/src/object/map.c ---------------------------------------------------------------------- diff --git a/proton-c/src/object/map.c b/proton-c/src/object/map.c index c969d24..6ae7792 100644 --- a/proton-c/src/object/map.c +++ b/proton-c/src/object/map.c @@ -265,7 +265,7 @@ void *pn_map_get(pn_map_t *map, void *key) return entry ? entry->value : NULL; } -void pn_map_rehash(pn_map_t *map, size_t index) +static void pni_map_rehash(pn_map_t *map, size_t index) { //reinsert entries in chain starting at index assert(map); @@ -331,7 +331,7 @@ void pn_map_del(pn_map_t *map, void *key) map->size--; if (orig_state == PNI_ENTRY_LINK) { - pn_map_rehash(map, orig_next); + pni_map_rehash(map, orig_next); } // do this last as it may trigger further deletions http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d921c6bc/proton-c/src/parser.c ---------------------------------------------------------------------- diff --git a/proton-c/src/parser.c b/proton-c/src/parser.c index 93b6da4..87cb758 100644 --- a/proton-c/src/parser.c +++ b/proton-c/src/parser.c @@ -47,7 +47,7 @@ pn_parser_t *pn_parser() return parser; } -void pn_parser_ensure(pn_parser_t *parser, size_t size) +static void pni_parser_ensure(pn_parser_t *parser, size_t size) { while (parser->capacity - parser->size < size) { parser->capacity = parser->capacity ? 2 * parser->capacity : 1024; @@ -55,11 +55,6 @@ void pn_parser_ensure(pn_parser_t *parser, size_t size) } } -void pn_parser_line_info(pn_parser_t *parser, int *line, int *col) -{ - pn_scanner_line_info(parser->scanner, line, col); -} - int pn_parser_err(pn_parser_t *parser, int code, const char *fmt, ...) { va_list ap; @@ -88,29 +83,29 @@ void pn_parser_free(pn_parser_t *parser) } } -int pn_parser_shift(pn_parser_t *parser) +static int pni_parser_shift(pn_parser_t *parser) { return pn_scanner_shift(parser->scanner); } -pn_token_t pn_parser_token(pn_parser_t *parser) +static pn_token_t pni_parser_token(pn_parser_t *parser) { return pn_scanner_token(parser->scanner); } -int pn_parser_value(pn_parser_t *parser, pn_data_t *data); +static int pni_parser_value(pn_parser_t *parser, pn_data_t *data); -int pn_parser_descriptor(pn_parser_t *parser, pn_data_t *data) +static int pni_parser_descriptor(pn_parser_t *parser, pn_data_t *data) { - if (pn_parser_token(parser).type == PN_TOK_AT) { - int err = pn_parser_shift(parser); + if (pni_parser_token(parser).type == PN_TOK_AT) { + int err = pni_parser_shift(parser); if (err) return err; err = pn_data_put_described(data); if (err) return pn_parser_err(parser, err, "error writing described"); pn_data_enter(data); for (int i = 0; i < 2; i++) { - err = pn_parser_value(parser, data); + err = pni_parser_value(parser, data); if (err) return err; } pn_data_exit(data); @@ -120,10 +115,10 @@ int pn_parser_descriptor(pn_parser_t *parser, pn_data_t *data) } } -int pn_parser_map(pn_parser_t *parser, pn_data_t *data) +static int pni_parser_map(pn_parser_t *parser, pn_data_t *data) { - if (pn_parser_token(parser).type == PN_TOK_LBRACE) { - int err = pn_parser_shift(parser); + if (pni_parser_token(parser).type == PN_TOK_LBRACE) { + int err = pni_parser_shift(parser); if (err) return err; err = pn_data_put_map(data); @@ -131,23 +126,23 @@ int pn_parser_map(pn_parser_t *parser, pn_data_t *data) pn_data_enter(data); - if (pn_parser_token(parser).type != PN_TOK_RBRACE) { + if (pni_parser_token(parser).type != PN_TOK_RBRACE) { while (true) { - err = pn_parser_value(parser, data); + err = pni_parser_value(parser, data); if (err) return err; - if (pn_parser_token(parser).type == PN_TOK_EQUAL) { - err = pn_parser_shift(parser); + if (pni_parser_token(parser).type == PN_TOK_EQUAL) { + err = pni_parser_shift(parser); if (err) return err; } else { return pn_parser_err(parser, PN_ERR, "expecting '='"); } - err = pn_parser_value(parser, data); + err = pni_parser_value(parser, data); if (err) return err; - if (pn_parser_token(parser).type == PN_TOK_COMMA) { - err = pn_parser_shift(parser); + if (pni_parser_token(parser).type == PN_TOK_COMMA) { + err = pni_parser_shift(parser); if (err) return err; } else { break; @@ -157,8 +152,8 @@ int pn_parser_map(pn_parser_t *parser, pn_data_t *data) pn_data_exit(data); - if (pn_parser_token(parser).type == PN_TOK_RBRACE) { - return pn_parser_shift(parser); + if (pni_parser_token(parser).type == PN_TOK_RBRACE) { + return pni_parser_shift(parser); } else { return pn_parser_err(parser, PN_ERR, "expecting '}'"); } @@ -167,12 +162,12 @@ int pn_parser_map(pn_parser_t *parser, pn_data_t *data) } } -int pn_parser_list(pn_parser_t *parser, pn_data_t *data) +static int pni_parser_list(pn_parser_t *parser, pn_data_t *data) { int err; - if (pn_parser_token(parser).type == PN_TOK_LBRACKET) { - err = pn_parser_shift(parser); + if (pni_parser_token(parser).type == PN_TOK_LBRACKET) { + err = pni_parser_shift(parser); if (err) return err; err = pn_data_put_list(data); @@ -180,13 +175,13 @@ int pn_parser_list(pn_parser_t *parser, pn_data_t *data) pn_data_enter(data); - if (pn_parser_token(parser).type != PN_TOK_RBRACKET) { + if (pni_parser_token(parser).type != PN_TOK_RBRACKET) { while (true) { - err = pn_parser_value(parser, data); + err = pni_parser_value(parser, data); if (err) return err; - if (pn_parser_token(parser).type == PN_TOK_COMMA) { - err = pn_parser_shift(parser); + if (pni_parser_token(parser).type == PN_TOK_COMMA) { + err = pni_parser_shift(parser); if (err) return err; } else { break; @@ -196,8 +191,8 @@ int pn_parser_list(pn_parser_t *parser, pn_data_t *data) pn_data_exit(data); - if (pn_parser_token(parser).type == PN_TOK_RBRACKET) { - return pn_parser_shift(parser); + if (pni_parser_token(parser).type == PN_TOK_RBRACKET) { + return pni_parser_shift(parser); } else { return pn_parser_err(parser, PN_ERR, "expecting ']'"); } @@ -206,13 +201,13 @@ int pn_parser_list(pn_parser_t *parser, pn_data_t *data) } } -void pn_parser_append_tok(pn_parser_t *parser, char *dst, int *idx) +static void pni_parser_append_tok(pn_parser_t *parser, char *dst, int *idx) { - memcpy(dst + *idx, pn_parser_token(parser).start, pn_parser_token(parser).size); - *idx += pn_parser_token(parser).size; + memcpy(dst + *idx, pni_parser_token(parser).start, pni_parser_token(parser).size); + *idx += pni_parser_token(parser).size; } -int pn_parser_number(pn_parser_t *parser, pn_data_t *data) +static int pni_parser_number(pn_parser_t *parser, pn_data_t *data) { bool dbl = false; char number[1024]; @@ -221,17 +216,17 @@ int pn_parser_number(pn_parser_t *parser, pn_data_t *data) bool negate = false; - if (pn_parser_token(parser).type == PN_TOK_NEG || pn_parser_token(parser).type == PN_TOK_POS) { - if (pn_parser_token(parser).type == PN_TOK_NEG) + if (pni_parser_token(parser).type == PN_TOK_NEG || pni_parser_token(parser).type == PN_TOK_POS) { + if (pni_parser_token(parser).type == PN_TOK_NEG) negate = !negate; - err = pn_parser_shift(parser); + err = pni_parser_shift(parser); if (err) return err; } - if (pn_parser_token(parser).type == PN_TOK_FLOAT || pn_parser_token(parser).type == PN_TOK_INT) { - dbl = pn_parser_token(parser).type == PN_TOK_FLOAT; - pn_parser_append_tok(parser, number, &idx); - err = pn_parser_shift(parser); + if (pni_parser_token(parser).type == PN_TOK_FLOAT || pni_parser_token(parser).type == PN_TOK_INT) { + dbl = pni_parser_token(parser).type == PN_TOK_FLOAT; + pni_parser_append_tok(parser, number, &idx); + err = pni_parser_shift(parser); if (err) return err; } else { return pn_parser_err(parser, PN_ERR, "expecting FLOAT or INT"); @@ -258,7 +253,7 @@ int pn_parser_number(pn_parser_t *parser, pn_data_t *data) return 0; } -int pn_parser_unquote(pn_parser_t *parser, char *dst, const char *src, size_t *n) +static int pni_parser_unquote(pn_parser_t *parser, char *dst, const char *src, size_t *n) { size_t idx = 0; bool escape = false; @@ -336,29 +331,29 @@ int pn_parser_unquote(pn_parser_t *parser, char *dst, const char *src, size_t *n return 0; } -int pn_parser_value(pn_parser_t *parser, pn_data_t *data) +static int pni_parser_value(pn_parser_t *parser, pn_data_t *data) { int err; size_t n; char *dst; - pn_token_t tok = pn_parser_token(parser); + pn_token_t tok = pni_parser_token(parser); switch (tok.type) { case PN_TOK_AT: - return pn_parser_descriptor(parser, data); + return pni_parser_descriptor(parser, data); case PN_TOK_LBRACE: - return pn_parser_map(parser, data); + return pni_parser_map(parser, data); case PN_TOK_LBRACKET: - return pn_parser_list(parser, data); + return pni_parser_list(parser, data); case PN_TOK_BINARY: case PN_TOK_SYMBOL: case PN_TOK_STRING: n = tok.size; - pn_parser_ensure(parser, n); + pni_parser_ensure(parser, n); dst = parser->atoms + parser->size; - err = pn_parser_unquote(parser, dst, tok.start, &n); + err = pni_parser_unquote(parser, dst, tok.start, &n); if (err) return err; parser->size += n; switch (tok.type) { @@ -375,42 +370,42 @@ int pn_parser_value(pn_parser_t *parser, pn_data_t *data) return pn_parser_err(parser, PN_ERR, "internal error"); } if (err) return pn_parser_err(parser, err, "error writing string/binary/symbol"); - return pn_parser_shift(parser); + return pni_parser_shift(parser); case PN_TOK_POS: case PN_TOK_NEG: case PN_TOK_FLOAT: case PN_TOK_INT: - return pn_parser_number(parser, data); + return pni_parser_number(parser, data); case PN_TOK_TRUE: err = pn_data_put_bool(data, true); if (err) return pn_parser_err(parser, err, "error writing boolean"); - return pn_parser_shift(parser); + return pni_parser_shift(parser); case PN_TOK_FALSE: err = pn_data_put_bool(data, false); if (err) return pn_parser_err(parser, err, "error writing boolean"); - return pn_parser_shift(parser); + return pni_parser_shift(parser); case PN_TOK_NULL: err = pn_data_put_null(data); if (err) return pn_parser_err(parser, err, "error writing null"); - return pn_parser_shift(parser); + return pni_parser_shift(parser); default: return pn_parser_err(parser, PN_ERR, "expecting one of '[', '{', STRING, " "SYMBOL, BINARY, true, false, null, NUMBER"); } } -int pn_parser_parse_r(pn_parser_t *parser, pn_data_t *data) +static int pni_parser_parse_r(pn_parser_t *parser, pn_data_t *data) { while (true) { int err; - switch (pn_parser_token(parser).type) + switch (pni_parser_token(parser).type) { case PN_TOK_EOS: return 0; case PN_TOK_ERR: return PN_ERR; default: - err = pn_parser_value(parser, data); + err = pni_parser_value(parser, data); if (err) return err; } } @@ -421,5 +416,5 @@ int pn_parser_parse(pn_parser_t *parser, const char *str, pn_data_t *data) int err = pn_scanner_start(parser->scanner, str); if (err) return err; parser->size = 0; - return pn_parser_parse_r(parser, data); + return pni_parser_parse_r(parser, data); } http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d921c6bc/proton-c/src/scanner.c ---------------------------------------------------------------------- diff --git a/proton-c/src/scanner.c b/proton-c/src/scanner.c index ef54db4..84d8e3f 100644 --- a/proton-c/src/scanner.c +++ b/proton-c/src/scanner.c @@ -41,7 +41,7 @@ struct pn_scanner_t { pn_error_t *error; }; -const char *pn_token_type(pn_token_type_t type) +static const char *pni_token_type(pn_token_type_t type) { switch (type) { @@ -132,7 +132,7 @@ int pn_scanner_verr(pn_scanner_t *scanner, int code, const char *fmt, va_list ap int size = scanner->token.size; int ln = snprintf(error, ERROR_SIZE, "input line %i column %i %s:'%.*s': ", line, col, - pn_token_type(scanner->token.type), + pni_token_type(scanner->token.type), size, scanner->token.start); if (ln >= ERROR_SIZE) { return pn_scanner_err(scanner, code, "error info truncated"); @@ -161,14 +161,14 @@ const char *pn_scanner_error(pn_scanner_t *scanner) return pn_error_text(scanner->error); } -void pn_scanner_emit(pn_scanner_t *scanner, pn_token_type_t type, const char *start, size_t size) +static void pni_scanner_emit(pn_scanner_t *scanner, pn_token_type_t type, const char *start, size_t size) { scanner->token.type = type; scanner->token.start = start; scanner->token.size = size; } -int pn_scanner_quoted(pn_scanner_t *scanner, const char *str, int start, +static int pni_scanner_quoted(pn_scanner_t *scanner, const char *str, int start, pn_token_type_t type) { bool escape = false; @@ -181,7 +181,7 @@ int pn_scanner_quoted(pn_scanner_t *scanner, const char *str, int start, switch (c) { case '\0': case '"': - pn_scanner_emit(scanner, c ? type : PN_TOK_ERR, + pni_scanner_emit(scanner, c ? type : PN_TOK_ERR, str, c ? i + 1 : i); return c ? 0 : pn_scanner_err(scanner, PN_ERR, "missmatched quote"); case '\\': @@ -192,17 +192,17 @@ int pn_scanner_quoted(pn_scanner_t *scanner, const char *str, int start, } } -int pn_scanner_binary(pn_scanner_t *scanner, const char *str) +static int pni_scanner_binary(pn_scanner_t *scanner, const char *str) { - return pn_scanner_quoted(scanner, str, 2, PN_TOK_BINARY); + return pni_scanner_quoted(scanner, str, 2, PN_TOK_BINARY); } -int pn_scanner_string(pn_scanner_t *scanner, const char *str) +static int pni_scanner_string(pn_scanner_t *scanner, const char *str) { - return pn_scanner_quoted(scanner, str, 1, PN_TOK_STRING); + return pni_scanner_quoted(scanner, str, 1, PN_TOK_STRING); } -int pn_scanner_alpha_end(pn_scanner_t *scanner, const char *str, int start) +static int pni_scanner_alpha_end(pn_scanner_t *scanner, const char *str, int start) { for (int i = start; true; i++) { char c = str[i]; @@ -212,9 +212,9 @@ int pn_scanner_alpha_end(pn_scanner_t *scanner, const char *str, int start) } } -int pn_scanner_alpha(pn_scanner_t *scanner, const char *str) +static int pni_scanner_alpha(pn_scanner_t *scanner, const char *str) { - int n = pn_scanner_alpha_end(scanner, str, 0); + int n = pni_scanner_alpha_end(scanner, str, 0); pn_token_type_t type; if (!strncmp(str, "true", n)) { type = PN_TOK_TRUE; @@ -226,24 +226,24 @@ int pn_scanner_alpha(pn_scanner_t *scanner, const char *str) type = PN_TOK_ID; } - pn_scanner_emit(scanner, type, str, n); + pni_scanner_emit(scanner, type, str, n); return type == PN_TOK_ERR ? pn_scanner_err(scanner, PN_ERR, "unrecognized keyword") : 0; } -int pn_scanner_symbol(pn_scanner_t *scanner, const char *str) +static int pni_scanner_symbol(pn_scanner_t *scanner, const char *str) { char c = str[1]; if (c == '"') { - return pn_scanner_quoted(scanner, str, 2, PN_TOK_SYMBOL); + return pni_scanner_quoted(scanner, str, 2, PN_TOK_SYMBOL); } else { - int n = pn_scanner_alpha_end(scanner, str, 1); - pn_scanner_emit(scanner, PN_TOK_SYMBOL, str, n); + int n = pni_scanner_alpha_end(scanner, str, 1); + pni_scanner_emit(scanner, PN_TOK_SYMBOL, str, n); return 0; } } -int pn_scanner_number(pn_scanner_t *scanner, const char *str) +static int pni_scanner_number(pn_scanner_t *scanner, const char *str) { bool dot = false; bool exp = false; @@ -262,7 +262,7 @@ int pn_scanner_number(pn_scanner_t *scanner, const char *str) continue; case '.': if (dot) { - pn_scanner_emit(scanner, PN_TOK_FLOAT, str, i); + pni_scanner_emit(scanner, PN_TOK_FLOAT, str, i); return 0; } else { dot = true; @@ -271,7 +271,7 @@ int pn_scanner_number(pn_scanner_t *scanner, const char *str) case 'e': case 'E': if (exp) { - pn_scanner_emit(scanner, PN_TOK_FLOAT, str, i); + pni_scanner_emit(scanner, PN_TOK_FLOAT, str, i); return 0; } else { dot = true; @@ -283,19 +283,19 @@ int pn_scanner_number(pn_scanner_t *scanner, const char *str) } default: if (dot || exp) { - pn_scanner_emit(scanner, PN_TOK_FLOAT, str, i); + pni_scanner_emit(scanner, PN_TOK_FLOAT, str, i); return 0; } else { - pn_scanner_emit(scanner, PN_TOK_INT, str, i); + pni_scanner_emit(scanner, PN_TOK_INT, str, i); return 0; } } } } -int pn_scanner_single(pn_scanner_t *scanner, const char *str, pn_token_type_t type) +static int pni_scanner_single(pn_scanner_t *scanner, const char *str, pn_token_type_t type) { - pn_scanner_emit(scanner, type, str, 1); + pni_scanner_emit(scanner, type, str, 1); return 0; } @@ -317,54 +317,54 @@ int pn_scanner_scan(pn_scanner_t *scanner) switch (c) { case '{': - return pn_scanner_single(scanner, str, PN_TOK_LBRACE); + return pni_scanner_single(scanner, str, PN_TOK_LBRACE); case '}': - return pn_scanner_single(scanner, str, PN_TOK_RBRACE); + return pni_scanner_single(scanner, str, PN_TOK_RBRACE); case'[': - return pn_scanner_single(scanner, str, PN_TOK_LBRACKET); + return pni_scanner_single(scanner, str, PN_TOK_LBRACKET); case ']': - return pn_scanner_single(scanner, str, PN_TOK_RBRACKET); + return pni_scanner_single(scanner, str, PN_TOK_RBRACKET); case '=': - return pn_scanner_single(scanner, str, PN_TOK_EQUAL); + return pni_scanner_single(scanner, str, PN_TOK_EQUAL); case ',': - return pn_scanner_single(scanner, str, PN_TOK_COMMA); + return pni_scanner_single(scanner, str, PN_TOK_COMMA); case '.': n = *(str+1); if ((n >= '0' && n <= '9')) { - return pn_scanner_number(scanner, str); + return pni_scanner_number(scanner, str); } else { - return pn_scanner_single(scanner, str, PN_TOK_DOT); + return pni_scanner_single(scanner, str, PN_TOK_DOT); } case '@': - return pn_scanner_single(scanner, str, PN_TOK_AT); + return pni_scanner_single(scanner, str, PN_TOK_AT); case '$': - return pn_scanner_single(scanner, str, PN_TOK_DOLLAR); + return pni_scanner_single(scanner, str, PN_TOK_DOLLAR); case '-': n = *(str+1); if ((n >= '0' && n <= '9') || n == '.') { - return pn_scanner_number(scanner, str); + return pni_scanner_number(scanner, str); } else { - return pn_scanner_single(scanner, str, PN_TOK_NEG); + return pni_scanner_single(scanner, str, PN_TOK_NEG); } case '+': n = *(str+1); if ((n >= '0' && n <= '9') || n == '.') { - return pn_scanner_number(scanner, str); + return pni_scanner_number(scanner, str); } else { - return pn_scanner_single(scanner, str, PN_TOK_POS); + return pni_scanner_single(scanner, str, PN_TOK_POS); } case ' ': case '\t': case '\r': case '\v': case '\f': case '\n': break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': - return pn_scanner_number(scanner, str); + return pni_scanner_number(scanner, str); case ':': - return pn_scanner_symbol(scanner, str); + return pni_scanner_symbol(scanner, str); case '"': - return pn_scanner_string(scanner, str); + return pni_scanner_string(scanner, str); case 'b': if (str[1] == '"') { - return pn_scanner_binary(scanner, str); + return pni_scanner_binary(scanner, str); } case 'a': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': @@ -374,12 +374,12 @@ int pn_scanner_scan(pn_scanner_t *scanner) case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': - return pn_scanner_alpha(scanner, str); + return pni_scanner_alpha(scanner, str); case '\0': - pn_scanner_emit(scanner, PN_TOK_EOS, str, 0); + pni_scanner_emit(scanner, PN_TOK_EOS, str, 0); return PN_EOS; default: - pn_scanner_emit(scanner, PN_TOK_ERR, str, 1); + pni_scanner_emit(scanner, PN_TOK_ERR, str, 1); return pn_scanner_err(scanner, PN_ERR, "illegal character"); } } --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
