You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by as...@apache.org on 2016/11/14 18:28:39 UTC
[18/20] qpid-proton git commit: PROTON-1350 PROTON-1351: Introduce
proton-c core library - Created new core proton library qpid-proton-core
which only contains protocol processsing and no IO. - Rearranged source tree
to separate core protocol code and
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/a5850716/proton-c/src/buffer.c
----------------------------------------------------------------------
diff --git a/proton-c/src/buffer.c b/proton-c/src/buffer.c
deleted file mode 100644
index c3015f4..0000000
--- a/proton-c/src/buffer.c
+++ /dev/null
@@ -1,310 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
- */
-
-#include <proton/error.h>
-#ifndef __cplusplus
-#include <stdbool.h>
-#endif
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "buffer.h"
-#include "util.h"
-
-struct pn_buffer_t {
- size_t capacity;
- size_t start;
- size_t size;
- char *bytes;
-};
-
-pn_buffer_t *pn_buffer(size_t capacity)
-{
- pn_buffer_t *buf = (pn_buffer_t *) malloc(sizeof(pn_buffer_t));
- if (buf != NULL) {
- buf->capacity = capacity;
- buf->start = 0;
- buf->size = 0;
- if (capacity > 0) {
- buf->bytes = (char *)malloc(capacity);
- if (buf->bytes == NULL) {
- free(buf);
- buf = NULL;
- }
- }
- else {
- buf->bytes = NULL;
- }
- }
- return buf;
-}
-
-void pn_buffer_free(pn_buffer_t *buf)
-{
- if (buf) {
- free(buf->bytes);
- free(buf);
- }
-}
-
-size_t pn_buffer_size(pn_buffer_t *buf)
-{
- return buf->size;
-}
-
-size_t pn_buffer_capacity(pn_buffer_t *buf)
-{
- return buf->capacity;
-}
-
-size_t pn_buffer_available(pn_buffer_t *buf)
-{
- return buf->capacity - buf->size;
-}
-
-static size_t pni_buffer_head(pn_buffer_t *buf)
-{
- return buf->start;
-}
-
-static size_t pni_buffer_tail(pn_buffer_t *buf)
-{
- size_t tail = buf->start + buf->size;
- if (tail >= buf->capacity)
- tail -= buf->capacity;
- return tail;
-}
-
-static bool pni_buffer_wrapped(pn_buffer_t *buf)
-{
- return buf->size && pni_buffer_head(buf) >= pni_buffer_tail(buf);
-}
-
-static size_t pni_buffer_tail_space(pn_buffer_t *buf)
-{
- if (pni_buffer_wrapped(buf)) {
- return pn_buffer_available(buf);
- } else {
- return buf->capacity - pni_buffer_tail(buf);
- }
-}
-
-static size_t pni_buffer_head_space(pn_buffer_t *buf)
-{
- if (pni_buffer_wrapped(buf)) {
- return pn_buffer_available(buf);
- } else {
- return pni_buffer_head(buf);
- }
-}
-
-static size_t pni_buffer_head_size(pn_buffer_t *buf)
-{
- if (pni_buffer_wrapped(buf)) {
- return buf->capacity - pni_buffer_head(buf);
- } else {
- return pni_buffer_tail(buf) - pni_buffer_head(buf);
- }
-}
-
-static size_t pni_buffer_tail_size(pn_buffer_t *buf)
-{
- if (pni_buffer_wrapped(buf)) {
- return pni_buffer_tail(buf);
- } else {
- return 0;
- }
-}
-
-int pn_buffer_ensure(pn_buffer_t *buf, size_t size)
-{
- size_t old_capacity = buf->capacity;
- 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);
- }
-
- if (buf->capacity != old_capacity) {
- char* new_bytes = (char *)realloc(buf->bytes, buf->capacity);
- if (new_bytes) {
- buf->bytes = new_bytes;
-
- if (wrapped) {
- size_t n = old_capacity - old_head;
- memmove(buf->bytes + buf->capacity - n, buf->bytes + old_head, n);
- buf->start = buf->capacity - n;
- }
- }
- }
-
- return 0;
-}
-
-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 = 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);
- memmove(buf->bytes, bytes + n, size - n);
-
- buf->size += size;
-
- return 0;
-}
-
-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 = 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);
- memmove(buf->bytes + buf->capacity - (size - n), bytes, size - n);
-
- if (buf->start >= size) {
- buf->start -= size;
- } else {
- buf->start = buf->capacity - (size - buf->start);
- }
-
- buf->size += size;
-
- return 0;
-}
-
-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;
- return result;
-}
-
-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 = pni_buffer_index(buf, offset);
- size_t stop = pni_buffer_index(buf, offset + size);
-
- if (size == 0) return 0;
-
- size_t sz1;
- size_t sz2;
-
- if (start >= stop) {
- sz1 = buf->capacity - start;
- sz2 = stop;
- } else {
- sz1 = stop - start;
- sz2 = 0;
- }
-
- memmove(dst, buf->bytes + start, sz1);
- memmove(dst + sz1, buf->bytes, sz2);
-
- return sz1 + sz2;
-}
-
-int pn_buffer_trim(pn_buffer_t *buf, size_t left, size_t right)
-{
- if (left + right > buf->size) return PN_ARG_ERR;
-
- buf->start += left;
- if (buf->start >= buf->capacity)
- buf->start -= buf->capacity;
-
- buf->size -= left + right;
-
- return 0;
-}
-
-void pn_buffer_clear(pn_buffer_t *buf)
-{
- buf->start = 0;
- buf->size = 0;
-}
-
-static void pn_buffer_rotate (pn_buffer_t *buf, size_t sz) {
- if (sz == 0) return;
-
- unsigned c = 0, v = 0;
- for (; c < buf->capacity; v++) {
- unsigned t = v, tp = v + sz;
- char tmp = buf->bytes[v];
- c++;
- while (tp != v) {
- buf->bytes[t] = buf->bytes[tp];
- t = tp;
- tp += sz;
- if (tp >= buf->capacity) tp -= buf->capacity;
- c++;
- }
- buf->bytes[t] = tmp;
- }
-}
-
-int pn_buffer_defrag(pn_buffer_t *buf)
-{
- pn_buffer_rotate(buf, buf->start);
- buf->start = 0;
- return 0;
-}
-
-pn_bytes_t pn_buffer_bytes(pn_buffer_t *buf)
-{
- if (buf) {
- pn_buffer_defrag(buf);
- return pn_bytes(buf->size, buf->bytes);
- } else {
- return pn_bytes(0, NULL);
- }
-}
-
-pn_rwbytes_t pn_buffer_memory(pn_buffer_t *buf)
-{
- if (buf) {
- pn_buffer_defrag(buf);
- pn_rwbytes_t r = {buf->size, buf->bytes};
- return r;
- } else {
- pn_rwbytes_t r = {0, NULL};
- return r;
- }
-}
-
-int pn_buffer_print(pn_buffer_t *buf)
-{
- printf("pn_buffer(\"");
- 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/a5850716/proton-c/src/buffer.h
----------------------------------------------------------------------
diff --git a/proton-c/src/buffer.h b/proton-c/src/buffer.h
deleted file mode 100644
index da557ef..0000000
--- a/proton-c/src/buffer.h
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef PROTON_BUFFER_H
-#define PROTON_BUFFER_H 1
-
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
- */
-
-#include <proton/import_export.h>
-#include <proton/types.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct pn_buffer_t pn_buffer_t;
-
-pn_buffer_t *pn_buffer(size_t capacity);
-void pn_buffer_free(pn_buffer_t *buf);
-size_t pn_buffer_size(pn_buffer_t *buf);
-size_t pn_buffer_capacity(pn_buffer_t *buf);
-size_t pn_buffer_available(pn_buffer_t *buf);
-int pn_buffer_ensure(pn_buffer_t *buf, size_t size);
-int pn_buffer_append(pn_buffer_t *buf, const char *bytes, size_t size);
-int pn_buffer_prepend(pn_buffer_t *buf, const char *bytes, size_t size);
-size_t pn_buffer_get(pn_buffer_t *buf, size_t offset, size_t size, char *dst);
-int pn_buffer_trim(pn_buffer_t *buf, size_t left, size_t right);
-void pn_buffer_clear(pn_buffer_t *buf);
-int pn_buffer_defrag(pn_buffer_t *buf);
-pn_bytes_t pn_buffer_bytes(pn_buffer_t *buf);
-pn_rwbytes_t pn_buffer_memory(pn_buffer_t *buf);
-int pn_buffer_print(pn_buffer_t *buf);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* buffer.h */
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/a5850716/proton-c/src/codec/codec.c
----------------------------------------------------------------------
diff --git a/proton-c/src/codec/codec.c b/proton-c/src/codec/codec.c
deleted file mode 100644
index 2a4532c..0000000
--- a/proton-c/src/codec/codec.c
+++ /dev/null
@@ -1,2142 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
- */
-
-#include <proton/object.h>
-#include <proton/codec.h>
-#include <proton/error.h>
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include "encodings.h"
-#define DEFINE_FIELDS
-#include "protocol.h"
-#include "platform.h"
-#include "platform_fmt.h"
-#include "util.h"
-#include "decoder.h"
-#include "encoder.h"
-#include "data.h"
-#include "log_private.h"
-
-const char *pn_type_name(pn_type_t type)
-{
- switch (type)
- {
- case PN_NULL: return "PN_NULL";
- case PN_BOOL: return "PN_BOOL";
- case PN_UBYTE: return "PN_UBYTE";
- case PN_BYTE: return "PN_BYTE";
- case PN_USHORT: return "PN_USHORT";
- case PN_SHORT: return "PN_SHORT";
- case PN_UINT: return "PN_UINT";
- case PN_INT: return "PN_INT";
- case PN_CHAR: return "PN_CHAR";
- case PN_ULONG: return "PN_ULONG";
- case PN_LONG: return "PN_LONG";
- case PN_TIMESTAMP: return "PN_TIMESTAMP";
- case PN_FLOAT: return "PN_FLOAT";
- case PN_DOUBLE: return "PN_DOUBLE";
- case PN_DECIMAL32: return "PN_DECIMAL32";
- case PN_DECIMAL64: return "PN_DECIMAL64";
- case PN_DECIMAL128: return "PN_DECIMAL128";
- case PN_UUID: return "PN_UUID";
- case PN_BINARY: return "PN_BINARY";
- case PN_STRING: return "PN_STRING";
- case PN_SYMBOL: return "PN_SYMBOL";
- case PN_DESCRIBED: return "PN_DESCRIBED";
- case PN_ARRAY: return "PN_ARRAY";
- case PN_LIST: return "PN_LIST";
- case PN_MAP: return "PN_MAP";
- default: break;
- }
-
- return "<UNKNOWN>";
-}
-
-static inline void pni_atom_init(pn_atom_t *atom, pn_type_t type)
-{
- memset(atom, 0, sizeof(pn_atom_t));
- atom->type = type;
-}
-
-// data
-
-static void pn_data_finalize(void *object)
-{
- pn_data_t *data = (pn_data_t *) object;
- free(data->nodes);
- pn_buffer_free(data->buf);
- pn_free(data->str);
- pn_error_free(data->error);
- pn_free(data->decoder);
- pn_free(data->encoder);
-}
-
-static const pn_fields_t *pni_node_fields(pn_data_t *data, pni_node_t *node)
-{
- if (!node) return NULL;
- if (node->atom.type != PN_DESCRIBED) return NULL;
-
- pni_node_t *descriptor = pn_data_node(data, node->down);
-
- if (!descriptor || descriptor->atom.type != PN_ULONG) {
- return NULL;
- }
-
- if (descriptor->atom.u.as_ulong >= FIELD_MIN && descriptor->atom.u.as_ulong <= FIELD_MAX) {
- const pn_fields_t *f = &FIELDS[descriptor->atom.u.as_ulong-FIELD_MIN];
- return (f->name_index!=0) ? f : NULL;
- } else {
- return NULL;
- }
-}
-
-static int pni_node_index(pn_data_t *data, pni_node_t *node)
-{
- int count = 0;
- while (node) {
- node = pn_data_node(data, node->prev);
- count++;
- }
- return count - 1;
-}
-
-int pni_inspect_atom(pn_atom_t *atom, pn_string_t *str)
-{
- switch (atom->type) {
- case PN_NULL:
- return pn_string_addf(str, "null");
- case PN_BOOL:
- return pn_string_addf(str, atom->u.as_bool ? "true" : "false");
- case PN_UBYTE:
- return pn_string_addf(str, "%" PRIu8, atom->u.as_ubyte);
- case PN_BYTE:
- return pn_string_addf(str, "%" PRIi8, atom->u.as_byte);
- case PN_USHORT:
- return pn_string_addf(str, "%" PRIu16, atom->u.as_ushort);
- case PN_SHORT:
- return pn_string_addf(str, "%" PRIi16, atom->u.as_short);
- case PN_UINT:
- return pn_string_addf(str, "%" PRIu32, atom->u.as_uint);
- case PN_INT:
- return pn_string_addf(str, "%" PRIi32, atom->u.as_int);
- case PN_CHAR:
- return pn_string_addf(str, "%c", atom->u.as_char);
- case PN_ULONG:
- return pn_string_addf(str, "%" PRIu64, atom->u.as_ulong);
- case PN_LONG:
- return pn_string_addf(str, "%" PRIi64, atom->u.as_long);
- case PN_TIMESTAMP:
- return pn_string_addf(str, "%" PRIi64, atom->u.as_timestamp);
- case PN_FLOAT:
- return pn_string_addf(str, "%g", atom->u.as_float);
- case PN_DOUBLE:
- return pn_string_addf(str, "%g", atom->u.as_double);
- case PN_DECIMAL32:
- return pn_string_addf(str, "D32(%" PRIu32 ")", atom->u.as_decimal32);
- case PN_DECIMAL64:
- return pn_string_addf(str, "D64(%" PRIu64 ")", atom->u.as_decimal64);
- case PN_DECIMAL128:
- return pn_string_addf(str, "D128(%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx"
- "%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx"
- "%02hhx%02hhx)",
- atom->u.as_decimal128.bytes[0],
- atom->u.as_decimal128.bytes[1],
- atom->u.as_decimal128.bytes[2],
- atom->u.as_decimal128.bytes[3],
- atom->u.as_decimal128.bytes[4],
- atom->u.as_decimal128.bytes[5],
- atom->u.as_decimal128.bytes[6],
- atom->u.as_decimal128.bytes[7],
- atom->u.as_decimal128.bytes[8],
- atom->u.as_decimal128.bytes[9],
- atom->u.as_decimal128.bytes[10],
- atom->u.as_decimal128.bytes[11],
- atom->u.as_decimal128.bytes[12],
- atom->u.as_decimal128.bytes[13],
- atom->u.as_decimal128.bytes[14],
- atom->u.as_decimal128.bytes[15]);
- case PN_UUID:
- return pn_string_addf(str, "UUID(%02hhx%02hhx%02hhx%02hhx-"
- "%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-"
- "%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx)",
- atom->u.as_uuid.bytes[0],
- atom->u.as_uuid.bytes[1],
- atom->u.as_uuid.bytes[2],
- atom->u.as_uuid.bytes[3],
- atom->u.as_uuid.bytes[4],
- atom->u.as_uuid.bytes[5],
- atom->u.as_uuid.bytes[6],
- atom->u.as_uuid.bytes[7],
- atom->u.as_uuid.bytes[8],
- atom->u.as_uuid.bytes[9],
- atom->u.as_uuid.bytes[10],
- atom->u.as_uuid.bytes[11],
- atom->u.as_uuid.bytes[12],
- atom->u.as_uuid.bytes[13],
- atom->u.as_uuid.bytes[14],
- atom->u.as_uuid.bytes[15]);
- case PN_BINARY:
- case PN_STRING:
- case PN_SYMBOL:
- {
- int err;
- const char *pfx;
- pn_bytes_t bin = atom->u.as_bytes;
- bool quote;
- switch (atom->type) {
- case PN_BINARY:
- pfx = "b";
- quote = true;
- break;
- case PN_STRING:
- pfx = "";
- quote = true;
- break;
- case PN_SYMBOL:
- pfx = ":";
- quote = false;
- for (unsigned i = 0; i < bin.size; i++) {
- if (!isalpha(bin.start[i])) {
- quote = true;
- break;
- }
- }
- break;
- default:
- assert(false);
- return PN_ERR;
- }
-
- if ((err = pn_string_addf(str, "%s", pfx))) return err;
- if (quote) if ((err = pn_string_addf(str, "\""))) return err;
- if ((err = pn_quote(str, bin.start, bin.size))) return err;
- if (quote) if ((err = pn_string_addf(str, "\""))) return err;
- return 0;
- }
- case PN_LIST:
- return pn_string_addf(str, "<list>");
- case PN_MAP:
- return pn_string_addf(str, "<map>");
- case PN_ARRAY:
- return pn_string_addf(str, "<array>");
- case PN_DESCRIBED:
- return pn_string_addf(str, "<described>");
- default:
- return pn_string_addf(str, "<undefined: %i>", atom->type);
- }
-}
-
-int pni_inspect_enter(void *ctx, pn_data_t *data, pni_node_t *node)
-{
- pn_string_t *str = (pn_string_t *) ctx;
- pn_atom_t *atom = (pn_atom_t *) &node->atom;
-
- pni_node_t *parent = pn_data_node(data, node->parent);
- const pn_fields_t *fields = pni_node_fields(data, parent);
- pni_node_t *grandparent = parent ? pn_data_node(data, parent->parent) : NULL;
- const pn_fields_t *grandfields = pni_node_fields(data, grandparent);
- int index = pni_node_index(data, node);
-
- int err;
-
- if (grandfields) {
- if (atom->type == PN_NULL) {
- return 0;
- }
- const char *name = (index < grandfields->field_count)
- ? FIELD_STRINGPOOL.STRING0+FIELD_FIELDS[grandfields->first_field_index+index]
- : NULL;
- if (name) {
- err = pn_string_addf(str, "%s=", name);
- if (err) return err;
- }
- }
-
- switch (atom->type) {
- case PN_DESCRIBED:
- return pn_string_addf(str, "@");
- case PN_ARRAY:
- // XXX: need to fix for described arrays
- return pn_string_addf(str, "@%s[", pn_type_name(node->type));
- case PN_LIST:
- return pn_string_addf(str, "[");
- case PN_MAP:
- return pn_string_addf(str, "{");
- default:
- if (fields && index == 0) {
- err = pn_string_addf(str, "%s", FIELD_STRINGPOOL.STRING0+FIELD_NAME[fields->name_index]);
- if (err) return err;
- err = pn_string_addf(str, "(");
- if (err) return err;
- err = pni_inspect_atom(atom, str);
- if (err) return err;
- return pn_string_addf(str, ")");
- } else {
- return pni_inspect_atom(atom, str);
- }
- }
-}
-
-pni_node_t *pni_next_nonnull(pn_data_t *data, pni_node_t *node)
-{
- while (node) {
- node = pn_data_node(data, node->next);
- if (node && node->atom.type != PN_NULL) {
- return node;
- }
- }
-
- return NULL;
-}
-
-int pni_inspect_exit(void *ctx, pn_data_t *data, pni_node_t *node)
-{
- pn_string_t *str = (pn_string_t *) ctx;
- pni_node_t *parent = pn_data_node(data, node->parent);
- pni_node_t *grandparent = parent ? pn_data_node(data, parent->parent) : NULL;
- const pn_fields_t *grandfields = pni_node_fields(data, grandparent);
- pni_node_t *next = pn_data_node(data, node->next);
- int err;
-
- switch (node->atom.type) {
- case PN_ARRAY:
- case PN_LIST:
- err = pn_string_addf(str, "]");
- if (err) return err;
- break;
- case PN_MAP:
- err = pn_string_addf(str, "}");
- if (err) return err;
- break;
- default:
- break;
- }
-
- if (!grandfields || node->atom.type != PN_NULL) {
- if (next) {
- int index = pni_node_index(data, node);
- if (parent && parent->atom.type == PN_MAP && (index % 2) == 0) {
- err = pn_string_addf(str, "=");
- } else if (parent && parent->atom.type == PN_DESCRIBED && index == 0) {
- err = pn_string_addf(str, " ");
- if (err) return err;
- } else {
- if (!grandfields || pni_next_nonnull(data, node)) {
- err = pn_string_addf(str, ", ");
- if (err) return err;
- }
- }
- }
- }
-
- return 0;
-}
-
-static int pn_data_inspect(void *obj, pn_string_t *dst)
-{
- pn_data_t *data = (pn_data_t *) obj;
-
- return pni_data_traverse(data, pni_inspect_enter, pni_inspect_exit, dst);
-}
-
-#define pn_data_initialize NULL
-#define pn_data_hashcode NULL
-#define pn_data_compare NULL
-
-pn_data_t *pn_data(size_t capacity)
-{
- static const pn_class_t clazz = PN_CLASS(pn_data);
- pn_data_t *data = (pn_data_t *) pn_class_new(&clazz, sizeof(pn_data_t));
- data->capacity = capacity;
- data->size = 0;
- data->nodes = capacity ? (pni_node_t *) malloc(capacity * sizeof(pni_node_t)) : NULL;
- data->buf = pn_buffer(64);
- data->parent = 0;
- data->current = 0;
- data->base_parent = 0;
- data->base_current = 0;
- data->decoder = pn_decoder();
- data->encoder = pn_encoder();
- data->error = pn_error();
- data->str = pn_string(NULL);
- return data;
-}
-
-void pn_data_free(pn_data_t *data)
-{
- pn_free(data);
-}
-
-int pn_data_errno(pn_data_t *data)
-{
- return pn_error_code(data->error);
-}
-
-pn_error_t *pn_data_error(pn_data_t *data)
-{
- return data->error;
-}
-
-size_t pn_data_size(pn_data_t *data)
-{
- return data ? data->size : 0;
-}
-
-void pn_data_clear(pn_data_t *data)
-{
- if (data) {
- data->size = 0;
- data->parent = 0;
- data->current = 0;
- data->base_parent = 0;
- data->base_current = 0;
- pn_buffer_clear(data->buf);
- }
-}
-
-static int pni_data_grow(pn_data_t *data)
-{
- size_t capacity = data->capacity ? data->capacity : 2;
- if (capacity >= PNI_NID_MAX) return PN_OUT_OF_MEMORY;
- else if (capacity < PNI_NID_MAX/2) capacity *= 2;
- else capacity = PNI_NID_MAX;
-
- pni_node_t *new_nodes = (pni_node_t *)realloc(data->nodes, capacity * sizeof(pni_node_t));
- if (new_nodes == NULL) return PN_OUT_OF_MEMORY;
- data->capacity = capacity;
- data->nodes = new_nodes;
- return 0;
-}
-
-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);
- if (err) return err;
- err = pn_buffer_append(data->buf, "\0", 1);
- if (err) return err;
- return offset;
-}
-
-static pn_bytes_t *pni_data_bytes(pn_data_t *data, pni_node_t *node)
-{
- switch (node->atom.type) {
- case PN_BINARY:
- case PN_STRING:
- case PN_SYMBOL:
- return &node->atom.u.as_bytes;
- default: return NULL;
- }
-}
-
-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 = pni_data_bytes(data, node);
- bytes->start = base + node->data_offset;
- }
- }
-}
-
-static int pni_data_intern_node(pn_data_t *data, pni_node_t *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 = pni_data_intern(data, bytes->start, bytes->size);
- if (offset < 0) return offset;
- node->data = true;
- node->data_offset = offset;
- node->data_size = bytes->size;
- pn_rwbytes_t buf = pn_buffer_memory(data->buf);
- bytes->start = buf.start + offset;
-
- if (pn_buffer_capacity(data->buf) != oldcap) {
- pni_data_rebase(data, buf.start);
- }
-
- return 0;
-}
-
-int pn_data_vfill(pn_data_t *data, const char *fmt, va_list ap)
-{
- int err = 0;
- const char *begin = fmt;
- while (*fmt) {
- char code = *(fmt++);
- if (!code) return 0;
-
- switch (code) {
- case 'n':
- err = pn_data_put_null(data);
- break;
- case 'o':
- err = pn_data_put_bool(data, va_arg(ap, int));
- break;
- case 'B':
- err = pn_data_put_ubyte(data, va_arg(ap, unsigned int));
- break;
- case 'b':
- err = pn_data_put_byte(data, va_arg(ap, int));
- break;
- case 'H':
- err = pn_data_put_ushort(data, va_arg(ap, unsigned int));
- break;
- case 'h':
- err = pn_data_put_short(data, va_arg(ap, int));
- break;
- case 'I':
- err = pn_data_put_uint(data, va_arg(ap, uint32_t));
- break;
- case 'i':
- err = pn_data_put_int(data, va_arg(ap, uint32_t));
- break;
- case 'L':
- err = pn_data_put_ulong(data, va_arg(ap, uint64_t));
- break;
- case 'l':
- err = pn_data_put_long(data, va_arg(ap, int64_t));
- break;
- case 't':
- err = pn_data_put_timestamp(data, va_arg(ap, pn_timestamp_t));
- break;
- case 'f':
- err = pn_data_put_float(data, va_arg(ap, double));
- break;
- case 'd':
- err = pn_data_put_double(data, va_arg(ap, double));
- break;
- case 'z':
- {
- // For maximum portability, caller must pass these as two separate args, not a single struct
- size_t size = va_arg(ap, size_t);
- char *start = va_arg(ap, char *);
- if (start) {
- err = pn_data_put_binary(data, pn_bytes(size, start));
- } else {
- err = pn_data_put_null(data);
- }
- }
- break;
- case 'S':
- case 's':
- {
- char *start = va_arg(ap, char *);
- size_t size;
- if (start) {
- size = strlen(start);
- if (code == 'S') {
- err = pn_data_put_string(data, pn_bytes(size, start));
- } else {
- err = pn_data_put_symbol(data, pn_bytes(size, start));
- }
- } else {
- err = pn_data_put_null(data);
- }
- }
- break;
- case 'D':
- err = pn_data_put_described(data);
- pn_data_enter(data);
- break;
- case 'T':
- {
- pni_node_t *parent = pn_data_node(data, data->parent);
- if (parent->atom.type == PN_ARRAY) {
- parent->type = (pn_type_t) va_arg(ap, int);
- } else {
- return pn_error_format(data->error, PN_ERR, "naked type");
- }
- }
- break;
- case '@':
- {
- bool described;
- if (*(fmt + 1) == 'D') {
- fmt++;
- described = true;
- } else {
- described = false;
- }
- err = pn_data_put_array(data, described, (pn_type_t) 0);
- pn_data_enter(data);
- }
- break;
- case '[':
- if (fmt < (begin + 2) || *(fmt - 2) != 'T') {
- err = pn_data_put_list(data);
- if (err) return err;
- pn_data_enter(data);
- }
- break;
- case '{':
- err = pn_data_put_map(data);
- if (err) return err;
- pn_data_enter(data);
- break;
- case '}':
- case ']':
- if (!pn_data_exit(data))
- return pn_error_format(data->error, PN_ERR, "exit failed");
- break;
- case '?':
- if (!va_arg(ap, int)) {
- err = pn_data_put_null(data);
- if (err) return err;
- pn_data_enter(data);
- }
- break;
- case '*':
- {
- int count = va_arg(ap, int);
- void *ptr = va_arg(ap, void *);
-
- char c = *(fmt++);
-
- switch (c)
- {
- case 's':
- {
- char **sptr = (char **) ptr;
- for (int i = 0; i < count; i++)
- {
- char *sym = *(sptr++);
- err = pn_data_fill(data, "s", sym);
- if (err) return err;
- }
- }
- break;
- default:
- pn_logf("unrecognized * code: 0x%.2X '%c'", code, code);
- return PN_ARG_ERR;
- }
- }
- break;
- case 'C':
- {
- pn_data_t *src = va_arg(ap, pn_data_t *);
- if (src && pn_data_size(src) > 0) {
- err = pn_data_appendn(data, src, 1);
- if (err) return err;
- } else {
- err = pn_data_put_null(data);
- if (err) return err;
- }
- }
- break;
- default:
- pn_logf("unrecognized fill code: 0x%.2X '%c'", code, code);
- return PN_ARG_ERR;
- }
-
- if (err) return err;
-
- pni_node_t *parent = pn_data_node(data, data->parent);
- while (parent) {
- if (parent->atom.type == PN_DESCRIBED && parent->children == 2) {
- pn_data_exit(data);
- parent = pn_data_node(data, data->parent);
- } else if (parent->atom.type == PN_NULL && parent->children == 1) {
- pn_data_exit(data);
- pni_node_t *current = pn_data_node(data, data->current);
- current->down = 0;
- current->children = 0;
- parent = pn_data_node(data, data->parent);
- } else {
- break;
- }
- }
- }
-
- return 0;
-}
-
-
-int pn_data_fill(pn_data_t *data, const char *fmt, ...)
-{
- va_list ap;
- va_start(ap, fmt);
- int err = pn_data_vfill(data, fmt, ap);
- va_end(ap);
- return err;
-}
-
-static bool pn_scan_next(pn_data_t *data, pn_type_t *type, bool suspend)
-{
- if (suspend) return false;
- bool found = pn_data_next(data);
- if (found) {
- *type = pn_data_type(data);
- return true;
- } else {
- pni_node_t *parent = pn_data_node(data, data->parent);
- if (parent && parent->atom.type == PN_DESCRIBED) {
- pn_data_exit(data);
- return pn_scan_next(data, type, suspend);
- } else {
- *type = PN_INVALID;
- return false;
- }
- }
-}
-
-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)
-{
- pn_data_rewind(data);
- bool *scanarg = NULL;
- bool at = false;
- int level = 0;
- int count_level = -1;
- int resume_count = 0;
-
- while (*fmt) {
- char code = *(fmt++);
-
- bool found = false;
- pn_type_t type;
-
- bool scanned = false;
- bool suspend = resume_count > 0;
-
- switch (code) {
- case 'n':
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_NULL) {
- scanned = true;
- } else {
- scanned = false;
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'o':
- {
- bool *value = va_arg(ap, bool *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_BOOL) {
- *value = pn_data_get_bool(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'B':
- {
- uint8_t *value = va_arg(ap, uint8_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_UBYTE) {
- *value = pn_data_get_ubyte(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'b':
- {
- int8_t *value = va_arg(ap, int8_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_BYTE) {
- *value = pn_data_get_byte(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'H':
- {
- uint16_t *value = va_arg(ap, uint16_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_USHORT) {
- *value = pn_data_get_ushort(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'h':
- {
- int16_t *value = va_arg(ap, int16_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_SHORT) {
- *value = pn_data_get_short(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'I':
- {
- uint32_t *value = va_arg(ap, uint32_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_UINT) {
- *value = pn_data_get_uint(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'i':
- {
- int32_t *value = va_arg(ap, int32_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_INT) {
- *value = pn_data_get_int(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'c':
- {
- pn_char_t *value = va_arg(ap, pn_char_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_CHAR) {
- *value = pn_data_get_char(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'L':
- {
- uint64_t *value = va_arg(ap, uint64_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_ULONG) {
- *value = pn_data_get_ulong(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'l':
- {
- int64_t *value = va_arg(ap, int64_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_LONG) {
- *value = pn_data_get_long(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 't':
- {
- pn_timestamp_t *value = va_arg(ap, pn_timestamp_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_TIMESTAMP) {
- *value = pn_data_get_timestamp(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'f':
- {
- float *value = va_arg(ap, float *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_FLOAT) {
- *value = pn_data_get_float(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'd':
- {
- double *value = va_arg(ap, double *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_DOUBLE) {
- *value = pn_data_get_double(data);
- scanned = true;
- } else {
- *value = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'z':
- {
- pn_bytes_t *bytes = va_arg(ap, pn_bytes_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_BINARY) {
- *bytes = pn_data_get_binary(data);
- scanned = true;
- } else {
- bytes->start = 0;
- bytes->size = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'S':
- {
- pn_bytes_t *bytes = va_arg(ap, pn_bytes_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_STRING) {
- *bytes = pn_data_get_string(data);
- scanned = true;
- } else {
- bytes->start = 0;
- bytes->size = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 's':
- {
- pn_bytes_t *bytes = va_arg(ap, pn_bytes_t *);
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_SYMBOL) {
- *bytes = pn_data_get_symbol(data);
- scanned = true;
- } else {
- bytes->start = 0;
- bytes->size = 0;
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case 'D':
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_DESCRIBED) {
- pn_data_enter(data);
- scanned = true;
- } else {
- if (!suspend) {
- resume_count = 3;
- count_level = level;
- }
- scanned = false;
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case '@':
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_ARRAY) {
- pn_data_enter(data);
- scanned = true;
- at = true;
- } else {
- if (!suspend) {
- resume_count = 3;
- count_level = level;
- }
- scanned = false;
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- case '[':
- if (at) {
- scanned = true;
- at = false;
- } else {
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_LIST) {
- pn_data_enter(data);
- scanned = true;
- } else {
- if (!suspend) {
- resume_count = 1;
- count_level = level;
- }
- scanned = false;
- }
- }
- level++;
- break;
- case '{':
- found = pn_scan_next(data, &type, suspend);
- if (found && type == PN_MAP) {
- pn_data_enter(data);
- scanned = true;
- } else {
- if (resume_count) {
- resume_count = 1;
- count_level = level;
- }
- scanned = false;
- }
- level++;
- break;
- case ']':
- case '}':
- level--;
- if (!suspend && !pn_data_exit(data))
- return pn_error_format(data->error, PN_ERR, "exit failed");
- if (resume_count && level == count_level) resume_count--;
- break;
- case '.':
- found = pn_scan_next(data, &type, suspend);
- scanned = found;
- if (resume_count && level == count_level) resume_count--;
- break;
- case '?':
- if (!*fmt || *fmt == '?')
- return pn_error_format(data->error, PN_ARG_ERR, "codes must follow a ?");
- scanarg = va_arg(ap, bool *);
- break;
- case 'C':
- {
- pn_data_t *dst = va_arg(ap, pn_data_t *);
- if (!suspend) {
- size_t old = pn_data_size(dst);
- 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);
- pn_data_widen(data);
- if (err) return err;
- scanned = pn_data_size(dst) > old;
- } else {
- scanned = false;
- }
- pn_data_next(data);
- } else {
- scanned = false;
- }
- }
- if (resume_count && level == count_level) resume_count--;
- break;
- default:
- return pn_error_format(data->error, PN_ARG_ERR, "unrecognized scan code: 0x%.2X '%c'", code, code);
- }
-
- if (scanarg && code != '?') {
- *scanarg = scanned;
- scanarg = NULL;
- }
- }
-
- return 0;
-}
-
-int pn_data_scan(pn_data_t *data, const char *fmt, ...)
-{
- va_list ap;
- va_start(ap, fmt);
- int err = pn_data_vscan(data, fmt, ap);
- va_end(ap);
- return err;
-}
-
-static int pni_data_inspectify(pn_data_t *data)
-{
- int err = pn_string_set(data->str, "");
- if (err) return err;
- return pn_data_inspect(data, data->str);
-}
-
-int pn_data_print(pn_data_t *data)
-{
- int err = pni_data_inspectify(data);
- if (err) return err;
- printf("%s", pn_string_get(data->str));
- return 0;
-}
-
-int pn_data_format(pn_data_t *data, char *bytes, size_t *size)
-{
- int err = pni_data_inspectify(data);
- if (err) return err;
- if (pn_string_size(data->str) >= *size) {
- return PN_OVERFLOW;
- } else {
- pn_string_put(data->str, bytes);
- *size = pn_string_size(data->str);
- return 0;
- }
-}
-
-static size_t pni_data_id(pn_data_t *data, pni_node_t *node)
-{
- return node - data->nodes + 1;
-}
-
-static pni_node_t *pni_data_new(pn_data_t *data)
-{
- if ((data->capacity <= data->size) && (pni_data_grow(data) != 0)) return NULL;
- pni_node_t *node = pn_data_node(data, ++(data->size));
- node->next = 0;
- node->down = 0;
- node->children = 0;
- return node;
-}
-
-void pn_data_rewind(pn_data_t *data)
-{
- data->parent = data->base_parent;
- data->current = data->base_current;
-}
-
-static pni_node_t *pni_data_current(pn_data_t *data)
-{
- return pn_data_node(data, data->current);
-}
-
-void pn_data_narrow(pn_data_t *data)
-{
- data->base_parent = data->parent;
- data->base_current = data->current;
-}
-
-void pn_data_widen(pn_data_t *data)
-{
- data->base_parent = 0;
- data->base_current = 0;
-}
-
-pn_handle_t pn_data_point(pn_data_t *data)
-{
- if (data->current) {
- return (pn_handle_t)(uintptr_t)data->current;
- } else {
- return (pn_handle_t)(uintptr_t)-data->parent;
- }
-}
-
-bool pn_data_restore(pn_data_t *data, pn_handle_t point)
-{
- pn_shandle_t spoint = (pn_shandle_t) point;
- if (spoint <= 0 && ((size_t) (-spoint)) <= data->size) {
- data->parent = -((pn_shandle_t) point);
- data->current = 0;
- return true;
- } else if (spoint && spoint <= data->size) {
- data->current = spoint;
- pni_node_t *current = pni_data_current(data);
- data->parent = current->parent;
- return true;
- } else {
- return false;
- }
-}
-
-static pni_node_t *pni_data_peek(pn_data_t *data)
-{
- pni_node_t *current = pni_data_current(data);
- if (current) {
- return pn_data_node(data, current->next);
- }
-
- pni_node_t *parent = pn_data_node(data, data->parent);
- if (parent) {
- return pn_data_node(data, parent->down);
- }
-
- return NULL;
-}
-
-bool pn_data_next(pn_data_t *data)
-{
- pni_node_t *current = pni_data_current(data);
- pni_node_t *parent = pn_data_node(data, data->parent);
- size_t next;
-
- if (current) {
- next = current->next;
- } else if (parent && parent->down) {
- next = parent->down;
- } else if (!parent && data->size) {
- next = 1;
- } else {
- return false;
- }
-
- if (next) {
- data->current = next;
- return true;
- } else {
- return false;
- }
-}
-
-bool pn_data_prev(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->prev) {
- data->current = node->prev;
- return true;
- } else {
- return false;
- }
-}
-
-int pni_data_traverse(pn_data_t *data,
- int (*enter)(void *ctx, pn_data_t *data, pni_node_t *node),
- int (*exit)(void *ctx, pn_data_t *data, pni_node_t *node),
- void *ctx)
-{
- pni_node_t *node = data->size ? pn_data_node(data, 1) : NULL;
- while (node) {
- pni_node_t *parent = pn_data_node(data, node->parent);
-
- int err = enter(ctx, data, node);
- if (err) return err;
-
- size_t next = 0;
- if (node->down) {
- next = node->down;
- } else if (node->next) {
- err = exit(ctx, data, node);
- if (err) return err;
- next = node->next;
- } else {
- err = exit(ctx, data, node);
- if (err) return err;
- while (parent) {
- err = exit(ctx, data, parent);
- if (err) return err;
- if (parent->next) {
- next = parent->next;
- break;
- } else {
- parent = pn_data_node(data, parent->parent);
- }
- }
- }
-
- node = pn_data_node(data, next);
- }
-
- return 0;
-}
-
-pn_type_t pn_data_type(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node) {
- return node->atom.type;
- } else {
- return PN_INVALID;
- }
-}
-
-pn_type_t pni_data_parent_type(pn_data_t *data)
-{
- pni_node_t *node = pn_data_node(data, data->parent);
- if (node) {
- return node->atom.type;
- } else {
- return PN_INVALID;
- }
-}
-
-size_t pn_data_siblings(pn_data_t *data)
-{
- pni_node_t *node = pn_data_node(data, data->parent);
- if (node) {
- return node->children;
- } else {
- return 0;
- }
-}
-
-bool pn_data_enter(pn_data_t *data)
-{
- if (data->current) {
- data->parent = data->current;
- data->current = 0;
- return true;
- } else {
- return false;
- }
-}
-
-bool pn_data_exit(pn_data_t *data)
-{
- if (data->parent) {
- pni_node_t *parent = pn_data_node(data, data->parent);
- data->current = data->parent;
- data->parent = parent->parent;
- return true;
- } else {
- return false;
- }
-}
-
-bool pn_data_lookup(pn_data_t *data, const char *name)
-{
- while (pn_data_next(data)) {
- pn_type_t type = pn_data_type(data);
-
- switch (type) {
- case PN_STRING:
- case PN_SYMBOL:
- {
- pn_bytes_t bytes = pn_data_get_bytes(data);
- if (strlen(name) == bytes.size && !strncmp(name, bytes.start, bytes.size)) {
- return pn_data_next(data);
- }
- }
- break;
- default:
- break;
- }
-
- // skip the value
- pn_data_next(data);
- }
-
- return false;
-}
-
-void pn_data_dump(pn_data_t *data)
-{
- printf("{current=%" PN_ZI ", parent=%" PN_ZI "}\n", (size_t) data->current, (size_t) data->parent);
- for (unsigned i = 0; i < data->size; i++)
- {
- pni_node_t *node = &data->nodes[i];
- pn_string_set(data->str, "");
- pni_inspect_atom((pn_atom_t *) &node->atom, data->str);
- printf("Node %i: prev=%" PN_ZI ", next=%" PN_ZI ", parent=%" PN_ZI ", down=%" PN_ZI
- ", children=%" PN_ZI ", type=%s (%s)\n",
- i + 1, (size_t) node->prev,
- (size_t) node->next,
- (size_t) node->parent,
- (size_t) node->down,
- (size_t) node->children,
- pn_type_name(node->atom.type), pn_string_get(data->str));
- }
-}
-
-static pni_node_t *pni_data_add(pn_data_t *data)
-{
- pni_node_t *current = pni_data_current(data);
- pni_node_t *parent = pn_data_node(data, data->parent);
- pni_node_t *node;
-
- if (current) {
- if (current->next) {
- node = pn_data_node(data, current->next);
- } else {
- node = pni_data_new(data);
- if (!node) return NULL;
-
- // refresh the pointers in case we grew
- current = pni_data_current(data);
- parent = pn_data_node(data, data->parent);
- node->prev = data->current;
- current->next = pni_data_id(data, node);
- node->parent = data->parent;
- if (parent) {
- if (!parent->down) {
- parent->down = pni_data_id(data, node);
- }
- parent->children++;
- }
- }
- } else if (parent) {
- if (parent->down) {
- node = pn_data_node(data, parent->down);
- } else {
- node = pni_data_new(data);
- if (!node) return NULL;
-
- // refresh the pointers in case we grew
- parent = pn_data_node(data, data->parent);
- node->prev = 0;
- node->parent = data->parent;
- parent->down = pni_data_id(data, node);
- parent->children++;
- }
- } else if (data->size) {
- node = pn_data_node(data, 1);
- } else {
- node = pni_data_new(data);
- if (!node) return NULL;
-
- node->prev = 0;
- node->parent = 0;
- }
-
- node->down = 0;
- node->children = 0;
- node->data = false;
- node->data_offset = 0;
- node->data_size = 0;
- data->current = pni_data_id(data, node);
- return node;
-}
-
-ssize_t pn_data_encode(pn_data_t *data, char *bytes, size_t size)
-{
- return pn_encoder_encode(data->encoder, data, bytes, size);
-}
-
-ssize_t pn_data_encoded_size(pn_data_t *data)
-{
- return pn_encoder_size(data->encoder, data);
-}
-
-ssize_t pn_data_decode(pn_data_t *data, const char *bytes, size_t size)
-{
- return pn_decoder_decode(data->decoder, bytes, size, data);
-}
-
-int pn_data_put_list(pn_data_t *data)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_LIST;
- return 0;
-}
-
-int pn_data_put_map(pn_data_t *data)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- 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 = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_ARRAY;
- node->described = described;
- node->type = type;
- return 0;
-}
-
-void pni_data_set_array_type(pn_data_t *data, pn_type_t type)
-{
- 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 = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_DESCRIBED;
- return 0;
-}
-
-int pn_data_put_null(pn_data_t *data)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- pni_atom_init(&node->atom, PN_NULL);
- return 0;
-}
-
-int pn_data_put_bool(pn_data_t *data, bool b)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_BOOL;
- node->atom.u.as_bool = b;
- return 0;
-}
-
-int pn_data_put_ubyte(pn_data_t *data, uint8_t ub)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_UBYTE;
- node->atom.u.as_ubyte = ub;
- return 0;
-}
-
-int pn_data_put_byte(pn_data_t *data, int8_t b)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_BYTE;
- node->atom.u.as_byte = b;
- return 0;
-}
-
-int pn_data_put_ushort(pn_data_t *data, uint16_t us)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_USHORT;
- node->atom.u.as_ushort = us;
- return 0;
-}
-
-int pn_data_put_short(pn_data_t *data, int16_t s)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_SHORT;
- node->atom.u.as_short = s;
- return 0;
-}
-
-int pn_data_put_uint(pn_data_t *data, uint32_t ui)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_UINT;
- node->atom.u.as_uint = ui;
- return 0;
-}
-
-int pn_data_put_int(pn_data_t *data, int32_t i)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_INT;
- node->atom.u.as_int = i;
- return 0;
-}
-
-int pn_data_put_char(pn_data_t *data, pn_char_t c)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_CHAR;
- node->atom.u.as_char = c;
- return 0;
-}
-
-int pn_data_put_ulong(pn_data_t *data, uint64_t ul)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_ULONG;
- node->atom.u.as_ulong = ul;
- return 0;
-}
-
-int pn_data_put_long(pn_data_t *data, int64_t l)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_LONG;
- node->atom.u.as_long = l;
- return 0;
-}
-
-int pn_data_put_timestamp(pn_data_t *data, pn_timestamp_t t)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_TIMESTAMP;
- node->atom.u.as_timestamp = t;
- return 0;
-}
-
-int pn_data_put_float(pn_data_t *data, float f)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_FLOAT;
- node->atom.u.as_float = f;
- return 0;
-}
-
-int pn_data_put_double(pn_data_t *data, double d)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_DOUBLE;
- node->atom.u.as_double = d;
- return 0;
-}
-
-int pn_data_put_decimal32(pn_data_t *data, pn_decimal32_t d)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_DECIMAL32;
- node->atom.u.as_decimal32 = d;
- return 0;
-}
-
-int pn_data_put_decimal64(pn_data_t *data, pn_decimal64_t d)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_DECIMAL64;
- node->atom.u.as_decimal64 = d;
- return 0;
-}
-
-int pn_data_put_decimal128(pn_data_t *data, pn_decimal128_t d)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_DECIMAL128;
- memmove(node->atom.u.as_decimal128.bytes, d.bytes, 16);
- return 0;
-}
-
-int pn_data_put_uuid(pn_data_t *data, pn_uuid_t u)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_UUID;
- memmove(node->atom.u.as_uuid.bytes, u.bytes, 16);
- return 0;
-}
-
-int pn_data_put_binary(pn_data_t *data, pn_bytes_t bytes)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_BINARY;
- node->atom.u.as_bytes = bytes;
- return pni_data_intern_node(data, node);
-}
-
-int pn_data_put_string(pn_data_t *data, pn_bytes_t string)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_STRING;
- node->atom.u.as_bytes = string;
- return pni_data_intern_node(data, node);
-}
-
-int pn_data_put_symbol(pn_data_t *data, pn_bytes_t symbol)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom.type = PN_SYMBOL;
- node->atom.u.as_bytes = symbol;
- return pni_data_intern_node(data, node);
-}
-
-int pn_data_put_atom(pn_data_t *data, pn_atom_t atom)
-{
- pni_node_t *node = pni_data_add(data);
- if (node == NULL) return PN_OUT_OF_MEMORY;
- node->atom = atom;
- return pni_data_intern_node(data, node);
-}
-
-size_t pn_data_get_list(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_LIST) {
- return node->children;
- } else {
- return 0;
- }
-}
-
-size_t pn_data_get_map(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_MAP) {
- return node->children;
- } else {
- return 0;
- }
-}
-
-size_t pn_data_get_array(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_ARRAY) {
- if (node->described) {
- return node->children - 1;
- } else {
- return node->children;
- }
- } else {
- return 0;
- }
-}
-
-bool pn_data_is_array_described(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_ARRAY) {
- return node->described;
- } else {
- return false;
- }
-}
-
-pn_type_t pn_data_get_array_type(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_ARRAY) {
- return node->type;
- } else {
- return PN_INVALID;
- }
-}
-
-bool pn_data_is_described(pn_data_t *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 = pni_data_current(data);
- return node && node->atom.type == PN_NULL;
-}
-
-bool pn_data_get_bool(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_BOOL) {
- return node->atom.u.as_bool;
- } else {
- return false;
- }
-}
-
-uint8_t pn_data_get_ubyte(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_UBYTE) {
- return node->atom.u.as_ubyte;
- } else {
- return 0;
- }
-}
-
-int8_t pn_data_get_byte(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_BYTE) {
- return node->atom.u.as_byte;
- } else {
- return 0;
- }
-}
-
-uint16_t pn_data_get_ushort(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_USHORT) {
- return node->atom.u.as_ushort;
- } else {
- return 0;
- }
-}
-
-int16_t pn_data_get_short(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_SHORT) {
- return node->atom.u.as_short;
- } else {
- return 0;
- }
-}
-
-uint32_t pn_data_get_uint(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_UINT) {
- return node->atom.u.as_uint;
- } else {
- return 0;
- }
-}
-
-int32_t pn_data_get_int(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_INT) {
- return node->atom.u.as_int;
- } else {
- return 0;
- }
-}
-
-pn_char_t pn_data_get_char(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_CHAR) {
- return node->atom.u.as_char;
- } else {
- return 0;
- }
-}
-
-uint64_t pn_data_get_ulong(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_ULONG) {
- return node->atom.u.as_ulong;
- } else {
- return 0;
- }
-}
-
-int64_t pn_data_get_long(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_LONG) {
- return node->atom.u.as_long;
- } else {
- return 0;
- }
-}
-
-pn_timestamp_t pn_data_get_timestamp(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_TIMESTAMP) {
- return node->atom.u.as_timestamp;
- } else {
- return 0;
- }
-}
-
-float pn_data_get_float(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_FLOAT) {
- return node->atom.u.as_float;
- } else {
- return 0;
- }
-}
-
-double pn_data_get_double(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_DOUBLE) {
- return node->atom.u.as_double;
- } else {
- return 0;
- }
-}
-
-pn_decimal32_t pn_data_get_decimal32(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_DECIMAL32) {
- return node->atom.u.as_decimal32;
- } else {
- return 0;
- }
-}
-
-pn_decimal64_t pn_data_get_decimal64(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_DECIMAL64) {
- return node->atom.u.as_decimal64;
- } else {
- return 0;
- }
-}
-
-pn_decimal128_t pn_data_get_decimal128(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_DECIMAL128) {
- return node->atom.u.as_decimal128;
- } else {
- pn_decimal128_t t = {{0}};
- return t;
- }
-}
-
-pn_uuid_t pn_data_get_uuid(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_UUID) {
- return node->atom.u.as_uuid;
- } else {
- pn_uuid_t t = {{0}};
- return t;
- }
-}
-
-pn_bytes_t pn_data_get_binary(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_BINARY) {
- return node->atom.u.as_bytes;
- } else {
- pn_bytes_t t = {0};
- return t;
- }
-}
-
-pn_bytes_t pn_data_get_string(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_STRING) {
- return node->atom.u.as_bytes;
- } else {
- pn_bytes_t t = {0};
- return t;
- }
-}
-
-pn_bytes_t pn_data_get_symbol(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node && node->atom.type == PN_SYMBOL) {
- return node->atom.u.as_bytes;
- } else {
- pn_bytes_t t = {0};
- return t;
- }
-}
-
-pn_bytes_t pn_data_get_bytes(pn_data_t *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)) {
- return node->atom.u.as_bytes;
- } else {
- pn_bytes_t t = {0};
- return t;
- }
-}
-
-pn_atom_t pn_data_get_atom(pn_data_t *data)
-{
- pni_node_t *node = pni_data_current(data);
- if (node) {
- return *((pn_atom_t *) &node->atom);
- } else {
- pn_atom_t t = {PN_NULL, {0,}};
- return t;
- }
-}
-
-int pn_data_copy(pn_data_t *data, pn_data_t *src)
-{
- pn_data_clear(data);
- int err = pn_data_append(data, src);
- pn_data_rewind(data);
- return err;
-}
-
-int pn_data_append(pn_data_t *data, pn_data_t *src)
-{
- return pn_data_appendn(data, src, -1);
-}
-
-int pn_data_appendn(pn_data_t *data, pn_data_t *src, int limit)
-{
- int err = 0;
- int level = 0, count = 0;
- bool stop = false;
- pn_handle_t point = pn_data_point(src);
- pn_data_rewind(src);
-
- while (true) {
- while (!pn_data_next(src)) {
- if (level > 0) {
- pn_data_exit(data);
- pn_data_exit(src);
- level--;
- continue;
- }
-
- if (!pn_data_next(src)) {
- stop = true;
- }
- break;
- }
-
- if (stop) break;
-
- if (level == 0 && count == limit)
- break;
-
- pn_type_t type = pn_data_type(src);
- switch (type) {
- case PN_NULL:
- err = pn_data_put_null(data);
- if (level == 0) count++;
- break;
- case PN_BOOL:
- err = pn_data_put_bool(data, pn_data_get_bool(src));
- if (level == 0) count++;
- break;
- case PN_UBYTE:
- err = pn_data_put_ubyte(data, pn_data_get_ubyte(src));
- if (level == 0) count++;
- break;
- case PN_BYTE:
- err = pn_data_put_byte(data, pn_data_get_byte(src));
- if (level == 0) count++;
- break;
- case PN_USHORT:
- err = pn_data_put_ushort(data, pn_data_get_ushort(src));
- if (level == 0) count++;
- break;
- case PN_SHORT:
- err = pn_data_put_short(data, pn_data_get_short(src));
- if (level == 0) count++;
- break;
- case PN_UINT:
- err = pn_data_put_uint(data, pn_data_get_uint(src));
- if (level == 0) count++;
- break;
- case PN_INT:
- err = pn_data_put_int(data, pn_data_get_int(src));
- if (level == 0) count++;
- break;
- case PN_CHAR:
- err = pn_data_put_char(data, pn_data_get_char(src));
- if (level == 0) count++;
- break;
- case PN_ULONG:
- err = pn_data_put_ulong(data, pn_data_get_ulong(src));
- if (level == 0) count++;
- break;
- case PN_LONG:
- err = pn_data_put_long(data, pn_data_get_long(src));
- if (level == 0) count++;
- break;
- case PN_TIMESTAMP:
- err = pn_data_put_timestamp(data, pn_data_get_timestamp(src));
- if (level == 0) count++;
- break;
- case PN_FLOAT:
- err = pn_data_put_float(data, pn_data_get_float(src));
- if (level == 0) count++;
- break;
- case PN_DOUBLE:
- err = pn_data_put_double(data, pn_data_get_double(src));
- if (level == 0) count++;
- break;
- case PN_DECIMAL32:
- err = pn_data_put_decimal32(data, pn_data_get_decimal32(src));
- if (level == 0) count++;
- break;
- case PN_DECIMAL64:
- err = pn_data_put_decimal64(data, pn_data_get_decimal64(src));
- if (level == 0) count++;
- break;
- case PN_DECIMAL128:
- err = pn_data_put_decimal128(data, pn_data_get_decimal128(src));
- if (level == 0) count++;
- break;
- case PN_UUID:
- err = pn_data_put_uuid(data, pn_data_get_uuid(src));
- if (level == 0) count++;
- break;
- case PN_BINARY:
- err = pn_data_put_binary(data, pn_data_get_binary(src));
- if (level == 0) count++;
- break;
- case PN_STRING:
- err = pn_data_put_string(data, pn_data_get_string(src));
- if (level == 0) count++;
- break;
- case PN_SYMBOL:
- err = pn_data_put_symbol(data, pn_data_get_symbol(src));
- if (level == 0) count++;
- break;
- case PN_DESCRIBED:
- err = pn_data_put_described(data);
- if (level == 0) count++;
- if (err) { pn_data_restore(src, point); return err; }
- pn_data_enter(data);
- pn_data_enter(src);
- level++;
- break;
- case PN_ARRAY:
- err = pn_data_put_array(data, pn_data_is_array_described(src),
- pn_data_get_array_type(src));
- if (level == 0) count++;
- if (err) { pn_data_restore(src, point); return err; }
- pn_data_enter(data);
- pn_data_enter(src);
- level++;
- break;
- case PN_LIST:
- err = pn_data_put_list(data);
- if (level == 0) count++;
- if (err) { pn_data_restore(src, point); return err; }
- pn_data_enter(data);
- pn_data_enter(src);
- level++;
- break;
- case PN_MAP:
- err = pn_data_put_map(data);
- if (level == 0) count++;
- if (err) { pn_data_restore(src, point); return err; }
- pn_data_enter(data);
- pn_data_enter(src);
- level++;
- break;
- default:
- break;
- }
-
- if (err) { pn_data_restore(src, point); return err; }
- }
-
- pn_data_restore(src, point);
-
- return 0;
-}
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/a5850716/proton-c/src/codec/data.h
----------------------------------------------------------------------
diff --git a/proton-c/src/codec/data.h b/proton-c/src/codec/data.h
deleted file mode 100644
index 94dc7d6..0000000
--- a/proton-c/src/codec/data.h
+++ /dev/null
@@ -1,75 +0,0 @@
-#ifndef _PROTON_DATA_H
-#define _PROTON_DATA_H 1
-
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
- */
-
-#include <proton/codec.h>
-#include "buffer.h"
-#include "decoder.h"
-#include "encoder.h"
-
-typedef uint16_t pni_nid_t;
-#define PNI_NID_MAX ((pni_nid_t)-1)
-
-typedef struct {
- char *start;
- size_t data_offset;
- size_t data_size;
- pn_atom_t atom;
- pn_type_t type;
- pni_nid_t next;
- pni_nid_t prev;
- pni_nid_t down;
- pni_nid_t parent;
- pni_nid_t children;
- // for arrays
- bool described;
- bool data;
- bool small;
-} pni_node_t;
-
-struct pn_data_t {
- pni_node_t *nodes;
- pn_buffer_t *buf;
- pn_decoder_t *decoder;
- pn_encoder_t *encoder;
- pn_error_t *error;
- pn_string_t *str;
- pni_nid_t capacity;
- pni_nid_t size;
- pni_nid_t parent;
- pni_nid_t current;
- pni_nid_t base_parent;
- pni_nid_t base_current;
-};
-
-static inline pni_node_t * pn_data_node(pn_data_t *data, pni_nid_t nd)
-{
- return nd ? (data->nodes + nd - 1) : NULL;
-}
-
-int pni_data_traverse(pn_data_t *data,
- int (*enter)(void *ctx, pn_data_t *data, pni_node_t *node),
- int (*exit)(void *ctx, pn_data_t *data, pni_node_t *node),
- void *ctx);
-
-#endif /* data.h */
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/a5850716/proton-c/src/codec/decoder.c
----------------------------------------------------------------------
diff --git a/proton-c/src/codec/decoder.c b/proton-c/src/codec/decoder.c
deleted file mode 100644
index b0c8d79..0000000
--- a/proton-c/src/codec/decoder.c
+++ /dev/null
@@ -1,497 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
- */
-
-#include <proton/error.h>
-#include <proton/object.h>
-#include <proton/codec.h>
-#include "encodings.h"
-#include "decoder.h"
-
-#include <string.h>
-
-struct pn_decoder_t {
- const char *input;
- size_t size;
- const char *position;
- pn_error_t *error;
-};
-
-static void pn_decoder_initialize(void *obj)
-{
- pn_decoder_t *decoder = (pn_decoder_t *) obj;
- decoder->input = NULL;
- decoder->size = 0;
- decoder->position = NULL;
- decoder->error = pn_error();
-}
-
-static void pn_decoder_finalize(void *obj) {
- pn_decoder_t *decoder = (pn_decoder_t *) obj;
- pn_error_free(decoder->error);
-}
-
-#define pn_decoder_hashcode NULL
-#define pn_decoder_compare NULL
-#define pn_decoder_inspect NULL
-
-pn_decoder_t *pn_decoder()
-{
- static const pn_class_t clazz = PN_CLASS(pn_decoder);
- return (pn_decoder_t *) pn_class_new(&clazz, sizeof(pn_decoder_t));
-}
-
-static inline uint8_t pn_decoder_readf8(pn_decoder_t *decoder)
-{
- uint8_t r = decoder->position[0];
- decoder->position++;
- return r;
-}
-
-static inline uint16_t pn_decoder_readf16(pn_decoder_t *decoder)
-{
- uint16_t a = (uint8_t) decoder->position[0];
- uint16_t b = (uint8_t) decoder->position[1];
- uint16_t r = a << 8
- | b;
- decoder->position += 2;
- return r;
-}
-
-static inline uint32_t pn_decoder_readf32(pn_decoder_t *decoder)
-{
- uint32_t a = (uint8_t) decoder->position[0];
- uint32_t b = (uint8_t) decoder->position[1];
- uint32_t c = (uint8_t) decoder->position[2];
- uint32_t d = (uint8_t) decoder->position[3];
- uint32_t r = a << 24
- | b << 16
- | c << 8
- | d;
- decoder->position += 4;
- return r;
-}
-
-static inline uint64_t pn_decoder_readf64(pn_decoder_t *decoder)
-{
- uint64_t a = pn_decoder_readf32(decoder);
- uint64_t b = pn_decoder_readf32(decoder);
- return a << 32 | b;
-}
-
-static inline void pn_decoder_readf128(pn_decoder_t *decoder, void *dst)
-{
- memmove(dst, decoder->position, 16);
- decoder->position += 16;
-}
-
-static inline size_t pn_decoder_remaining(pn_decoder_t *decoder)
-{
- return decoder->input + decoder->size - decoder->position;
-}
-
-typedef union {
- uint32_t i;
- uint32_t a[2];
- uint64_t l;
- float f;
- double d;
-} conv_t;
-
-static inline pn_type_t pn_code2type(uint8_t code)
-{
- switch (code)
- {
- case PNE_DESCRIPTOR:
- return (pn_type_t) PN_ARG_ERR;
- case PNE_NULL:
- return PN_NULL;
- case PNE_TRUE:
- case PNE_FALSE:
- case PNE_BOOLEAN:
- return PN_BOOL;
- case PNE_UBYTE:
- return PN_UBYTE;
- case PNE_BYTE:
- return PN_BYTE;
- case PNE_USHORT:
- return PN_USHORT;
- case PNE_SHORT:
- return PN_SHORT;
- case PNE_UINT0:
- case PNE_SMALLUINT:
- case PNE_UINT:
- return PN_UINT;
- case PNE_SMALLINT:
- case PNE_INT:
- return PN_INT;
- case PNE_UTF32:
- return PN_CHAR;
- case PNE_FLOAT:
- return PN_FLOAT;
- case PNE_LONG:
- case PNE_SMALLLONG:
- return PN_LONG;
- case PNE_MS64:
- return PN_TIMESTAMP;
- case PNE_DOUBLE:
- return PN_DOUBLE;
- case PNE_DECIMAL32:
- return PN_DECIMAL32;
- case PNE_DECIMAL64:
- return PN_DECIMAL64;
- case PNE_DECIMAL128:
- return PN_DECIMAL128;
- case PNE_UUID:
- return PN_UUID;
- case PNE_ULONG0:
- case PNE_SMALLULONG:
- case PNE_ULONG:
- return PN_ULONG;
- case PNE_VBIN8:
- case PNE_VBIN32:
- return PN_BINARY;
- case PNE_STR8_UTF8:
- case PNE_STR32_UTF8:
- return PN_STRING;
- case PNE_SYM8:
- case PNE_SYM32:
- return PN_SYMBOL;
- case PNE_LIST0:
- case PNE_LIST8:
- case PNE_LIST32:
- return PN_LIST;
- case PNE_ARRAY8:
- case PNE_ARRAY32:
- return PN_ARRAY;
- case PNE_MAP8:
- case PNE_MAP32:
- return PN_MAP;
- default:
- return (pn_type_t) PN_ARG_ERR;
- }
-}
-
-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);
-
-static int pni_decoder_decode_value(pn_decoder_t *decoder, pn_data_t *data, uint8_t code)
-{
- int err;
- conv_t conv;
- pn_decimal128_t dec128;
- pn_uuid_t uuid;
- size_t size;
- size_t count;
-
- switch (code)
- {
- case PNE_NULL:
- err = pn_data_put_null(data);
- break;
- case PNE_TRUE:
- err = pn_data_put_bool(data, true);
- break;
- case PNE_FALSE:
- err = pn_data_put_bool(data, false);
- break;
- case PNE_BOOLEAN:
- if (!pn_decoder_remaining(decoder)) return PN_UNDERFLOW;
- err = pn_data_put_bool(data, pn_decoder_readf8(decoder) != 0);
- break;
- case PNE_UBYTE:
- if (!pn_decoder_remaining(decoder)) return PN_UNDERFLOW;
- err = pn_data_put_ubyte(data, pn_decoder_readf8(decoder));
- break;
- case PNE_BYTE:
- if (!pn_decoder_remaining(decoder)) return PN_UNDERFLOW;
- err = pn_data_put_byte(data, pn_decoder_readf8(decoder));
- break;
- case PNE_USHORT:
- if (pn_decoder_remaining(decoder) < 2) return PN_UNDERFLOW;
- err = pn_data_put_ushort(data, pn_decoder_readf16(decoder));
- break;
- case PNE_SHORT:
- if (pn_decoder_remaining(decoder) < 2) return PN_UNDERFLOW;
- err = pn_data_put_short(data, pn_decoder_readf16(decoder));
- break;
- case PNE_UINT:
- if (pn_decoder_remaining(decoder) < 4) return PN_UNDERFLOW;
- err = pn_data_put_uint(data, pn_decoder_readf32(decoder));
- break;
- case PNE_UINT0:
- err = pn_data_put_uint(data, 0);
- break;
- case PNE_SMALLUINT:
- if (!pn_decoder_remaining(decoder)) return PN_UNDERFLOW;
- err = pn_data_put_uint(data, pn_decoder_readf8(decoder));
- break;
- case PNE_SMALLINT:
- if (!pn_decoder_remaining(decoder)) return PN_UNDERFLOW;
- err = pn_data_put_int(data, (int8_t)pn_decoder_readf8(decoder));
- break;
- case PNE_INT:
- if (pn_decoder_remaining(decoder) < 4) return PN_UNDERFLOW;
- err = pn_data_put_int(data, pn_decoder_readf32(decoder));
- break;
- case PNE_UTF32:
- if (pn_decoder_remaining(decoder) < 4) return PN_UNDERFLOW;
- err = pn_data_put_char(data, pn_decoder_readf32(decoder));
- break;
- case PNE_FLOAT:
- if (pn_decoder_remaining(decoder) < 4) return PN_UNDERFLOW;
- // XXX: this assumes the platform uses IEEE floats
- conv.i = pn_decoder_readf32(decoder);
- err = pn_data_put_float(data, conv.f);
- break;
- case PNE_DECIMAL32:
- if (pn_decoder_remaining(decoder) < 4) return PN_UNDERFLOW;
- err = pn_data_put_decimal32(data, pn_decoder_readf32(decoder));
- break;
- case PNE_ULONG:
- if (pn_decoder_remaining(decoder) < 8) return PN_UNDERFLOW;
- err = pn_data_put_ulong(data, pn_decoder_readf64(decoder));
- break;
- case PNE_LONG:
- if (pn_decoder_remaining(decoder) < 8) return PN_UNDERFLOW;
- err = pn_data_put_long(data, pn_decoder_readf64(decoder));
- break;
- case PNE_MS64:
- if (pn_decoder_remaining(decoder) < 8) return PN_UNDERFLOW;
- err = pn_data_put_timestamp(data, pn_decoder_readf64(decoder));
- break;
- case PNE_DOUBLE:
- // XXX: this assumes the platform uses IEEE floats
- if (pn_decoder_remaining(decoder) < 8) return PN_UNDERFLOW;
- conv.l = pn_decoder_readf64(decoder);
- err = pn_data_put_double(data, conv.d);
- break;
- case PNE_DECIMAL64:
- if (pn_decoder_remaining(decoder) < 8) return PN_UNDERFLOW;
- err = pn_data_put_decimal64(data, pn_decoder_readf64(decoder));
- break;
- case PNE_ULONG0:
- err = pn_data_put_ulong(data, 0);
- break;
- case PNE_SMALLULONG:
- if (!pn_decoder_remaining(decoder)) return PN_UNDERFLOW;
- err = pn_data_put_ulong(data, pn_decoder_readf8(decoder));
- break;
- case PNE_SMALLLONG:
- if (!pn_decoder_remaining(decoder)) return PN_UNDERFLOW;
- err = pn_data_put_long(data, (int8_t)pn_decoder_readf8(decoder));
- break;
- case PNE_DECIMAL128:
- if (pn_decoder_remaining(decoder) < 16) return PN_UNDERFLOW;
- pn_decoder_readf128(decoder, &dec128);
- err = pn_data_put_decimal128(data, dec128);
- break;
- case PNE_UUID:
- if (pn_decoder_remaining(decoder) < 16) return PN_UNDERFLOW;
- pn_decoder_readf128(decoder, &uuid);
- err = pn_data_put_uuid(data, uuid);
- break;
- case PNE_VBIN8:
- case PNE_STR8_UTF8:
- case PNE_SYM8:
- case PNE_VBIN32:
- case PNE_STR32_UTF8:
- case PNE_SYM32:
- switch (code & 0xF0)
- {
- case 0xA0:
- if (!pn_decoder_remaining(decoder)) return PN_UNDERFLOW;
- size = pn_decoder_readf8(decoder);
- break;
- case 0xB0:
- if (pn_decoder_remaining(decoder) < 4) return PN_UNDERFLOW;
- size = pn_decoder_readf32(decoder);
- break;
- default:
- return PN_ARG_ERR;
- }
-
- if (pn_decoder_remaining(decoder) < size) return PN_UNDERFLOW;
-
- {
- char *start = (char *) decoder->position;
- pn_bytes_t bytes = {size, start};
- switch (code & 0x0F)
- {
- case 0x0:
- err = pn_data_put_binary(data, bytes);
- break;
- case 0x1:
- err = pn_data_put_string(data, bytes);
- break;
- case 0x3:
- err = pn_data_put_symbol(data, bytes);
- break;
- default:
- return PN_ARG_ERR;
- }
- }
-
- decoder->position += size;
- break;
- case PNE_LIST0:
- err = pn_data_put_list(data);
- break;
- case PNE_ARRAY8:
- case PNE_ARRAY32:
- case PNE_LIST8:
- case PNE_LIST32:
- case PNE_MAP8:
- case PNE_MAP32:
- switch (code)
- {
- case PNE_ARRAY8:
- case PNE_LIST8:
- case PNE_MAP8:
- if (pn_decoder_remaining(decoder) < 2) return PN_UNDERFLOW;
- size = pn_decoder_readf8(decoder);
- count = pn_decoder_readf8(decoder);
- break;
- case PNE_ARRAY32:
- case PNE_LIST32:
- case PNE_MAP32:
- size = pn_decoder_readf32(decoder);
- count = pn_decoder_readf32(decoder);
- break;
- default:
- return PN_ARG_ERR;
- }
-
- switch (code)
- {
- case PNE_ARRAY8:
- case PNE_ARRAY32:
- {
- uint8_t next = *decoder->position;
- bool described = (next == PNE_DESCRIPTOR);
- err = pn_data_put_array(data, described, (pn_type_t) 0);
- if (err) return err;
-
- pn_data_enter(data);
- uint8_t 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 = pni_decoder_decode_value(decoder, data, acode);
- if (e) return e;
- }
- pn_data_exit(data);
-
- pni_data_set_array_type(data, type);
- }
- return 0;
- case PNE_LIST8:
- case PNE_LIST32:
- err = pn_data_put_list(data);
- if (err) return err;
- break;
- case PNE_MAP8:
- case PNE_MAP32:
- err = pn_data_put_map(data);
- if (err) return err;
- break;
- default:
- return PN_ARG_ERR;
- }
-
- pn_data_enter(data);
- for (size_t i = 0; i < count; i++)
- {
- int e = pni_decoder_single(decoder, data);
- if (e) return e;
- }
- pn_data_exit(data);
-
- return 0;
- default:
- return pn_error_format(decoder->error, PN_ARG_ERR, "unrecognized typecode: %u", code);
- }
-
- return err;
-}
-
-pn_type_t pni_data_parent_type(pn_data_t *data);
-
-static int pni_decoder_decode_type(pn_decoder_t *decoder, pn_data_t *data, uint8_t *code)
-{
- int err;
-
- if (!pn_decoder_remaining(decoder)) {
- return PN_UNDERFLOW;
- }
-
- uint8_t next = *decoder->position++;
-
- if (next == PNE_DESCRIPTOR) {
- if (pni_data_parent_type(data) != PN_ARRAY) {
- err = pn_data_put_described(data);
- if (err) return err;
- // pni_decoder_single has the corresponding exit
- pn_data_enter(data);
- }
- err = pni_decoder_single(decoder, data);
- if (err) return err;
- err = pni_decoder_decode_type(decoder, data, code);
- if (err) return err;
- } else {
- *code = next;
- }
-
- return 0;
-}
-
-size_t pn_data_siblings(pn_data_t *data);
-
-int pni_decoder_single(pn_decoder_t *decoder, pn_data_t *data)
-{
- uint8_t code;
- int err = pni_decoder_decode_type(decoder, data, &code);
- if (err) return err;
- 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);
- }
- return 0;
-}
-
-ssize_t pn_decoder_decode(pn_decoder_t *decoder, const char *src, size_t size, pn_data_t *dst)
-{
- decoder->input = src;
- decoder->size = size;
- decoder->position = src;
-
- 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");
- if (err) return err;
-
- return decoder->position - decoder->input;
-}
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/a5850716/proton-c/src/codec/decoder.h
----------------------------------------------------------------------
diff --git a/proton-c/src/codec/decoder.h b/proton-c/src/codec/decoder.h
deleted file mode 100644
index b7de898..0000000
--- a/proton-c/src/codec/decoder.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef _PROTON_DECODER_H
-#define _PROTON_DECODER_H 1
-
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
- */
-
-typedef struct pn_decoder_t pn_decoder_t;
-
-pn_decoder_t *pn_decoder(void);
-ssize_t pn_decoder_decode(pn_decoder_t *decoder, const char *src, size_t size, pn_data_t *dst);
-
-#endif /* decoder.h */
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org