You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by mg...@apache.org on 2015/06/08 16:08:13 UTC
[1/2] qpid-proton git commit: PROTON-896: declare functions static
that are only referred to in one file,
and change their names to have pni_ prefix.
Repository: qpid-proton
Updated Branches:
refs/heads/master 5a6c8da65 -> d921c6bc8
http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/d921c6bc/proton-c/src/transport/transport.c
----------------------------------------------------------------------
diff --git a/proton-c/src/transport/transport.c b/proton-c/src/transport/transport.c
index e72875b..b5887ef 100644
--- a/proton-c/src/transport/transport.c
+++ b/proton-c/src/transport/transport.c
@@ -54,7 +54,7 @@ void pn_delivery_map_free(pn_delivery_map_t *db)
pn_free(db->deliveries);
}
-pn_delivery_t *pn_delivery_map_get(pn_delivery_map_t *db, pn_sequence_t id)
+static pn_delivery_t *pni_delivery_map_get(pn_delivery_map_t *db, pn_sequence_t id)
{
return (pn_delivery_t *) pn_hash_get(db->deliveries, id);
}
@@ -66,7 +66,7 @@ static void pn_delivery_state_init(pn_delivery_state_t *ds, pn_delivery_t *deliv
ds->init = true;
}
-pn_delivery_state_t *pn_delivery_map_push(pn_delivery_map_t *db, pn_delivery_t *delivery)
+static pn_delivery_state_t *pni_delivery_map_push(pn_delivery_map_t *db, pn_delivery_t *delivery)
{
pn_delivery_state_t *ds = &delivery->state;
pn_delivery_state_init(ds, delivery, db->next++);
@@ -83,7 +83,7 @@ void pn_delivery_map_del(pn_delivery_map_t *db, pn_delivery_t *delivery)
}
}
-void pn_delivery_map_clear(pn_delivery_map_t *dm)
+static void pni_delivery_map_clear(pn_delivery_map_t *dm)
{
pn_hash_t *hash = dm->deliveries;
for (pn_handle_t entry = pn_hash_head(hash);
@@ -405,7 +405,7 @@ static void pn_transport_initialize(void *object)
}
-pn_session_t *pn_channel_state(pn_transport_t *transport, uint16_t channel)
+static pn_session_t *pni_channel_state(pn_transport_t *transport, uint16_t channel)
{
return (pn_session_t *) pn_hash_get(transport->remote_channels, channel);
}
@@ -423,7 +423,7 @@ void pni_transport_unbind_handles(pn_hash_t *handles, bool reset_state);
static void pni_unmap_remote_channel(pn_session_t *ssn)
{
// XXX: should really update link state also
- pn_delivery_map_clear(&ssn->state.incoming);
+ pni_delivery_map_clear(&ssn->state.incoming);
pni_transport_unbind_handles(ssn->state.remote_handles, false);
pn_transport_t *transport = ssn->connection->transport;
uint16_t channel = ssn->state.remote_channel;
@@ -637,8 +637,8 @@ void pni_transport_unbind_channels(pn_hash_t *channels)
for (pn_handle_t h = pn_hash_head(channels); h; h = pn_hash_next(channels, h)) {
uintptr_t key = pn_hash_key(channels, h);
pn_session_t *ssn = (pn_session_t *) pn_hash_value(channels, h);
- pn_delivery_map_clear(&ssn->state.incoming);
- pn_delivery_map_clear(&ssn->state.outgoing);
+ pni_delivery_map_clear(&ssn->state.incoming);
+ pni_delivery_map_clear(&ssn->state.outgoing);
pni_transport_unbind_handles(ssn->state.local_handles, true);
pni_transport_unbind_handles(ssn->state.remote_handles, true);
pn_session_unbound(ssn);
@@ -662,8 +662,8 @@ int pn_transport_unbind(pn_transport_t *transport)
// XXX: what happens if the endpoints are freed before we get here?
pn_session_t *ssn = pn_session_head(conn, 0);
while (ssn) {
- pn_delivery_map_clear(&ssn->state.incoming);
- pn_delivery_map_clear(&ssn->state.outgoing);
+ pni_delivery_map_clear(&ssn->state.incoming);
+ pni_delivery_map_clear(&ssn->state.outgoing);
ssn = pn_session_next(ssn, 0);
}
@@ -721,7 +721,7 @@ static void pni_unmap_remote_handle(pn_link_t *link)
pn_hash_del(link->session->state.remote_handles, handle);
}
-pn_link_t *pn_handle_state(pn_session_t *ssn, uint32_t handle)
+static pn_link_t *pni_handle_state(pn_session_t *ssn, uint32_t handle)
{
return (pn_link_t *) pn_hash_get(ssn->state.remote_handles, handle);
}
@@ -849,17 +849,17 @@ int pn_post_frame(pn_transport_t *transport, uint8_t type, uint16_t ch, const ch
return 0;
}
-int pn_post_amqp_transfer_frame(pn_transport_t *transport, uint16_t ch,
- uint32_t handle,
- pn_sequence_t id,
- pn_bytes_t *payload,
- const pn_bytes_t *tag,
- uint32_t message_format,
- bool settled,
- bool more,
- pn_sequence_t frame_limit,
- uint64_t code,
- pn_data_t* state)
+static int pni_post_amqp_transfer_frame(pn_transport_t *transport, uint16_t ch,
+ uint32_t handle,
+ pn_sequence_t id,
+ pn_bytes_t *payload,
+ const pn_bytes_t *tag,
+ uint32_t message_format,
+ bool settled,
+ bool more,
+ pn_sequence_t frame_limit,
+ uint64_t code,
+ pn_data_t* state)
{
bool more_flag = more;
int framecount = 0;
@@ -952,7 +952,7 @@ int pn_post_amqp_transfer_frame(pn_transport_t *transport, uint16_t ch,
return framecount;
}
-int pn_post_close(pn_transport_t *transport, const char *condition, const char *description)
+static int pni_post_close(pn_transport_t *transport, const char *condition, const char *description)
{
pn_condition_t *cond = NULL;
if (transport->connection) {
@@ -1013,7 +1013,7 @@ int pn_do_error(pn_transport_t *transport, const char *condition, const char *fm
pn_post_frame(transport, AMQP_FRAME_TYPE, 0, "DL[S]", OPEN, "");
}
- pn_post_close(transport, condition, buf);
+ pni_post_close(transport, condition, buf);
transport->close_sent = true;
}
transport->halt = true;
@@ -1213,7 +1213,7 @@ int pn_do_attach(pn_transport_t *transport, uint8_t frame_type, uint16_t channel
strncpy(strname, name.start, name.size);
strname[name.size] = '\0';
- pn_session_t *ssn = pn_channel_state(transport, channel);
+ pn_session_t *ssn = pni_channel_state(transport, channel);
if (!ssn) {
pn_do_error(transport, "amqp:connection:no-session", "attach without a session");
if (strheap) free(strheap);
@@ -1303,7 +1303,7 @@ int pn_do_attach(pn_transport_t *transport, uint8_t frame_type, uint16_t channel
return 0;
}
-int pn_post_flow(pn_transport_t *transport, pn_session_t *ssn, pn_link_t *link);
+static int pni_post_flow(pn_transport_t *transport, pn_session_t *ssn, pn_link_t *link);
// free the delivery
static void pn_full_settle(pn_delivery_map_t *db, pn_delivery_t *delivery)
@@ -1330,13 +1330,13 @@ int pn_do_transfer(pn_transport_t *transport, uint8_t frame_type, uint16_t chann
int err = pn_data_scan(args, "D.[I?Iz.oo.D?LC]", &handle, &id_present, &id, &tag,
&settled, &more, &has_type, &type, transport->disp_data);
if (err) return err;
- pn_session_t *ssn = pn_channel_state(transport, channel);
+ pn_session_t *ssn = pni_channel_state(transport, channel);
if (!ssn->state.incoming_window) {
return pn_do_error(transport, "amqp:session:window-violation", "incoming session window exceeded");
}
- pn_link_t *link = pn_handle_state(ssn, handle);
+ pn_link_t *link = pni_handle_state(ssn, handle);
pn_delivery_t *delivery;
if (link->unsettled_tail && !link->unsettled_tail->done) {
delivery = link->unsettled_tail;
@@ -1350,7 +1350,7 @@ int pn_do_transfer(pn_transport_t *transport, uint8_t frame_type, uint16_t chann
}
delivery = pn_delivery(link, pn_dtag(tag.start, tag.size));
- pn_delivery_state_t *state = pn_delivery_map_push(incoming, delivery);
+ pn_delivery_state_t *state = pni_delivery_map_push(incoming, delivery);
if (id_present && id != state->id) {
return pn_do_error(transport, "amqp:session:invalid-field",
"sequencing error, expected delivery-id %u, got %u",
@@ -1382,7 +1382,7 @@ int pn_do_transfer(pn_transport_t *transport, uint8_t frame_type, uint16_t chann
// XXX: need better policy for when to refresh window
if (!ssn->state.incoming_window && (int32_t) link->state.local_handle >= 0) {
- pn_post_flow(transport, ssn, link);
+ pni_post_flow(transport, ssn, link);
}
pn_collector_put(transport->connection->collector, PN_OBJECT, delivery, PN_DELIVERY);
@@ -1400,7 +1400,7 @@ int pn_do_flow(pn_transport_t *transport, uint8_t frame_type, uint16_t channel,
&delivery_count, &link_credit, &drain);
if (err) return err;
- pn_session_t *ssn = pn_channel_state(transport, channel);
+ pn_session_t *ssn = pni_channel_state(transport, channel);
if (inext_init) {
ssn->state.remote_incoming_window = inext + iwin - ssn->state.outgoing_transfer_count;
@@ -1409,7 +1409,7 @@ int pn_do_flow(pn_transport_t *transport, uint8_t frame_type, uint16_t channel,
}
if (handle_init) {
- pn_link_t *link = pn_handle_state(ssn, handle);
+ pn_link_t *link = pni_handle_state(ssn, handle);
if (link->endpoint.type == SENDER) {
pn_sequence_t receiver_count;
if (dcount_init) {
@@ -1470,7 +1470,7 @@ int pn_do_disposition(pn_transport_t *transport, uint8_t frame_type, uint16_t ch
if (err) return err;
if (!last_init) last = first;
- pn_session_t *ssn = pn_channel_state(transport, channel);
+ pn_session_t *ssn = pni_channel_state(transport, channel);
pn_delivery_map_t *deliveries;
if (role) {
deliveries = &ssn->state.outgoing;
@@ -1483,7 +1483,7 @@ int pn_do_disposition(pn_transport_t *transport, uint8_t frame_type, uint16_t ch
pn_data_get_list(transport->disp_data) > 0);
for (pn_sequence_t id = first; id <= last; id++) {
- pn_delivery_t *delivery = pn_delivery_map_get(deliveries, id);
+ pn_delivery_t *delivery = pni_delivery_map_get(deliveries, id);
pn_disposition_t *remote = &delivery->remote;
if (delivery) {
if (type_init) remote->type = type;
@@ -1542,11 +1542,11 @@ int pn_do_detach(pn_transport_t *transport, uint8_t frame_type, uint16_t channel
int err = pn_data_scan(args, "D.[Io]", &handle, &closed);
if (err) return err;
- pn_session_t *ssn = pn_channel_state(transport, channel);
+ pn_session_t *ssn = pni_channel_state(transport, channel);
if (!ssn) {
return pn_do_error(transport, "amqp:invalid-field", "no such channel: %u", channel);
}
- pn_link_t *link = pn_handle_state(ssn, handle);
+ pn_link_t *link = pni_handle_state(ssn, handle);
if (!link) {
return pn_do_error(transport, "amqp:invalid-field", "no such handle: %u", handle);
}
@@ -1568,7 +1568,7 @@ int pn_do_detach(pn_transport_t *transport, uint8_t frame_type, uint16_t channel
int pn_do_end(pn_transport_t *transport, uint8_t frame_type, uint16_t channel, pn_data_t *args, const pn_bytes_t *payload)
{
- pn_session_t *ssn = pn_channel_state(transport, channel);
+ pn_session_t *ssn = pni_channel_state(transport, channel);
int err = pn_scan_error(args, &ssn->endpoint.remote_condition, SCAN_ERROR_DEFAULT);
if (err) return err;
PN_SET_REMOTE(ssn->endpoint.state, PN_REMOTE_CLOSED);
@@ -1753,7 +1753,7 @@ static pn_timestamp_t pn_tick_amqp(pn_transport_t* transport, unsigned int layer
return timeout;
}
-int pn_process_conn_setup(pn_transport_t *transport, pn_endpoint_t *endpoint)
+static int pni_process_conn_setup(pn_transport_t *transport, pn_endpoint_t *endpoint)
{
if (endpoint->type == CONNECTION)
{
@@ -1796,7 +1796,7 @@ static uint16_t allocate_alias(pn_hash_t *aliases)
return 0;
}
-size_t pn_session_outgoing_window(pn_session_t *ssn)
+static size_t pni_session_outgoing_window(pn_session_t *ssn)
{
uint32_t size = ssn->connection->transport->remote_max_frame;
if (!size) {
@@ -1810,7 +1810,7 @@ size_t pn_session_outgoing_window(pn_session_t *ssn)
}
}
-size_t pn_session_incoming_window(pn_session_t *ssn)
+static size_t pni_session_incoming_window(pn_session_t *ssn)
{
uint32_t size = ssn->connection->transport->local_max_frame;
if (!size) {
@@ -1830,7 +1830,7 @@ static void pni_map_local_channel(pn_session_t *ssn)
pn_ep_incref(&ssn->endpoint);
}
-int pn_process_ssn_setup(pn_transport_t *transport, pn_endpoint_t *endpoint)
+static int pni_process_ssn_setup(pn_transport_t *transport, pn_endpoint_t *endpoint)
{
if (endpoint->type == SESSION && transport->open_sent)
{
@@ -1839,8 +1839,8 @@ int pn_process_ssn_setup(pn_transport_t *transport, pn_endpoint_t *endpoint)
if (!(endpoint->state & PN_LOCAL_UNINIT) && state->local_channel == (uint16_t) -1)
{
pni_map_local_channel(ssn);
- state->incoming_window = pn_session_incoming_window(ssn);
- state->outgoing_window = pn_session_outgoing_window(ssn);
+ state->incoming_window = pni_session_incoming_window(ssn);
+ state->outgoing_window = pni_session_outgoing_window(ssn);
pn_post_frame(transport, AMQP_FRAME_TYPE, state->local_channel, "DL[?HIII]", BEGIN,
((int16_t) state->remote_channel >= 0), state->remote_channel,
state->outgoing_transfer_count,
@@ -1876,7 +1876,7 @@ static void pni_map_local_handle(pn_link_t *link) {
pn_ep_incref(&link->endpoint);
}
-int pn_process_link_setup(pn_transport_t *transport, pn_endpoint_t *endpoint)
+static int pni_process_link_setup(pn_transport_t *transport, pn_endpoint_t *endpoint)
{
if (transport->open_sent && (endpoint->type == SENDER ||
endpoint->type == RECEIVER))
@@ -1947,10 +1947,10 @@ int pn_process_link_setup(pn_transport_t *transport, pn_endpoint_t *endpoint)
return 0;
}
-int pn_post_flow(pn_transport_t *transport, pn_session_t *ssn, pn_link_t *link)
+static int pni_post_flow(pn_transport_t *transport, pn_session_t *ssn, pn_link_t *link)
{
- ssn->state.incoming_window = pn_session_incoming_window(ssn);
- ssn->state.outgoing_window = pn_session_outgoing_window(ssn);
+ ssn->state.incoming_window = pni_session_incoming_window(ssn);
+ ssn->state.outgoing_window = pni_session_outgoing_window(ssn);
bool linkq = (bool) link;
pn_link_state_t *state = &link->state;
return pn_post_frame(transport, AMQP_FRAME_TYPE, ssn->state.local_channel, "DL[?IIII?I?I?In?o]", FLOW,
@@ -1964,7 +1964,7 @@ int pn_post_flow(pn_transport_t *transport, pn_session_t *ssn, pn_link_t *link)
linkq, linkq ? link->drain : false);
}
-int pn_process_flow_receiver(pn_transport_t *transport, pn_endpoint_t *endpoint)
+static int pni_process_flow_receiver(pn_transport_t *transport, pn_endpoint_t *endpoint)
{
if (endpoint->type == RECEIVER && endpoint->state & PN_LOCAL_ACTIVE)
{
@@ -1975,14 +1975,14 @@ int pn_process_flow_receiver(pn_transport_t *transport, pn_endpoint_t *endpoint)
(int32_t) state->local_handle >= 0 &&
((rcv->drain || state->link_credit != rcv->credit - rcv->queued) || !ssn->state.incoming_window)) {
state->link_credit = rcv->credit - rcv->queued;
- return pn_post_flow(transport, ssn, rcv);
+ return pni_post_flow(transport, ssn, rcv);
}
}
return 0;
}
-int pn_flush_disp(pn_transport_t *transport, pn_session_t *ssn)
+static int pni_flush_disp(pn_transport_t *transport, pn_session_t *ssn)
{
uint64_t code = ssn->state.disp_code;
bool settled = ssn->state.disp_settled;
@@ -2001,7 +2001,7 @@ int pn_flush_disp(pn_transport_t *transport, pn_session_t *ssn)
return 0;
}
-int pn_post_disp(pn_transport_t *transport, pn_delivery_t *delivery)
+static int pni_post_disp(pn_transport_t *transport, pn_delivery_t *delivery)
{
pn_link_t *link = delivery->link;
pn_session_t *ssn = link->session;
@@ -2038,7 +2038,7 @@ int pn_post_disp(pn_transport_t *transport, pn_delivery_t *delivery)
}
if (ssn_state->disp) {
- int err = pn_flush_disp(transport, ssn);
+ int err = pni_flush_disp(transport, ssn);
if (err) return err;
}
@@ -2052,7 +2052,7 @@ int pn_post_disp(pn_transport_t *transport, pn_delivery_t *delivery)
return 0;
}
-int pn_process_tpwork_sender(pn_transport_t *transport, pn_delivery_t *delivery, bool *settle)
+static int pni_process_tpwork_sender(pn_transport_t *transport, pn_delivery_t *delivery, bool *settle)
{
*settle = false;
pn_link_t *link = delivery->link;
@@ -2064,7 +2064,7 @@ int pn_process_tpwork_sender(pn_transport_t *transport, pn_delivery_t *delivery,
if (!state->sent && (delivery->done || pn_buffer_size(delivery->bytes) > 0) &&
ssn_state->remote_incoming_window > 0 && link_state->link_credit > 0) {
if (!state->init) {
- state = pn_delivery_map_push(&ssn_state->outgoing, delivery);
+ state = pni_delivery_map_push(&ssn_state->outgoing, delivery);
}
pn_bytes_t bytes = pn_buffer_bytes(delivery->bytes);
@@ -2073,7 +2073,7 @@ int pn_process_tpwork_sender(pn_transport_t *transport, pn_delivery_t *delivery,
pn_data_clear(transport->disp_data);
pni_disposition_encode(&delivery->local, transport->disp_data);
- int count = pn_post_amqp_transfer_frame(transport,
+ int count = pni_post_amqp_transfer_frame(transport,
ssn_state->local_channel,
link_state->local_handle,
state->id, &bytes, &tag,
@@ -2105,7 +2105,7 @@ int pn_process_tpwork_sender(pn_transport_t *transport, pn_delivery_t *delivery,
pn_delivery_state_t *state = delivery->state.init ? &delivery->state : NULL;
if ((int16_t) ssn_state->local_channel >= 0 && !delivery->remote.settled
&& state && state->sent && !xfr_posted) {
- int err = pn_post_disp(transport, delivery);
+ int err = pni_post_disp(transport, delivery);
if (err) return err;
}
@@ -2113,20 +2113,20 @@ int pn_process_tpwork_sender(pn_transport_t *transport, pn_delivery_t *delivery,
return 0;
}
-int pn_process_tpwork_receiver(pn_transport_t *transport, pn_delivery_t *delivery, bool *settle)
+static int pni_process_tpwork_receiver(pn_transport_t *transport, pn_delivery_t *delivery, bool *settle)
{
*settle = false;
pn_link_t *link = delivery->link;
// XXX: need to prevent duplicate disposition sending
pn_session_t *ssn = link->session;
if ((int16_t) ssn->state.local_channel >= 0 && !delivery->remote.settled && delivery->state.init) {
- int err = pn_post_disp(transport, delivery);
+ int err = pni_post_disp(transport, delivery);
if (err) return err;
}
// XXX: need to centralize this policy and improve it
if (!ssn->state.incoming_window) {
- int err = pn_post_flow(transport, ssn, link);
+ int err = pni_post_flow(transport, ssn, link);
if (err) return err;
}
@@ -2134,7 +2134,7 @@ int pn_process_tpwork_receiver(pn_transport_t *transport, pn_delivery_t *deliver
return 0;
}
-int pn_process_tpwork(pn_transport_t *transport, pn_endpoint_t *endpoint)
+static int pni_process_tpwork(pn_transport_t *transport, pn_endpoint_t *endpoint)
{
if (endpoint->type == CONNECTION && !transport->close_sent)
{
@@ -2149,11 +2149,11 @@ int pn_process_tpwork(pn_transport_t *transport, pn_endpoint_t *endpoint)
pn_delivery_map_t *dm = NULL;
if (pn_link_is_sender(link)) {
dm = &link->session->state.outgoing;
- int err = pn_process_tpwork_sender(transport, delivery, &settle);
+ int err = pni_process_tpwork_sender(transport, delivery, &settle);
if (err) return err;
} else {
dm = &link->session->state.incoming;
- int err = pn_process_tpwork_receiver(transport, delivery, &settle);
+ int err = pni_process_tpwork_receiver(transport, delivery, &settle);
if (err) return err;
}
@@ -2170,14 +2170,14 @@ int pn_process_tpwork(pn_transport_t *transport, pn_endpoint_t *endpoint)
return 0;
}
-int pn_process_flush_disp(pn_transport_t *transport, pn_endpoint_t *endpoint)
+static int pni_process_flush_disp(pn_transport_t *transport, pn_endpoint_t *endpoint)
{
if (endpoint->type == SESSION) {
pn_session_t *session = (pn_session_t *) endpoint;
pn_session_state_t *state = &session->state;
if ((int16_t) state->local_channel >= 0 && !transport->close_sent)
{
- int err = pn_flush_disp(transport, session);
+ int err = pni_flush_disp(transport, session);
if (err) return err;
}
}
@@ -2185,7 +2185,7 @@ int pn_process_flush_disp(pn_transport_t *transport, pn_endpoint_t *endpoint)
return 0;
}
-int pn_process_flow_sender(pn_transport_t *transport, pn_endpoint_t *endpoint)
+static int pni_process_flow_sender(pn_transport_t *transport, pn_endpoint_t *endpoint)
{
if (endpoint->type == SENDER && endpoint->state & PN_LOCAL_ACTIVE)
{
@@ -2200,7 +2200,7 @@ int pn_process_flow_sender(pn_transport_t *transport, pn_endpoint_t *endpoint)
state->delivery_count += state->link_credit;
state->link_credit = 0;
snd->drained = 0;
- return pn_post_flow(transport, ssn, snd);
+ return pni_post_flow(transport, ssn, snd);
}
}
}
@@ -2219,7 +2219,7 @@ static void pni_unmap_local_handle(pn_link_t *link) {
pn_hash_del(link->session->state.local_handles, handle);
}
-int pn_process_link_teardown(pn_transport_t *transport, pn_endpoint_t *endpoint)
+static int pni_process_link_teardown(pn_transport_t *transport, pn_endpoint_t *endpoint)
{
if (endpoint->type == SENDER || endpoint->type == RECEIVER)
{
@@ -2258,7 +2258,7 @@ int pn_process_link_teardown(pn_transport_t *transport, pn_endpoint_t *endpoint)
return 0;
}
-bool pn_pointful_buffering(pn_transport_t *transport, pn_session_t *session)
+static bool pni_pointful_buffering(pn_transport_t *transport, pn_session_t *session)
{
if (transport->close_rcvd) return false;
if (!transport->open_rcvd) return true;
@@ -2283,7 +2283,7 @@ bool pn_pointful_buffering(pn_transport_t *transport, pn_session_t *session)
static void pni_unmap_local_channel(pn_session_t *ssn) {
// XXX: should really update link state also
- pn_delivery_map_clear(&ssn->state.outgoing);
+ pni_delivery_map_clear(&ssn->state.outgoing);
pni_transport_unbind_handles(ssn->state.local_handles, false);
pn_transport_t *transport = ssn->connection->transport;
pn_session_state_t *state = &ssn->state;
@@ -2296,7 +2296,7 @@ static void pni_unmap_local_channel(pn_session_t *ssn) {
pn_hash_del(transport->local_channels, channel);
}
-int pn_process_ssn_teardown(pn_transport_t *transport, pn_endpoint_t *endpoint)
+static int pni_process_ssn_teardown(pn_transport_t *transport, pn_endpoint_t *endpoint)
{
if (endpoint->type == SESSION)
{
@@ -2305,7 +2305,7 @@ int pn_process_ssn_teardown(pn_transport_t *transport, pn_endpoint_t *endpoint)
if (endpoint->state & PN_LOCAL_CLOSED && (int16_t) state->local_channel >= 0
&& !transport->close_sent)
{
- if (pn_pointful_buffering(transport, session)) {
+ if (pni_pointful_buffering(transport, session)) {
return 0;
}
@@ -2330,13 +2330,13 @@ int pn_process_ssn_teardown(pn_transport_t *transport, pn_endpoint_t *endpoint)
return 0;
}
-int pn_process_conn_teardown(pn_transport_t *transport, pn_endpoint_t *endpoint)
+static int pni_process_conn_teardown(pn_transport_t *transport, pn_endpoint_t *endpoint)
{
if (endpoint->type == CONNECTION)
{
if (endpoint->state & PN_LOCAL_CLOSED && !transport->close_sent) {
- if (pn_pointful_buffering(transport, NULL)) return 0;
- int err = pn_post_close(transport, NULL, NULL);
+ if (pni_pointful_buffering(transport, NULL)) return 0;
+ int err = pni_post_close(transport, NULL, NULL);
if (err) return err;
transport->close_sent = true;
}
@@ -2346,7 +2346,7 @@ int pn_process_conn_teardown(pn_transport_t *transport, pn_endpoint_t *endpoint)
return 0;
}
-int pn_phase(pn_transport_t *transport, int (*phase)(pn_transport_t *, pn_endpoint_t *))
+static int pni_phase(pn_transport_t *transport, int (*phase)(pn_transport_t *, pn_endpoint_t *))
{
pn_connection_t *conn = transport->connection;
pn_endpoint_t *endpoint = conn->transport_head;
@@ -2360,26 +2360,26 @@ int pn_phase(pn_transport_t *transport, int (*phase)(pn_transport_t *, pn_endpoi
return 0;
}
-int pn_process(pn_transport_t *transport)
+static int pni_process(pn_transport_t *transport)
{
int err;
- if ((err = pn_phase(transport, pn_process_conn_setup))) return err;
- if ((err = pn_phase(transport, pn_process_ssn_setup))) return err;
- if ((err = pn_phase(transport, pn_process_link_setup))) return err;
- if ((err = pn_phase(transport, pn_process_flow_receiver))) return err;
+ if ((err = pni_phase(transport, pni_process_conn_setup))) return err;
+ if ((err = pni_phase(transport, pni_process_ssn_setup))) return err;
+ if ((err = pni_phase(transport, pni_process_link_setup))) return err;
+ if ((err = pni_phase(transport, pni_process_flow_receiver))) return err;
// XXX: this has to happen two times because we might settle stuff
// on the first pass and create space for more work to be done on the
// second pass
- if ((err = pn_phase(transport, pn_process_tpwork))) return err;
- if ((err = pn_phase(transport, pn_process_tpwork))) return err;
+ if ((err = pni_phase(transport, pni_process_tpwork))) return err;
+ if ((err = pni_phase(transport, pni_process_tpwork))) return err;
- if ((err = pn_phase(transport, pn_process_flush_disp))) return err;
+ if ((err = pni_phase(transport, pni_process_flush_disp))) return err;
- if ((err = pn_phase(transport, pn_process_flow_sender))) return err;
- if ((err = pn_phase(transport, pn_process_link_teardown))) return err;
- if ((err = pn_phase(transport, pn_process_ssn_teardown))) return err;
- if ((err = pn_phase(transport, pn_process_conn_teardown))) return err;
+ if ((err = pni_phase(transport, pni_process_flow_sender))) return err;
+ if ((err = pni_phase(transport, pni_process_link_teardown))) return err;
+ if ((err = pni_phase(transport, pni_process_ssn_teardown))) return err;
+ if ((err = pni_phase(transport, pni_process_conn_teardown))) return err;
if (transport->connection->tpwork_head) {
pn_modified(transport->connection, &transport->connection->endpoint, false);
@@ -2407,7 +2407,7 @@ static ssize_t pn_output_write_amqp_header(pn_transport_t* transport, unsigned i
static ssize_t pn_output_write_amqp(pn_transport_t* transport, unsigned int layer, char* bytes, size_t available)
{
if (transport->connection && !transport->done_processing) {
- int err = pn_process(transport);
+ int err = pni_process(transport);
if (err) {
pn_transport_logf(transport, "process error %i", err);
transport->done_processing = true;
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org
[2/2] qpid-proton git commit: PROTON-896: declare functions static
that are only referred to in one file,
and change their names to have pni_ prefix.
Posted by mg...@apache.org.
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 <mi...@redhat.com>
Authored: Mon Jun 8 10:05:50 2015 -0400
Committer: Mick Goulish <mi...@redhat.com>
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: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org