You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by zw...@apache.org on 2013/04/24 21:56:05 UTC
[2/3] TS-1794 Replace all usage of ts_debug_assert() with ts_assert()
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/mgmt/stats/StatType.cc
----------------------------------------------------------------------
diff --git a/mgmt/stats/StatType.cc b/mgmt/stats/StatType.cc
index 2d8e11d..822d9f6 100644
--- a/mgmt/stats/StatType.cc
+++ b/mgmt/stats/StatType.cc
@@ -147,7 +147,7 @@ StatExprToken::assignTokenName(const char *name)
*/
bool StatExprToken::assignTokenType()
{
- ink_debug_assert(m_token_name != NULL);
+ ink_assert(m_token_name != NULL);
m_token_type = varType(m_token_name);
if (m_token_name[0] == '$') {
@@ -522,7 +522,7 @@ StatObject::assignExpr(char *str)
if (StatDebug) {
Debug(MODULE_INIT, "EXPRESSION: %s\n", str);
}
- ink_debug_assert(m_expr_string == NULL);
+ ink_assert(m_expr_string == NULL);
// We take ownership here
m_expr_string = str;
@@ -531,7 +531,7 @@ StatObject::assignExpr(char *str)
tok_iter_state exprTok_state;
const char *token = exprTok.iterFirst(&exprTok_state);
- ink_debug_assert(m_expression == NULL);
+ ink_assert(m_expression == NULL);
m_expression = NEW(new StatExprList());
while (token) {
@@ -541,7 +541,7 @@ StatObject::assignExpr(char *str)
if (isOperator(token[0])) {
statToken->m_arith_symbol = token[0];
- ink_debug_assert(statToken->m_token_name == NULL);
+ ink_assert(statToken->m_token_name == NULL);
if (StatDebug) {
Debug(MODULE_INIT, "\toperator: ->%c<-\n", statToken->m_arith_symbol);
@@ -549,7 +549,7 @@ StatObject::assignExpr(char *str)
} else {
- ink_debug_assert(statToken->m_arith_symbol == '\0');
+ ink_assert(statToken->m_arith_symbol == '\0');
// delta
if (token[0] == '#') {
@@ -606,7 +606,7 @@ StatObject::infix2postfix()
m_postfix->enqueue(curToken);
} else {
- ink_debug_assert(curToken->m_arith_symbol != '\0');
+ ink_assert(curToken->m_arith_symbol != '\0');
if (curToken->m_arith_symbol == '(') {
stack.push(curToken);
@@ -712,7 +712,7 @@ RecData StatObject::NodeStatEval(RecDataT *result_type, bool cluster)
if (!isOperator(curToken->m_arith_symbol)) {
stack.push(curToken);
} else {
- ink_debug_assert(isOperator(curToken->m_arith_symbol));
+ ink_assert(isOperator(curToken->m_arith_symbol));
right = stack.pop();
left = stack.pop();
@@ -735,7 +735,7 @@ RecData StatObject::NodeStatEval(RecDataT *result_type, bool cluster)
/* should only be 1 value left on stack -- the resulting value */
if (stack.count() > 1) {
stack.print("\t");
- ink_debug_assert(false);
+ ink_assert(false);
}
*result_type = stack.top()->m_token_type;
@@ -756,7 +756,7 @@ RecData StatObject::NodeStatEval(RecDataT *result_type, bool cluster)
RecData StatObject::ClusterStatEval(RecDataT *result_type)
{
/* Sanity check */
- ink_debug_assert(m_cluster_dest && !m_cluster_dest->m_node_var);
+ ink_assert(m_cluster_dest && !m_cluster_dest->m_node_var);
// what is this?
if ((m_node_dest == NULL) || (m_cluster_dest->m_sum_var == false)) {
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/mgmt/web2/WebOverview.cc
----------------------------------------------------------------------
diff --git a/mgmt/web2/WebOverview.cc b/mgmt/web2/WebOverview.cc
index fc73b06..3084eb8 100644
--- a/mgmt/web2/WebOverview.cc
+++ b/mgmt/web2/WebOverview.cc
@@ -172,7 +172,7 @@ overviewRecord::readCounter(const char *name, bool * found)
if (rec_status == REC_ERR_OKAY) {
order -= node_rec_first_ix; // Offset
ink_release_assert(order < node_rec_data.num_recs);
- ink_debug_assert(order < node_rec_data.num_recs);
+ ink_assert(order < node_rec_data.num_recs);
rec = node_rec_data.recs[order].data.rec_counter;
} else {
mgmt_log(stderr, "node variables '%s' not found!\n");
@@ -198,7 +198,7 @@ overviewRecord::readInteger(const char *name, bool * found)
if (rec_status == REC_ERR_OKAY) {
order -= node_rec_first_ix; // Offset
ink_release_assert(order < node_rec_data.num_recs);
- ink_debug_assert(order < node_rec_data.num_recs);
+ ink_assert(order < node_rec_data.num_recs);
rec = node_rec_data.recs[order].data.rec_int;
}
} else {
@@ -224,7 +224,7 @@ overviewRecord::readFloat(const char *name, bool * found)
if (rec_status == REC_ERR_OKAY) {
order -= node_rec_first_ix; // Offset
ink_release_assert(order < node_rec_data.num_recs);
- ink_debug_assert(order < node_rec_data.num_recs);
+ ink_assert(order < node_rec_data.num_recs);
rec = node_rec_data.recs[order].data.rec_float;
}
} else {
@@ -250,7 +250,7 @@ overviewRecord::readString(const char *name, bool * found)
if (rec_status == REC_ERR_OKAY) {
order -= node_rec_first_ix; // Offset
ink_release_assert(order < node_rec_data.num_recs);
- ink_debug_assert(order < node_rec_data.num_recs);
+ ink_assert(order < node_rec_data.num_recs);
rec = ats_strdup(node_rec_data.recs[order].data.rec_string);
}
} else {
@@ -289,7 +289,7 @@ overviewRecord::readData(RecDataT varType, const char *name, bool * found)
if (rec_status == REC_ERR_OKAY) {
order -= node_rec_first_ix; // Offset
ink_release_assert(order < node_rec_data.num_recs);
- ink_debug_assert(order < node_rec_data.num_recs);
+ ink_assert(order < node_rec_data.num_recs);
RecDataSet(varType, &rec, &node_rec_data.recs[order].data);
} else {
Fatal("node variables '%s' not found!\n", name);
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/InkAPI.cc
----------------------------------------------------------------------
diff --git a/proxy/InkAPI.cc b/proxy/InkAPI.cc
index 814b07c..c68a391 100644
--- a/proxy/InkAPI.cc
+++ b/proxy/InkAPI.cc
@@ -6832,7 +6832,7 @@ TSTextLogObjectWrite(TSTextLogObject the_object, const char *format, ...)
retVal = TS_ERROR;
break;
default:
- ink_debug_assert(!"invalid return code");
+ ink_assert(!"invalid return code");
}
va_end(ap);
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/MuxVC.cc
----------------------------------------------------------------------
diff --git a/proxy/MuxVC.cc b/proxy/MuxVC.cc
index 2f08a85..92c17b2 100644
--- a/proxy/MuxVC.cc
+++ b/proxy/MuxVC.cc
@@ -96,7 +96,7 @@ mux_move_data(MIOBuffer * copy_to, IOBufferReader * from, int nbytes)
int64_t block_avail = from->block_read_avail();
int act_on = MIN(block_avail, left);
int r = copy_to->write(block_start, act_on);
- ink_debug_assert(r == act_on);
+ ink_assert(r == act_on);
from->consume(act_on);
left -= act_on;
}
@@ -134,8 +134,8 @@ void
MuxClientVC::init(MuxVC * mvc, int32_t id_arg)
{
- ink_debug_assert(!closed);
- ink_debug_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
+ ink_assert(!closed);
+ ink_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
mux_vc = mvc;
mutex = mux_vc->mutex;
@@ -155,9 +155,9 @@ void
MuxClientVC::kill()
{
- ink_debug_assert(closed == true);
- ink_debug_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
- ink_debug_assert(mutex->thread_holding == this_ethread());
+ ink_assert(closed == true);
+ ink_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
+ ink_assert(mutex->thread_holding == this_ethread());
Debug("mux_alloc", "[%d,%d] Killing client id", mux_vc->id, id);
@@ -198,8 +198,8 @@ VIO *
MuxClientVC::do_io_read(Continuation * c, int64_t nbytes, MIOBuffer * buf)
{
- ink_debug_assert(!closed);
- ink_debug_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
+ ink_assert(!closed);
+ ink_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
if (read_state.vio.op == VIO::READ) {
Debug("mux_last", "do_io_read over nbytes %d ndone %d byte_bank %d",
@@ -237,9 +237,9 @@ VIO *
MuxClientVC::do_io_write(Continuation * c, int64_t nbytes, IOBufferReader * abuffer, bool owner)
{
- ink_debug_assert(!closed);
- ink_debug_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
- ink_debug_assert(owner == false);
+ ink_assert(!closed);
+ ink_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
+ ink_assert(owner == false);
if (abuffer) {
ink_assert(!owner);
@@ -273,17 +273,17 @@ void
MuxClientVC::reenable(VIO * vio)
{
- ink_debug_assert(!closed);
- ink_debug_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
+ ink_assert(!closed);
+ ink_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
Debug("muxvc", "[%d,%d] MuxClientVC::reenable %s", mux_vc->id, id, (vio->op == VIO::WRITE) ? "Write" : "Read");
if (vio == &read_state.vio) {
- ink_debug_assert(vio->op == VIO::READ);
+ ink_assert(vio->op == VIO::READ);
read_state.enabled = 1;
} else {
- ink_debug_assert(vio == &write_state.vio);
- ink_debug_assert(vio->op == VIO::WRITE);
+ ink_assert(vio == &write_state.vio);
+ ink_assert(vio->op == VIO::WRITE);
write_state.enabled = 1;
}
@@ -297,8 +297,8 @@ MuxClientVC::reenable_re(VIO * vio)
{
this->reenable(vio);
/*
- ink_debug_assert(!closed);
- ink_debug_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
+ ink_assert(!closed);
+ ink_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
Debug("muxvc", "[%d] reenable_re %s", id,
(vio->op == VIO::WRITE) ? "Write" : "Read");
@@ -325,8 +325,8 @@ void
MuxClientVC::do_io_close(int flag)
{
- ink_debug_assert(closed == false);
- ink_debug_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
+ ink_assert(closed == false);
+ ink_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
Debug("muxvc", "[%d, %d] do_io_close", mux_vc->id, id);
@@ -374,8 +374,8 @@ void
MuxClientVC::do_io_shutdown(ShutdownHowTo_t howto)
{
- ink_debug_assert(closed == false);
- ink_debug_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
+ ink_assert(closed == false);
+ ink_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
switch (howto) {
case IO_SHUTDOWN_READ:
@@ -402,8 +402,8 @@ void
MuxClientVC::set_active_timeout(ink_hrtime timeout_in)
{
- ink_debug_assert(closed == false);
- ink_debug_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
+ ink_assert(closed == false);
+ ink_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
active_timeout = timeout_in;
@@ -427,8 +427,8 @@ void
MuxClientVC::set_inactivity_timeout(ink_hrtime timeout_in)
{
- ink_debug_assert(closed == false);
- ink_debug_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
+ ink_assert(closed == false);
+ ink_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
inactive_timeout = timeout_in;
@@ -475,7 +475,7 @@ MuxClientVC::get_inactivity_timeout()
void
MuxClientVC::update_inactive_timeout()
{
- ink_debug_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
+ ink_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
if (inactive_event) {
inactive_event->cancel();
@@ -541,7 +541,7 @@ MuxClientVC::main_handler(int event, void *data)
Ptr<ProxyMutex> read_side_mutex = read_state.vio.mutex;
Ptr<ProxyMutex> write_side_mutex = write_state.vio.mutex;
- ink_debug_assert(mutex->thread_holding == my_ethread);
+ ink_assert(mutex->thread_holding == my_ethread);
if (read_side_mutex) {
read_mutex_held = MUTEX_TAKE_TRY_LOCK(read_side_mutex, my_ethread);
@@ -600,7 +600,7 @@ void
MuxClientVC::process_timeout(int event_to_send)
{
- ink_debug_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
+ ink_assert(magic == MUX_VC_CLIENT_MAGIC_ALIVE);
Debug("muxvc", "[%d,%d] process_timeout - event_to_send %d", mux_vc->id, id, event_to_send);
@@ -695,8 +695,8 @@ void
MuxClientVC::process_read_state()
{
- ink_debug_assert(read_state.vio.mutex->thread_holding == this_ethread());
- ink_debug_assert(read_state.enabled);
+ ink_assert(read_state.vio.mutex->thread_holding == this_ethread());
+ ink_assert(read_state.enabled);
if (read_byte_bank) {
this->process_byte_bank();
@@ -783,8 +783,8 @@ MuxClientVC::process_write()
{
int bytes_written = 0;
- ink_debug_assert(write_state.vio.mutex->thread_holding == this_ethread());
- ink_debug_assert(write_state.enabled);
+ ink_assert(write_state.vio.mutex->thread_holding == this_ethread());
+ ink_assert(write_state.enabled);
if (other_side_closed & MUX_OCLOSE_OUTBOUND_MASK) {
if (other_side_closed & MUX_OCLOSE_NEED_WRITE_NOTIFY) {
@@ -793,7 +793,7 @@ MuxClientVC::process_write()
return 0;
} else {
- ink_debug_assert(!closed);
+ ink_assert(!closed);
int64_t ntodo = write_state.vio.ntodo();
if (ntodo == 0 || write_state.shutdown) {
@@ -814,7 +814,7 @@ MuxClientVC::process_write()
//
// act_on = MIN(act_on, MUX_MAX_BYTES_SLOT);
- ink_debug_assert(act_on >= 0);
+ ink_assert(act_on >= 0);
if (act_on <= 0) {
Debug("muxvc", "[process_write] disabling [%d,%d]" " due to zero bytes", mux_vc->id, id);
write_state.enabled = 0;
@@ -879,10 +879,10 @@ void
MuxClientVC::process_channel_close_for_read()
{
- ink_debug_assert(!closed);
- ink_debug_assert(other_side_closed & MUX_OCLOSE_NEED_READ_NOTIFY);
- ink_debug_assert(read_state.vio.mutex->thread_holding == this_ethread());
- ink_debug_assert(read_byte_bank == NULL);
+ ink_assert(!closed);
+ ink_assert(other_side_closed & MUX_OCLOSE_NEED_READ_NOTIFY);
+ ink_assert(read_state.vio.mutex->thread_holding == this_ethread());
+ ink_assert(read_byte_bank == NULL);
if (!read_state.shutdown && read_state.vio.ntodo() > 0) {
@@ -905,9 +905,9 @@ void
MuxClientVC::process_channel_close_for_write()
{
- ink_debug_assert(!closed);
- ink_debug_assert(other_side_closed & MUX_OCLOSE_NEED_WRITE_NOTIFY);
- ink_debug_assert(write_state.vio.mutex->thread_holding == this_ethread());
+ ink_assert(!closed);
+ ink_assert(other_side_closed & MUX_OCLOSE_NEED_WRITE_NOTIFY);
+ ink_assert(write_state.vio.mutex->thread_holding == this_ethread());
if (!write_state.shutdown && write_state.vio.ntodo() > 0) {
@@ -923,9 +923,9 @@ int
MuxClientVC::send_write_shutdown_message()
{
- ink_debug_assert(!closed);
- ink_debug_assert(write_state.shutdown & MUX_WRITE_SHUTUDOWN_SEND_MSG);
- ink_debug_assert(this->mutex->thread_holding == this_ethread());
+ ink_assert(!closed);
+ ink_assert(write_state.shutdown & MUX_WRITE_SHUTUDOWN_SEND_MSG);
+ ink_assert(this->mutex->thread_holding == this_ethread());
write_state.shutdown &= ~MUX_WRITE_SHUTUDOWN_SEND_MSG;
@@ -999,7 +999,7 @@ MuxVC::init_buffers()
if (!read_buffer) {
read_buffer = new_MIOBuffer(BUFFER_SIZE_INDEX_32K);
- ink_debug_assert(read_buffer_reader == NULL);
+ ink_assert(read_buffer_reader == NULL);
read_buffer_reader = read_buffer->alloc_reader();
}
@@ -1040,9 +1040,9 @@ Action *
MuxVC::do_connect(Continuation * c, unsigned int ip, int port)
{
- ink_debug_assert(magic == MUX_VC_MAGIC_ALIVE);
- ink_debug_assert(return_connect_action.continuation == NULL);
- ink_debug_assert(connect_state == MUX_NOT_CONNECTED);
+ ink_assert(magic == MUX_VC_MAGIC_ALIVE);
+ ink_assert(return_connect_action.continuation == NULL);
+ ink_assert(connect_state == MUX_NOT_CONNECTED);
reentrancy_count++;
connect_state = MUX_NET_CONNECT_ISSUED;
@@ -1091,7 +1091,7 @@ MuxVC::state_handle_connect(int event, void *data)
{
ink_release_assert(magic == MUX_VC_MAGIC_ALIVE);
- ink_debug_assert(net_vc == NULL);
+ ink_assert(net_vc == NULL);
Debug("muxvc", "MuxVC::connect_handler event %d", event);
Debug("mux_open", "MuxVC::connect_handler event %d", event);
@@ -1126,7 +1126,7 @@ MuxVC::state_wait_for_ready(int event, void *data)
{
ink_release_assert(magic == MUX_VC_MAGIC_ALIVE);
- ink_debug_assert(connect_state == MUX_WAIT_FOR_READY);
+ ink_assert(connect_state == MUX_WAIT_FOR_READY);
Debug("muxvc", "MuxVC::state_wait_for_ready event %d", event);
Debug("mux_open", "MuxVC::state_wait_for_ready event %d", event);
@@ -1135,7 +1135,7 @@ MuxVC::state_wait_for_ready(int event, void *data)
switch (event) {
case VC_EVENT_WRITE_READY:
- ink_debug_assert(data == write_vio);
+ ink_assert(data == write_vio);
connect_state = MUX_CONNECTED_ACTIVE;
net_vc->cancel_inactivity_timeout();
net_vc->do_io_write(this, 0, NULL);
@@ -1167,7 +1167,7 @@ int
MuxVC::state_send_init_response(int event, void *data)
{
- ink_debug_assert(event == EVENT_NONE || (event == EVENT_INTERVAL && data == retry_event));
+ ink_assert(event == EVENT_NONE || (event == EVENT_INTERVAL && data == retry_event));
if (event == EVENT_INTERVAL) {
retry_event = NULL;
@@ -1237,7 +1237,7 @@ MuxVC::setup_connect_check()
// FIX - ready timeout should be tunable
net_vc->set_inactivity_timeout(HRTIME_SECONDS(30));
- ink_debug_assert(write_vio == NULL);
+ ink_assert(write_vio == NULL);
write_vio = net_vc->do_io_write(this, INT64_MAX, r);
}
@@ -1253,8 +1253,8 @@ void
MuxVC::kill()
{
- ink_debug_assert(mutex->thread_holding == this_ethread());
- ink_debug_assert(reentrancy_count == 0);
+ ink_assert(mutex->thread_holding == this_ethread());
+ ink_assert(reentrancy_count == 0);
ink_release_assert(num_clients == 0);
Debug("mux_alloc", "[%d] Cleaning up MuxVC", id);
@@ -1298,7 +1298,7 @@ MuxVC::kill()
}
Debug("mux_alloc", "[%d] Killing MuxVC", id);
- ink_debug_assert(on_mux_list == false);
+ ink_assert(on_mux_list == false);
mutex = NULL;
delete this;
}
@@ -1307,9 +1307,9 @@ int
MuxVC::state_remove_from_list(int event, void *data)
{
- ink_debug_assert(data == process_event);
- ink_debug_assert(event == EVENT_INTERVAL);
- ink_debug_assert(on_mux_list);
+ ink_assert(data == process_event);
+ ink_assert(event == EVENT_INTERVAL);
+ ink_assert(on_mux_list);
process_event = NULL;
if (try_processor_list_remove() == 0) {
@@ -1343,17 +1343,17 @@ MuxClientVC *
MuxVC::new_client(int32_t id_arg)
{
- ink_debug_assert(magic == MUX_VC_MAGIC_ALIVE);
+ ink_assert(magic == MUX_VC_MAGIC_ALIVE);
ink_release_assert(mutex->thread_holding == this_ethread());
if (connect_state == MUX_CONNECTED_IDLE) {
- ink_debug_assert(process_event != NULL);
+ ink_assert(process_event != NULL);
process_event->cancel();
process_event = NULL;
connect_state = MUX_CONNECTED_ACTIVE;
SET_HANDLER(MuxVC::state_handle_mux);
}
- ink_debug_assert(connect_state == MUX_CONNECTED_ACTIVE);
+ ink_assert(connect_state == MUX_CONNECTED_ACTIVE);
MuxClientVC *new_client = NEW(new MuxClientVC);
@@ -1370,7 +1370,7 @@ MuxVC::new_client(int32_t id_arg)
num_clients++;
active_clients.push(new_client);
- ink_debug_assert(on_list(new_client) == true);
+ ink_assert(on_list(new_client) == true);
return new_client;
}
@@ -1383,7 +1383,7 @@ void
MuxVC::remove_client(MuxClientVC * client)
{
- ink_debug_assert(mutex->thread_holding == this_ethread());
+ ink_assert(mutex->thread_holding == this_ethread());
num_clients--;
active_clients.remove(client);
@@ -1431,7 +1431,7 @@ int
MuxVC::enqueue_control_message(int msg_id, int32_t cid, int data_size)
{
- ink_debug_assert(data_size + sizeof(MuxMessage) <= USHRT_MAX);
+ ink_assert(data_size + sizeof(MuxMessage) <= USHRT_MAX);
MuxMessage mm;
Debug("mux_cntl", "enqueue_control_message: %s for %d", control_msg_id_to_string(msg_id), cid);
@@ -1457,7 +1457,7 @@ void
MuxVC::process_clients()
{
- ink_debug_assert(magic == MUX_VC_MAGIC_ALIVE);
+ ink_assert(magic == MUX_VC_MAGIC_ALIVE);
EThread *my_ethread = this_ethread();
MuxClientVC *current = active_clients.head;
@@ -1556,7 +1556,7 @@ MuxVC::process_read_msg_body()
bool need_flow_control = false;
MuxClientVC *client = NULL;
- ink_debug_assert(read_msg_state == MUX_READ_MSG_BODY);
+ ink_assert(read_msg_state == MUX_READ_MSG_BODY);
int avail = read_buffer_reader->read_avail();
if (avail > 0) {
@@ -1663,7 +1663,7 @@ MuxVC::process_read_msg_body()
// If the client isn't available or has closed or shutdown reading,
// discard the input data
if (discard_read_data) {
- ink_debug_assert(need_byte_bank == false);
+ ink_assert(need_byte_bank == false);
int left_in_msg = current_msg_hdr.msg_len - read_msg_ndone;
int act_on = MIN(avail, left_in_msg);
read_buffer_reader->consume(act_on);
@@ -1672,7 +1672,7 @@ MuxVC::process_read_msg_body()
ADD_TO_BYTE_BANK:
if (need_byte_bank) {
- ink_debug_assert(discard_read_data == false);
+ ink_assert(discard_read_data == false);
// Either missed the lock or bytes sent exceeds the amount the client asked
// for. Need to store in byte until client is ready for these bytes
@@ -1728,7 +1728,7 @@ MuxVC::process_read_data()
if (read_msg_state == MUX_READ_MSG_HEADER) {
char *copy_to = ((char *) (¤t_msg_hdr)) + read_msg_ndone;
int act_on = sizeof(MuxMessage) - read_msg_ndone;
- ink_debug_assert(act_on > 0);
+ ink_assert(act_on > 0);
int res = read_buffer_reader->read(copy_to, act_on);
read_msg_ndone += res;
@@ -1917,7 +1917,7 @@ MuxVC::process_channel_inbound_shutdown(MuxClientVC * client)
EThread *my_ethread = this_ethread();
- ink_debug_assert(client->other_side_closed & MUX_OCLOSE_NEED_READ_NOTIFY);
+ ink_assert(client->other_side_closed & MUX_OCLOSE_NEED_READ_NOTIFY);
if (client->read_state.vio.mutex) {
MUTEX_TRY_LOCK(rlock, client->read_state.vio.mutex, my_ethread);
@@ -1980,7 +1980,7 @@ void
MuxVC::cleanup_on_error()
{
- ink_debug_assert(connect_state == MUX_CONNECTION_DROPPED);
+ ink_assert(connect_state == MUX_CONNECTION_DROPPED);
MuxClientVC *current = active_clients.head;
MuxClientVC *next = NULL;
@@ -2042,7 +2042,7 @@ MuxVC::state_teardown(int event, void *data)
switch (event) {
case VC_EVENT_WRITE_COMPLETE:
- ink_debug_assert(data == write_vio);
+ ink_assert(data == write_vio);
terminate_vc = true;
break;
case VC_EVENT_WRITE_READY:
@@ -2067,8 +2067,8 @@ MuxVC::state_idle(int event, void *data)
int r = EVENT_DONE;
ink_release_assert(magic == MUX_VC_MAGIC_ALIVE);
- ink_debug_assert(connect_state == MUX_CONNECTED_IDLE);
- ink_debug_assert(num_clients == 0);
+ ink_assert(connect_state == MUX_CONNECTED_IDLE);
+ ink_assert(num_clients == 0);
Debug("muxvc", "state_idle: event %d", event);
reentrancy_count++;
@@ -2077,7 +2077,7 @@ MuxVC::state_idle(int event, void *data)
case EVENT_INTERVAL:
case EVENT_IMMEDIATE:
{
- ink_debug_assert(process_event == data);
+ ink_assert(process_event == data);
process_event = NULL;
connect_state = MUX_CONNECTED_TEARDOWN;
@@ -2139,7 +2139,7 @@ MuxVC::state_handle_mux_down(int event, void *data)
switch (event) {
case EVENT_INTERVAL:
case EVENT_IMMEDIATE:
- ink_debug_assert(process_event == data);
+ ink_assert(process_event == data);
process_event = NULL;
cleanup_on_error();
break;
@@ -2168,13 +2168,13 @@ MuxVC::state_handle_mux(int event, void *data)
switch (event) {
case VC_EVENT_WRITE_COMPLETE:
// We hit INT64_MAX bytes. Reset the I/O
- ink_debug_assert(data == write_vio);
- ink_debug_assert(write_vio->ndone == INT64_MAX);
+ ink_assert(data == write_vio);
+ ink_assert(write_vio->ndone == INT64_MAX);
write_bytes_added -= write_vio->ndone;
write_vio = net_vc->do_io_write(this, INT64_MAX, write_vio->buffer.reader());
// FALL THROUGH
case VC_EVENT_WRITE_READY:
- ink_debug_assert(data == write_vio);
+ ink_assert(data == write_vio);
Debug("muxvc", "state_handle_mux: WRITE_READY, ndone: %d", write_vio->ndone);
if (writes_blocked) {
@@ -2184,11 +2184,11 @@ MuxVC::state_handle_mux(int event, void *data)
break;
case VC_EVENT_READ_COMPLETE:
// We hit INT64_MAX bytes. Reset the I/O
- ink_debug_assert(data == read_vio);
+ ink_assert(data == read_vio);
read_vio = net_vc->do_io_read(this, INT64_MAX, read_buffer);
// FALL THROUGH
case VC_EVENT_READ_READY:
- ink_debug_assert(data == read_vio);
+ ink_assert(data == read_vio);
/*Debug("muxvc", "state_handle_mux: READ_READY, ndone: %d, "
"avail %d, high_water %d",
read_vio->ndone,
@@ -2205,7 +2205,7 @@ MuxVC::state_handle_mux(int event, void *data)
read_buffer_reader->read_avail(),
read_buffer->max_read_avail(),
(int) read_buffer->high_water()); */
- ink_debug_assert(process_event == data);
+ ink_assert(process_event == data);
process_event = NULL;
process_clients();
read_vio->reenable();
@@ -2401,7 +2401,7 @@ return_action(), mux_action(NULL), mux_vc(NULL), retry_event(NULL), ip(0), port(
MuxGetCont::~MuxGetCont()
{
- ink_debug_assert(mux_action == NULL);
+ ink_assert(mux_action == NULL);
if (retry_event) {
retry_event->cancel();
@@ -2460,15 +2460,15 @@ MuxGetCont::lock_miss_handler(int event, void *data)
Event *call_event = (Event *) data;
ink_release_assert(event == EVENT_INTERVAL);
- ink_debug_assert(retry_event == call_event);
- ink_debug_assert(this->mutex.m_ptr == return_action.mutex.m_ptr);
+ ink_assert(retry_event == call_event);
+ ink_assert(this->mutex.m_ptr == return_action.mutex.m_ptr);
retry_event = NULL;
// Note, we've already got the continuation's mutex
// since we set our mutex to it's mutex
if (return_action.cancelled) {
- ink_debug_assert(mux_action == NULL);
+ ink_assert(mux_action == NULL);
retry_event = NULL;
delete this;
return EVENT_DONE;
@@ -2514,7 +2514,7 @@ MuxGetCont::new_mux_handler(int event, void *data)
switch (event) {
case MUX_EVENT_OPEN:
{
- ink_debug_assert(mux_vc->connect_state == MUX_CONNECTED_ACTIVE);
+ ink_assert(mux_vc->connect_state == MUX_CONNECTED_ACTIVE);
Debug("mux_open", "[MuxGetCont::main_handler sending] adding to mux list");
@@ -2737,7 +2737,7 @@ int
MuxPagesHandler::handle_mux_details(int event, void *data)
{
- ink_debug_assert(event == EVENT_IMMEDIATE || event == EVENT_INTERVAL);
+ ink_assert(event == EVENT_IMMEDIATE || event == EVENT_INTERVAL);
Event *call_event = (Event *) data;
int32_t mux_id = extract_id(request);
@@ -2790,7 +2790,7 @@ int
MuxPagesHandler::handle_muxvc_list(int event, void *data)
{
- ink_debug_assert(event == EVENT_IMMEDIATE || event == EVENT_INTERVAL);
+ ink_assert(event == EVENT_IMMEDIATE || event == EVENT_INTERVAL);
Event *call_event = (Event *) data;
MUTEX_TRY_LOCK(lock, muxProcessor.list_mutex, call_event->ethread);
@@ -2983,7 +2983,7 @@ MUXTestDriver::start_next_test()
Debug("mux_test", "Starting test %s", netvc_tests_def[next_index].test_name);
completions_received = 0;
- ink_debug_assert(pending_action == NULL);
+ ink_assert(pending_action == NULL);
Action *tmp = muxProcessor.get_mux_re(this, inet_addr("127.0.0.1"), 9555);
if (tmp != ACTION_RESULT_DONE) {
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/PluginVC.cc
----------------------------------------------------------------------
diff --git a/proxy/PluginVC.cc b/proxy/PluginVC.cc
index c1debab..5c56200 100644
--- a/proxy/PluginVC.cc
+++ b/proxy/PluginVC.cc
@@ -111,8 +111,8 @@ PluginVC::main_handler(int event, void *data)
ink_release_assert(event == EVENT_INTERVAL || event == EVENT_IMMEDIATE);
ink_release_assert(magic == PLUGIN_VC_MAGIC_ALIVE);
- ink_debug_assert(!deletable);
- ink_debug_assert(data != NULL);
+ ink_assert(!deletable);
+ ink_assert(data != NULL);
Event *call_event = (Event *) data;
EThread *my_ethread = mutex->thread_holding;
@@ -288,7 +288,7 @@ PluginVC::reenable(VIO * vio)
ink_assert(!closed);
ink_assert(magic == PLUGIN_VC_MAGIC_ALIVE);
- ink_debug_assert(vio->mutex->thread_holding == this_ethread());
+ ink_assert(vio->mutex->thread_holding == this_ethread());
Debug("pvc", "[%u] %s: reenable %s", PVC_ID, PVC_TYPE, (vio->op == VIO::WRITE) ? "Write" : "Read");
@@ -309,7 +309,7 @@ PluginVC::reenable_re(VIO * vio)
ink_assert(!closed);
ink_assert(magic == PLUGIN_VC_MAGIC_ALIVE);
- ink_debug_assert(vio->mutex->thread_holding == this_ethread());
+ ink_assert(vio->mutex->thread_holding == this_ethread());
Debug("pvc", "[%u] %s: reenable_re %s", PVC_ID, PVC_TYPE, (vio->op == VIO::WRITE) ? "Write" : "Read");
@@ -420,7 +420,7 @@ PluginVC::transfer_bytes(MIOBuffer * transfer_to, IOBufferReader * transfer_from
int64_t total_added = 0;
- ink_debug_assert(act_on <= transfer_from->read_avail());
+ ink_assert(act_on <= transfer_from->read_avail());
while (act_on > 0) {
int64_t block_read_avail = transfer_from->block_read_avail();
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/Prefetch.cc
----------------------------------------------------------------------
diff --git a/proxy/Prefetch.cc b/proxy/Prefetch.cc
index 547898c..c8ee72c 100644
--- a/proxy/Prefetch.cc
+++ b/proxy/Prefetch.cc
@@ -243,7 +243,7 @@ normalize_url(char *url, int *len)
while (dir[0] == 0 && dir > root)
dir--;
- ink_debug_assert(dir[0] == '/');
+ ink_assert(dir[0] == '/');
if (dir > root && dir[0] == '/') {
do {
dir[0] = 0;
@@ -1567,7 +1567,7 @@ copy_header(MIOBuffer *buf, HTTPHdr *hdr, const char *hdr_tail)
done = hdr->print(buf->end(), block_len, &index, &temp);
- ink_debug_assert(done || index == block_len);
+ ink_assert(done || index == block_len);
offset += index;
@@ -1575,7 +1575,7 @@ copy_header(MIOBuffer *buf, HTTPHdr *hdr, const char *hdr_tail)
buf->fill(index);
buf->add_block();
} else {
- ink_debug_assert(index >= 2);
+ ink_assert(index >= 2);
if (hdr_tail && index >= 2) {
/*This is a hack to be able to send headers beginning with @ */
int len = strlen(hdr_tail);
@@ -2248,7 +2248,7 @@ KeepAliveConn::handleEvent(int event, void *data)
break;
default:
- ink_debug_assert(!"not reached");
+ ink_assert(!"not reached");
free();
}
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/Update.cc
----------------------------------------------------------------------
diff --git a/proxy/Update.cc b/proxy/Update.cc
index fb7d089..967377a 100644
--- a/proxy/Update.cc
+++ b/proxy/Update.cc
@@ -2533,7 +2533,7 @@ ObjectReloadCont::Init(Continuation * cont, char *url, int url_len,
} else {
// Unhandled case... TODO: Do we need to actually handle this?
- ink_debug_assert(false);
+ ink_assert(false);
}
handleEvent(EVENT_IMMEDIATE, (void *) NULL);
}
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/hdrs/HTTP.cc
----------------------------------------------------------------------
diff --git a/proxy/hdrs/HTTP.cc b/proxy/hdrs/HTTP.cc
index 3b783b8..2def411 100644
--- a/proxy/hdrs/HTTP.cc
+++ b/proxy/hdrs/HTTP.cc
@@ -385,8 +385,8 @@ http_hdr_clone(HTTPHdrImpl *s_hh, HdrHeap *s_heap, HdrHeap *d_heap)
static inline char *
http_hdr_version_to_string(int32_t version, char *buf9)
{
- ink_debug_assert(HTTP_MAJOR(version) < 10);
- ink_debug_assert(HTTP_MINOR(version) < 10);
+ ink_assert(HTTP_MAJOR(version) < 10);
+ ink_assert(HTTP_MINOR(version) < 10);
buf9[0] = 'H';
buf9[1] = 'T';
@@ -429,7 +429,7 @@ http_hdr_print(HdrHeap *heap, HTTPHdrImpl *hdr, char *buf, int bufsize, int *buf
char tmpbuf[32];
char *p;
- ink_debug_assert((hdr->m_polarity == HTTP_TYPE_REQUEST) || (hdr->m_polarity == HTTP_TYPE_RESPONSE));
+ ink_assert((hdr->m_polarity == HTTP_TYPE_REQUEST) || (hdr->m_polarity == HTTP_TYPE_RESPONSE));
if (hdr->m_polarity == HTTP_TYPE_REQUEST) {
@@ -512,7 +512,7 @@ http_hdr_print(HdrHeap *heap, HTTPHdrImpl *hdr, char *buf, int bufsize, int *buf
tmplen = 3;
} else {
tmplen = mime_format_int(p, hdrstat, (bufsize - (p - buf)));
- ink_debug_assert(tmplen <= 6);
+ ink_assert(tmplen <= 6);
p += tmplen;
}
*p++ = ' ';
@@ -669,7 +669,7 @@ http_hdr_method_get(HTTPHdrImpl *hh, int *length)
{
const char *str;
- ink_debug_assert(hh->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(hh->m_polarity == HTTP_TYPE_REQUEST);
if (hh->u.req.m_method_wks_idx >= 0) {
str = hdrtoken_index_to_wks(hh->u.req.m_method_wks_idx);
@@ -689,7 +689,7 @@ void
http_hdr_method_set(HdrHeap *heap, HTTPHdrImpl *hh, const char *method, int16_t method_wks_idx, int method_length,
bool must_copy)
{
- ink_debug_assert(hh->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(hh->m_polarity == HTTP_TYPE_REQUEST);
hh->u.req.m_method_wks_idx = method_wks_idx;
mime_str_u16_set(heap, method, method_length, &(hh->u.req.m_ptr_method), &(hh->u.req.m_len_method), must_copy);
@@ -701,7 +701,7 @@ http_hdr_method_set(HdrHeap *heap, HTTPHdrImpl *hh, const char *method, int16_t
void
http_hdr_url_set(HdrHeap *heap, HTTPHdrImpl *hh, URLImpl *url)
{
- ink_debug_assert(hh->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(hh->m_polarity == HTTP_TYPE_REQUEST);
if (hh->u.req.m_url_impl != url) {
if (hh->u.req.m_url_impl != NULL) {
heap->deallocate_obj(hh->u.req.m_url_impl);
@@ -717,7 +717,7 @@ http_hdr_url_set(HdrHeap *heap, HTTPHdrImpl *hh, URLImpl *url)
void
http_hdr_status_set(HTTPHdrImpl *hh, HTTPStatus status)
{
- ink_debug_assert(hh->m_polarity == HTTP_TYPE_RESPONSE);
+ ink_assert(hh->m_polarity == HTTP_TYPE_RESPONSE);
hh->u.resp.m_status = status;
}
@@ -727,7 +727,7 @@ http_hdr_status_set(HTTPHdrImpl *hh, HTTPStatus status)
const char *
http_hdr_reason_get(HTTPHdrImpl *hh, int *length)
{
- ink_debug_assert(hh->m_polarity == HTTP_TYPE_RESPONSE);
+ ink_assert(hh->m_polarity == HTTP_TYPE_RESPONSE);
*length = hh->u.resp.m_len_reason;
return (hh->u.resp.m_ptr_reason);
}
@@ -738,7 +738,7 @@ http_hdr_reason_get(HTTPHdrImpl *hh, int *length)
void
http_hdr_reason_set(HdrHeap *heap, HTTPHdrImpl *hh, const char *value, int length, bool must_copy)
{
- ink_debug_assert(hh->m_polarity == HTTP_TYPE_RESPONSE);
+ ink_assert(hh->m_polarity == HTTP_TYPE_RESPONSE);
mime_str_u16_set(heap, value, length, &(hh->u.resp.m_ptr_reason), &(hh->u.resp.m_len_reason), must_copy);
}
@@ -939,7 +939,7 @@ http_parser_parse_req(HTTPParser *parser, HdrHeap *heap, HTTPHdrImpl *hh, const
int32_t version = HTTP_VERSION(end[-5] - '0', end[-3] - '0');
http_hdr_method_set(heap, hh, &(cur[0]), hdrtoken_wks_to_index(HTTP_METHOD_GET), 3, must_copy_strings);
- ink_debug_assert(hh->u.req.m_url_impl != NULL);
+ ink_assert(hh->u.req.m_url_impl != NULL);
url = hh->u.req.m_url_impl;
url_start = &(cur[4]);
err =::url_parse(heap, url, &url_start, &(end[-11]), must_copy_strings);
@@ -1064,7 +1064,7 @@ http_parser_parse_req(HTTPParser *parser, HdrHeap *heap, HTTPHdrImpl *hh, const
if (!url_start || !url_end)
return PARSE_ERROR;
- ink_debug_assert(hh->u.req.m_url_impl != NULL);
+ ink_assert(hh->u.req.m_url_impl != NULL);
url = hh->u.req.m_url_impl;
err =::url_parse(heap, url, &url_start, url_end, must_copy_strings);
@@ -1790,10 +1790,10 @@ HTTPInfo::marshal(char *buf, int len)
// marshalled along with the alt struct.
int frag_len = (0 == m_alt->m_frag_offset_count || m_alt->m_frag_offsets == m_alt->m_integral_frag_offsets) ? 0 : sizeof(HTTPCacheAlt::FragOffset) * m_alt->m_frag_offset_count;
- ink_debug_assert(m_alt->m_magic == CACHE_ALT_MAGIC_ALIVE);
+ ink_assert(m_alt->m_magic == CACHE_ALT_MAGIC_ALIVE);
// Make sure the buffer is aligned
-// ink_debug_assert(((intptr_t)buf) & 0x3 == 0);
+// ink_assert(((intptr_t)buf) & 0x3 == 0);
// If we have external fragment offsets, copy the initial ones
// into the integral data.
@@ -2039,7 +2039,7 @@ HTTPInfo::get_handle(char *buf, int len)
void
HTTPInfo::push_frag_offset(FragOffset offset) {
- ink_debug_assert(m_alt);
+ ink_assert(m_alt);
if (0 == m_alt->m_frag_offsets) {
m_alt->m_frag_offsets = m_alt->m_integral_frag_offsets;
} else if (m_alt->m_frag_offset_count >= HTTPCacheAlt::N_INTEGRAL_FRAG_OFFSETS && 0 == (m_alt->m_frag_offset_count & (m_alt->m_frag_offset_count-1))) {
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/hdrs/HTTP.h
----------------------------------------------------------------------
diff --git a/proxy/hdrs/HTTP.h b/proxy/hdrs/HTTP.h
index 1323d8a..553317e 100644
--- a/proxy/hdrs/HTTP.h
+++ b/proxy/hdrs/HTTP.h
@@ -845,7 +845,7 @@ HTTPHdr::reset()
inline void
HTTPHdr::copy(const HTTPHdr *hdr)
{
- ink_debug_assert(hdr->valid());
+ ink_assert(hdr->valid());
if (valid()) {
http_hdr_copy_onto(hdr->m_http, hdr->m_heap, m_http, m_heap, (m_heap != hdr->m_heap) ? true : false);
@@ -862,7 +862,7 @@ HTTPHdr::copy(const HTTPHdr *hdr)
inline void
HTTPHdr::copy_shallow(const HTTPHdr *hdr)
{
- ink_debug_assert(hdr->valid());
+ ink_assert(hdr->valid());
m_heap = hdr->m_heap;
m_http = hdr->m_http;
@@ -878,7 +878,7 @@ HTTPHdr::copy_shallow(const HTTPHdr *hdr)
inline int
HTTPHdr::print(char *buf, int bufsize, int *bufindex, int *dumpoffset)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return http_hdr_print(m_heap, m_http, buf, bufsize, bufindex, dumpoffset);
}
@@ -888,7 +888,7 @@ HTTPHdr::print(char *buf, int bufsize, int *bufindex, int *dumpoffset)
inline int
HTTPHdr::length_get()
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return http_hdr_length_get(m_http);
}
@@ -971,7 +971,7 @@ http_hdr_type_get(HTTPHdrImpl *hh)
inline HTTPType
HTTPHdr::type_get() const
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return http_hdr_type_get(m_http);
}
@@ -990,7 +990,7 @@ http_hdr_version_get(HTTPHdrImpl *hh)
inline HTTPVersion
HTTPHdr::version_get()
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return HTTPVersion(http_hdr_version_get(m_http));
}
@@ -1000,7 +1000,7 @@ HTTPHdr::version_get()
inline void
HTTPHdr::version_set(HTTPVersion version)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
http_hdr_version_set(m_http, version.m_version);
}
@@ -1010,8 +1010,8 @@ HTTPHdr::version_set(HTTPVersion version)
inline const char *
HTTPHdr::method_get(int *length)
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
return http_hdr_method_get(m_http, length);
}
@@ -1020,8 +1020,8 @@ HTTPHdr::method_get(int *length)
inline int
HTTPHdr::method_get_wksidx()
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
return (m_http->u.req.m_method_wks_idx);
}
@@ -1033,8 +1033,8 @@ HTTPHdr::method_get_wksidx()
inline void
HTTPHdr::method_set(const char *value, int length)
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
int method_wks_idx = hdrtoken_tokenize(value, length);
http_hdr_method_set(m_heap, m_http, value, method_wks_idx, length, true);
@@ -1046,8 +1046,8 @@ HTTPHdr::method_set(const char *value, int length)
inline URL *
HTTPHdr::url_create(URL *u)
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
u->set(this);
u->create(m_heap);
@@ -1060,8 +1060,8 @@ HTTPHdr::url_create(URL *u)
inline URL *
HTTPHdr::url_get() const
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
// It's entirely possible that someone changed URL in our impl
// without updating the cached copy in the C++ layer. Check
@@ -1082,8 +1082,8 @@ HTTPHdr::url_get() const
inline URL *
HTTPHdr::url_get(URL *url)
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
url->set(this); // attach refcount
url->m_url_impl = m_http->u.req.m_url_impl;
@@ -1096,8 +1096,8 @@ HTTPHdr::url_get(URL *url)
inline void
HTTPHdr::url_set(URL *url)
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
URLImpl *url_impl = m_http->u.req.m_url_impl;
::url_copy_onto(url->m_url_impl, url->m_heap, url_impl, m_heap, true);
@@ -1109,8 +1109,8 @@ HTTPHdr::url_set(URL *url)
inline void
HTTPHdr::url_set_as_server_url(URL *url)
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
URLImpl *url_impl = m_http->u.req.m_url_impl;
::url_copy_onto_as_server_url(url->m_url_impl, url->m_heap, url_impl, m_heap, true);
@@ -1124,8 +1124,8 @@ HTTPHdr::url_set(const char *str, int length)
{
URLImpl *url_impl;
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
url_impl = m_http->u.req.m_url_impl;
::url_clear(url_impl);
@@ -1138,7 +1138,7 @@ HTTPHdr::url_set(const char *str, int length)
inline HTTPStatus
http_hdr_status_get(HTTPHdrImpl *hh)
{
- ink_debug_assert(hh->m_polarity == HTTP_TYPE_RESPONSE);
+ ink_assert(hh->m_polarity == HTTP_TYPE_RESPONSE);
return (HTTPStatus) hh->u.resp.m_status;
}
@@ -1148,8 +1148,8 @@ http_hdr_status_get(HTTPHdrImpl *hh)
inline HTTPStatus
HTTPHdr::status_get()
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_RESPONSE);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_RESPONSE);
return (NULL == m_http) ? HTTP_STATUS_NONE : http_hdr_status_get(m_http);
}
@@ -1160,8 +1160,8 @@ HTTPHdr::status_get()
inline void
HTTPHdr::status_set(HTTPStatus status)
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_RESPONSE);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_RESPONSE);
http_hdr_status_set(m_http, status);
}
@@ -1172,8 +1172,8 @@ HTTPHdr::status_set(HTTPStatus status)
inline const char *
HTTPHdr::reason_get(int *length)
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_RESPONSE);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_RESPONSE);
return http_hdr_reason_get(m_http, length);
}
@@ -1184,8 +1184,8 @@ HTTPHdr::reason_get(int *length)
inline void
HTTPHdr::reason_set(const char *value, int length)
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_RESPONSE);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_RESPONSE);
http_hdr_reason_set(m_heap, m_http, value, length, true);
}
@@ -1196,8 +1196,8 @@ HTTPHdr::reason_set(const char *value, int length)
inline MIMEParseResult
HTTPHdr::parse_req(HTTPParser *parser, const char **start, const char *end, bool eof)
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
return http_parser_parse_req(parser, m_heap, m_http, start, end, true, eof);
}
@@ -1208,8 +1208,8 @@ HTTPHdr::parse_req(HTTPParser *parser, const char **start, const char *end, bool
inline MIMEParseResult
HTTPHdr::parse_resp(HTTPParser *parser, const char **start, const char *end, bool eof)
{
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_RESPONSE);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_RESPONSE);
return http_parser_parse_resp(parser, m_heap, m_http, start, end, true, eof);
}
@@ -1220,11 +1220,11 @@ HTTPHdr::parse_resp(HTTPParser *parser, const char **start, const char *end, boo
inline bool
HTTPHdr::is_cache_control_set(const char *cc_directive_wks)
{
- ink_debug_assert(valid());
- ink_debug_assert(hdrtoken_is_wks(cc_directive_wks));
+ ink_assert(valid());
+ ink_assert(hdrtoken_is_wks(cc_directive_wks));
HdrTokenHeapPrefix *prefix = hdrtoken_wks_to_prefix(cc_directive_wks);
- ink_debug_assert(prefix->wks_token_type == HDRTOKEN_TYPE_CACHE_CONTROL);
+ ink_assert(prefix->wks_token_type == HDRTOKEN_TYPE_CACHE_CONTROL);
uint32_t cc_mask = prefix->wks_type_specific.u.cache_control.cc_mask;
if (get_cooked_cc_mask() & cc_mask)
@@ -1239,7 +1239,7 @@ HTTPHdr::is_cache_control_set(const char *cc_directive_wks)
inline bool
HTTPHdr::is_pragma_no_cache_set()
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return (get_cooked_pragma_no_cache());
}
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/hdrs/HdrHeap.h
----------------------------------------------------------------------
diff --git a/proxy/hdrs/HdrHeap.h b/proxy/hdrs/HdrHeap.h
index cb1d552..787d99a 100644
--- a/proxy/hdrs/HdrHeap.h
+++ b/proxy/hdrs/HdrHeap.h
@@ -106,7 +106,7 @@ obj_copy_data(HdrHeapObjImpl * s_obj, HdrHeapObjImpl * d_obj)
{
char *src, *dst;
- ink_debug_assert((s_obj->m_length == d_obj->m_length) && (s_obj->m_type == d_obj->m_type));
+ ink_assert((s_obj->m_length == d_obj->m_length) && (s_obj->m_type == d_obj->m_type));
int hdr_length = sizeof(HdrHeapObjImpl);
src = (char *) s_obj + hdr_length;
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/hdrs/HdrTSOnly.cc
----------------------------------------------------------------------
diff --git a/proxy/hdrs/HdrTSOnly.cc b/proxy/hdrs/HdrTSOnly.cc
index c6e13e0..ae7ae13 100644
--- a/proxy/hdrs/HdrTSOnly.cc
+++ b/proxy/hdrs/HdrTSOnly.cc
@@ -53,8 +53,8 @@ HTTPHdr::parse_req(HTTPParser * parser, IOBufferReader * r, int *bytes_used, boo
const char *end;
int used;
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_REQUEST);
MIMEParseResult state = PARSE_CONT;
*bytes_used = 0;
@@ -94,8 +94,8 @@ HTTPHdr::parse_resp(HTTPParser * parser, IOBufferReader * r, int *bytes_used, bo
const char *end;
int used;
- ink_debug_assert(valid());
- ink_debug_assert(m_http->m_polarity == HTTP_TYPE_RESPONSE);
+ ink_assert(valid());
+ ink_assert(m_http->m_polarity == HTTP_TYPE_RESPONSE);
MIMEParseResult state = PARSE_CONT;
*bytes_used = 0;
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/hdrs/HdrToken.cc
----------------------------------------------------------------------
diff --git a/proxy/hdrs/HdrToken.cc b/proxy/hdrs/HdrToken.cc
index 6adf950..4374d85 100644
--- a/proxy/hdrs/HdrToken.cc
+++ b/proxy/hdrs/HdrToken.cc
@@ -629,7 +629,7 @@ hdrtoken_init()
wks_idx = hdrtoken_tokenize_dfa(_hdrtoken_strs_type_initializers[i].name,
(int) strlen(_hdrtoken_strs_type_initializers[i].name));
- ink_debug_assert((wks_idx >= 0) && (wks_idx < (int) SIZEOF(hdrtoken_strs)));
+ ink_assert((wks_idx >= 0) && (wks_idx < (int) SIZEOF(hdrtoken_strs)));
// coverity[negative_returns]
prefix = hdrtoken_index_to_prefix(wks_idx);
prefix->wks_token_type = _hdrtoken_strs_type_initializers[i].type;
@@ -643,7 +643,7 @@ hdrtoken_init()
wks_idx = hdrtoken_tokenize_dfa(_hdrtoken_strs_field_initializers[i].name,
(int) strlen(_hdrtoken_strs_field_initializers[i].name));
- ink_debug_assert((wks_idx >= 0) && (wks_idx < (int) SIZEOF(hdrtoken_strs)));
+ ink_assert((wks_idx >= 0) && (wks_idx < (int) SIZEOF(hdrtoken_strs)));
prefix = hdrtoken_index_to_prefix(wks_idx);
prefix->wks_info.slotid = _hdrtoken_strs_field_initializers[i].slotid;
prefix->wks_info.flags = _hdrtoken_strs_field_initializers[i].flags;
@@ -695,7 +695,7 @@ hdrtoken_tokenize(const char *string, int string_len, const char **wks_string_ou
int wks_idx;
HdrTokenHashBucket *bucket;
- ink_debug_assert(string != NULL);
+ ink_assert(string != NULL);
if (hdrtoken_is_wks(string)) {
wks_idx = hdrtoken_wks_to_index(string);
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/hdrs/HdrToken.h
----------------------------------------------------------------------
diff --git a/proxy/hdrs/HdrToken.h b/proxy/hdrs/HdrToken.h
index c46cfdb..ad00004 100644
--- a/proxy/hdrs/HdrToken.h
+++ b/proxy/hdrs/HdrToken.h
@@ -150,7 +150,7 @@ hdrtoken_is_valid_wks_idx(int wks_idx)
inline HdrTokenHeapPrefix *
hdrtoken_wks_to_prefix(const char *wks)
{
- ink_debug_assert(hdrtoken_is_wks(wks));
+ ink_assert(hdrtoken_is_wks(wks));
return ((HdrTokenHeapPrefix *) (wks - sizeof(HdrTokenHeapPrefix)));
}
@@ -160,49 +160,49 @@ hdrtoken_wks_to_prefix(const char *wks)
inline const char *
hdrtoken_index_to_wks(int wks_idx)
{
- ink_debug_assert(hdrtoken_is_valid_wks_idx(wks_idx));
+ ink_assert(hdrtoken_is_valid_wks_idx(wks_idx));
return hdrtoken_strs[wks_idx];
}
inline int
hdrtoken_index_to_length(int wks_idx)
{
- ink_debug_assert(hdrtoken_is_valid_wks_idx(wks_idx));
+ ink_assert(hdrtoken_is_valid_wks_idx(wks_idx));
return hdrtoken_str_lengths[wks_idx];
}
inline HdrTokenType
hdrtoken_index_to_token_type(int wks_idx)
{
- ink_debug_assert(hdrtoken_is_valid_wks_idx(wks_idx));
+ ink_assert(hdrtoken_is_valid_wks_idx(wks_idx));
return hdrtoken_str_token_types[wks_idx];
}
inline int
hdrtoken_index_to_slotid(int wks_idx)
{
- ink_debug_assert(hdrtoken_is_valid_wks_idx(wks_idx));
+ ink_assert(hdrtoken_is_valid_wks_idx(wks_idx));
return hdrtoken_str_slotids[wks_idx];
}
inline uint64_t
hdrtoken_index_to_mask(int wks_idx)
{
- ink_debug_assert(hdrtoken_is_valid_wks_idx(wks_idx));
+ ink_assert(hdrtoken_is_valid_wks_idx(wks_idx));
return hdrtoken_str_masks[wks_idx];
}
inline int
hdrtoken_index_to_flags(int wks_idx)
{
- ink_debug_assert(hdrtoken_is_valid_wks_idx(wks_idx));
+ ink_assert(hdrtoken_is_valid_wks_idx(wks_idx));
return hdrtoken_str_flags[wks_idx];
}
inline HdrTokenHeapPrefix *
hdrtoken_index_to_prefix(int wks_idx)
{
- ink_debug_assert(hdrtoken_is_valid_wks_idx(wks_idx));
+ ink_assert(hdrtoken_is_valid_wks_idx(wks_idx));
return hdrtoken_wks_to_prefix(hdrtoken_index_to_wks(wks_idx));
}
@@ -212,35 +212,35 @@ hdrtoken_index_to_prefix(int wks_idx)
inline int
hdrtoken_wks_to_index(const char *wks)
{
- ink_debug_assert(hdrtoken_is_wks(wks));
+ ink_assert(hdrtoken_is_wks(wks));
return hdrtoken_wks_to_prefix(wks)->wks_idx;
}
inline int
hdrtoken_wks_to_length(const char *wks)
{
- ink_debug_assert(hdrtoken_is_wks(wks));
+ ink_assert(hdrtoken_is_wks(wks));
return hdrtoken_wks_to_prefix(wks)->wks_length;
}
inline int
hdrtoken_wks_to_token_type(const char *wks)
{
- ink_debug_assert(hdrtoken_is_wks(wks));
+ ink_assert(hdrtoken_is_wks(wks));
return hdrtoken_wks_to_prefix(wks)->wks_token_type;
}
inline int
hdrtoken_wks_to_slotid(const char *wks)
{
- ink_debug_assert(hdrtoken_is_wks(wks));
+ ink_assert(hdrtoken_is_wks(wks));
return hdrtoken_wks_to_prefix(wks)->wks_info.slotid;
}
inline uint64_t
hdrtoken_wks_to_mask(const char *wks)
{
- ink_debug_assert(hdrtoken_is_wks(wks));
+ ink_assert(hdrtoken_is_wks(wks));
HdrTokenHeapPrefix *prefix = hdrtoken_wks_to_prefix(wks);
return prefix->wks_info.mask;
}
@@ -248,7 +248,7 @@ hdrtoken_wks_to_mask(const char *wks)
inline int
hdrtoken_wks_to_flags(const char *wks)
{
- ink_debug_assert(hdrtoken_is_wks(wks));
+ ink_assert(hdrtoken_is_wks(wks));
return hdrtoken_wks_to_prefix(wks)->wks_info.flags;
}
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/hdrs/HdrUtils.cc
----------------------------------------------------------------------
diff --git a/proxy/hdrs/HdrUtils.cc b/proxy/hdrs/HdrUtils.cc
index f4ed433..eebae40 100644
--- a/proxy/hdrs/HdrUtils.cc
+++ b/proxy/hdrs/HdrUtils.cc
@@ -64,7 +64,7 @@ skip_leading_whitespace:
}
csv_start = cur;
parse_value:
- // ink_debug_assert((',' > '"') && (',' > ' ') && (',' > '\t'));
+ // ink_assert((',' > '"') && (',' > ' ') && (',' > '\t'));
// Cookie/Set-Cookie use ';' as the separator
if (m_separator == ',')
while ((cur<end - 1) && (*cur> ',')) {
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/hdrs/MIME.cc
----------------------------------------------------------------------
diff --git a/proxy/hdrs/MIME.cc b/proxy/hdrs/MIME.cc
index 979747c..bb89402 100644
--- a/proxy/hdrs/MIME.cc
+++ b/proxy/hdrs/MIME.cc
@@ -426,7 +426,7 @@ mime_hdr_presence_unset(MIMEHdrImpl *h, int well_known_str_index)
inline uint32_t
mime_hdr_get_accelerator_slotnum(MIMEHdrImpl *mh, int32_t slot_id)
{
- ink_debug_assert((slot_id != MIME_SLOTID_NONE) && (slot_id < 32));
+ ink_assert((slot_id != MIME_SLOTID_NONE) && (slot_id < 32));
uint32_t word_index = slot_id / 8; // 4 words of 8 slots
uint32_t word = mh->m_slot_accelerators[word_index]; // 8 slots of 4 bits each
@@ -438,8 +438,8 @@ mime_hdr_get_accelerator_slotnum(MIMEHdrImpl *mh, int32_t slot_id)
inline void
mime_hdr_set_accelerator_slotnum(MIMEHdrImpl *mh, int32_t slot_id, uint32_t slot_num)
{
- ink_debug_assert((slot_id != MIME_SLOTID_NONE) && (slot_id < 32));
- ink_debug_assert(slot_num < 16);
+ ink_assert((slot_id != MIME_SLOTID_NONE) && (slot_id < 32));
+ ink_assert(slot_num < 16);
uint32_t word_index = slot_id / 8; // 4 words of 8 slots
uint32_t word = mh->m_slot_accelerators[word_index]; // 8 slots of 4 bits each
@@ -1044,7 +1044,7 @@ mime_hdr_copy_onto(MIMEHdrImpl *s_mh, HdrHeap *s_heap, MIMEHdrImpl *d_mh, HdrHea
mime_hdr_destroy_field_block_list(d_heap, d_mh->m_first_fblock.m_next);
}
- ink_debug_assert(((char *) &(s_mh->m_first_fblock.m_field_slots[MIME_FIELD_BLOCK_SLOTS]) - (char *) s_mh) ==
+ ink_assert(((char *) &(s_mh->m_first_fblock.m_field_slots[MIME_FIELD_BLOCK_SLOTS]) - (char *) s_mh) ==
sizeof(struct MIMEHdrImpl));
int top = s_mh->m_first_fblock.m_freetop;
@@ -1159,7 +1159,7 @@ _mime_hdr_field_list_search_by_wks(MIMEHdrImpl *mh, int wks_idx)
MIMEFieldBlockImpl *fblock;
MIMEField *field, *too_far_field;
- ink_debug_assert(hdrtoken_is_valid_wks_idx(wks_idx));
+ ink_assert(hdrtoken_is_valid_wks_idx(wks_idx));
for (fblock = &(mh->m_first_fblock); fblock != NULL; fblock = fblock->m_next) {
field = &(fblock->m_field_slots[0]);
@@ -1233,7 +1233,7 @@ mime_hdr_field_find(MIMEHdrImpl *mh, const char *field_name_str, int field_name_
int is_wks;
HdrTokenHeapPrefix *token_info;
- ink_debug_assert(field_name_len >= 0);
+ ink_assert(field_name_len >= 0);
////////////////////////////////////////////
// do presence check and slot accelerator //
@@ -1261,7 +1261,7 @@ mime_hdr_field_find(MIMEHdrImpl *mh, const char *field_name_str, int field_name_
if (slotnum != MIME_FIELD_SLOTNUM_UNKNOWN) {
MIMEField *f = _mime_hdr_field_list_search_by_slotnum(mh, slotnum);
- ink_debug_assert((f == NULL) || f->is_live());
+ ink_assert((f == NULL) || f->is_live());
#if TRACK_FIELD_FIND_CALLS
Debug("http", "mime_hdr_field_find(hdr 0x%X, field %.*s): %s (due to slot accelerators)\n",
mh, field_name_len, field_name_str, (f ? "HIT" : "MISS"));
@@ -1281,7 +1281,7 @@ mime_hdr_field_find(MIMEHdrImpl *mh, const char *field_name_str, int field_name_
if (is_wks) {
MIMEField *f = _mime_hdr_field_list_search_by_wks(mh, token_info->wks_idx);
- ink_debug_assert((f == NULL) || f->is_live());
+ ink_assert((f == NULL) || f->is_live());
#if TRACK_FIELD_FIND_CALLS
Debug("http", "mime_hdr_field_find(hdr 0x%X, field %.*s): %s (due to WKS list walk)\n",
mh, field_name_len, field_name_str, (f ? "HIT" : "MISS"));
@@ -1290,7 +1290,7 @@ mime_hdr_field_find(MIMEHdrImpl *mh, const char *field_name_str, int field_name_
} else {
MIMEField *f = _mime_hdr_field_list_search_by_string(mh, field_name_str, field_name_len);
- ink_debug_assert((f == NULL) || f->is_live());
+ ink_assert((f == NULL) || f->is_live());
#if TRACK_FIELD_FIND_CALLS
Debug("http", "mime_hdr_field_find(hdr 0x%X, field %.*s): %s (due to strcmp list walk)\n",
mh, field_name_len, field_name_str, (f ? "HIT" : "MISS"));
@@ -1398,7 +1398,7 @@ mime_hdr_field_attach(MIMEHdrImpl *mh, MIMEField *field, int check_for_dups, MIM
if (field->m_readiness != MIME_FIELD_SLOT_READINESS_DETACHED)
return;
- ink_debug_assert(field->m_ptr_name != NULL);
+ ink_assert(field->m_ptr_name != NULL);
//////////////////////////////////////////////////
// if we don't know the head dup, or are given //
@@ -1409,7 +1409,7 @@ mime_hdr_field_attach(MIMEHdrImpl *mh, MIMEField *field, int check_for_dups, MIM
int length;
const char *name = mime_field_name_get(field, &length);
prev_dup = mime_hdr_field_find(mh, name, length);
- ink_debug_assert((prev_dup == NULL) || (prev_dup->is_dup_head()));
+ ink_assert((prev_dup == NULL) || (prev_dup->is_dup_head()));
}
field->m_readiness = MIME_FIELD_SLOT_READINESS_LIVE;
@@ -1436,7 +1436,7 @@ mime_hdr_field_attach(MIMEHdrImpl *mh, MIMEField *field, int check_for_dups, MIM
next_dup = prev_dup->m_next_dup;
next_slotnum = (next_dup ? mime_hdr_field_slotnum(mh, next_dup) : -1);
- ink_debug_assert(field_slotnum != prev_slotnum);
+ ink_assert(field_slotnum != prev_slotnum);
while (prev_slotnum < field_slotnum) // break if prev after field
{
@@ -1469,10 +1469,10 @@ mime_hdr_field_attach(MIMEHdrImpl *mh, MIMEField *field, int check_for_dups, MIM
mime_hdr_set_accelerators_and_presence_bits(mh, field);
} else // patch us after prev, and before next
{
- ink_debug_assert(prev_slotnum < field_slotnum);
- ink_debug_assert((next_dup == NULL) || (next_slotnum > field_slotnum));
+ ink_assert(prev_slotnum < field_slotnum);
+ ink_assert((next_dup == NULL) || (next_slotnum > field_slotnum));
field->m_flags = (field->m_flags & ~MIME_FIELD_SLOT_FLAGS_DUP_HEAD);
- ink_debug_assert((next_dup == NULL) || next_dup->is_live());
+ ink_assert((next_dup == NULL) || next_dup->is_live());
prev_dup->m_next_dup = field;
field->m_next_dup = next_dup;
}
@@ -1482,7 +1482,7 @@ mime_hdr_field_attach(MIMEHdrImpl *mh, MIMEField *field, int check_for_dups, MIM
}
// Now keep the cooked cache consistent
- ink_debug_assert(field->is_live());
+ ink_assert(field->is_live());
if (field->m_ptr_value && field->is_cooked())
mh->recompute_cooked_stuff(field);
@@ -1494,7 +1494,7 @@ mime_hdr_field_detach(MIMEHdrImpl *mh, MIMEField *field, bool detach_all_dups)
{
MIMEField *next_dup = field->m_next_dup;
- ink_debug_assert(field->is_live());
+ ink_assert(field->is_live());
MIME_HDR_SANITY_CHECK(mh);
@@ -1633,7 +1633,7 @@ void
mime_field_destroy(MIMEHdrImpl *mh, MIMEField *field)
{
NOWARN_UNUSED(mh);
- ink_debug_assert(field->m_readiness == MIME_FIELD_SLOT_READINESS_DETACHED);
+ ink_assert(field->m_readiness == MIME_FIELD_SLOT_READINESS_DETACHED);
field->m_readiness = MIME_FIELD_SLOT_READINESS_DELETED;
}
@@ -1652,7 +1652,7 @@ mime_field_name_set(HdrHeap *heap, MIMEHdrImpl *mh, MIMEField *field, int16_t na
const char *name, int length, bool must_copy_string)
{
NOWARN_UNUSED(mh);
- ink_debug_assert(field->m_readiness == MIME_FIELD_SLOT_READINESS_DETACHED);
+ ink_assert(field->m_readiness == MIME_FIELD_SLOT_READINESS_DETACHED);
field->m_wks_idx = name_wks_idx_or_neg1;
mime_str_u16_set(heap, name, length, &(field->m_ptr_name), &(field->m_len_name), must_copy_string);
@@ -1794,7 +1794,7 @@ mime_field_value_str_from_strlist(HdrHeap *heap, int *new_str_len_return, StrLis
dest += cell->len;
cell = cell->next;
}
- ink_debug_assert(dest - new_value == new_value_len);
+ ink_assert(dest - new_value == new_value_len);
*new_str_len_return = new_value_len;
return new_value;
@@ -1817,7 +1817,7 @@ mime_field_value_set_comma_val(HdrHeap *heap, MIMEHdrImpl *mh,
// (3) mutate cell idx
cell = list.get_idx(idx);
- ink_debug_assert(cell != NULL);
+ ink_assert(cell != NULL);
cell->str = new_piece_str;
cell->len = new_piece_len;
@@ -1933,7 +1933,7 @@ mime_field_value_extend_comma_val(HdrHeap *heap, MIMEHdrImpl *mh, MIMEField *fie
// (3) get the cell we want to modify
cell = list.get_idx(idx);
- ink_debug_assert(cell != NULL);
+ ink_assert(cell != NULL);
// (4) trim quotes if any
if ((cell->len >= 2) && (cell->str[0] == '\"') && (cell->str[cell->len - 1] == '\"')) {
@@ -1963,7 +1963,7 @@ mime_field_value_extend_comma_val(HdrHeap *heap, MIMEHdrImpl *mh, MIMEField *fie
dest += new_piece_len;
if (trimmed)
*dest++ = '\"';
- ink_debug_assert((size_t) (dest - temp_ptr) == extended_len);
+ ink_assert((size_t) (dest - temp_ptr) == extended_len);
// (8) assign the new token to the cell
cell->str = temp_ptr;
@@ -2042,7 +2042,7 @@ mime_field_name_value_set(HdrHeap *heap, MIMEHdrImpl *mh, MIMEField *field, int1
{
unsigned int n_v_raw_pad = n_v_raw_length - (name_length + value_length);
- ink_debug_assert(field->m_readiness == MIME_FIELD_SLOT_READINESS_DETACHED);
+ ink_assert(field->m_readiness == MIME_FIELD_SLOT_READINESS_DETACHED);
if (must_copy_strings) {
mime_field_name_set(heap, mh, field, name_wks_idx_or_neg1, name, name_length, 1);
@@ -2239,8 +2239,8 @@ mime_scanner_get(MIMEScanner *S,
// Need this for handling dangling CR.
static char const RAW_CR = ParseRules::CHAR_CR;
- ink_debug_assert((raw_input_s != NULL) && (*raw_input_s != NULL));
- ink_debug_assert(raw_input_e != NULL);
+ ink_assert((raw_input_s != NULL) && (*raw_input_s != NULL));
+ ink_assert(raw_input_e != NULL);
raw_input_c = *raw_input_s;
@@ -2644,8 +2644,8 @@ mime_mem_print(const char *src_d, int src_l, char *buf_start, int buf_length, in
return 1;
}
- ink_debug_assert(buf_start != NULL);
- ink_debug_assert(src_d != NULL);
+ ink_assert(buf_start != NULL);
+ ink_assert(src_d != NULL);
if (*buf_chars_to_skip_inout > 0) {
if (*buf_chars_to_skip_inout >= src_l) {
@@ -2826,7 +2826,7 @@ mime_days_since_epoch_to_mdy_slowcase(unsigned int days_since_jan_1_1970, int *m
/* convert the days */
d = mday - d;
if ((d<0) || (d> 366))
- ink_debug_assert(!"bad date");
+ ink_assert(!"bad date");
else {
month = months[d];
if (month > 1)
@@ -2921,10 +2921,10 @@ mime_format_date(char *buffer, time_t value)
#endif
/* arrange the date in the buffer */
- ink_debug_assert((mday >= 0) && (mday <= 99));
- ink_debug_assert((hour >= 0) && (hour <= 99));
- ink_debug_assert((min >= 0) && (min <= 99));
- ink_debug_assert((sec >= 0) && (sec <= 99));
+ ink_assert((mday >= 0) && (mday <= 99));
+ ink_assert((hour >= 0) && (hour <= 99));
+ ink_assert((min >= 0) && (min <= 99));
+ ink_assert((sec >= 0) && (sec <= 99));
/* the day string */
const char *three_char_day = daystrs[wday];
@@ -3143,9 +3143,9 @@ mime_parse_rfc822_date_fastcase(const char *buf, int length, struct tm *tp)
{
unsigned int three_char_wday, three_char_mon;
- ink_debug_assert(length >= 29);
- ink_debug_assert(!is_ws(buf[0]));
- ink_debug_assert(buf[3] == ',');
+ ink_assert(length >= 29);
+ ink_assert(!is_ws(buf[0]));
+ ink_assert(buf[3] == ',');
////////////////////////////
// binary search for wday //
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/hdrs/URL.cc
----------------------------------------------------------------------
diff --git a/proxy/hdrs/URL.cc b/proxy/hdrs/URL.cc
index b9d2b06..6fdd1e6 100644
--- a/proxy/hdrs/URL.cc
+++ b/proxy/hdrs/URL.cc
@@ -1230,7 +1230,7 @@ url_parse_internet(HdrHeap* heap, URLImpl* url,
url_host_set(heap, url, host._ptr, host._size, copy_strings_p);
if (last_colon) {
- ink_debug_assert(n_colon);
+ ink_assert(n_colon);
port.set(last_colon+1, cur);
if (!port._size)
return PARSE_ERROR; // colon w/o port value.
@@ -1285,7 +1285,7 @@ parse_path2:
goto parse_fragment1;
}
} else {
- ink_debug_assert((*cur != ';') && (*cur != '?') && (*cur != '#'));
+ ink_assert((*cur != ';') && (*cur != '?') && (*cur != '#'));
}
GETNEXT(done);
goto parse_path2;
@@ -1578,7 +1578,7 @@ url_MMH_get_fast(URLImpl * url, INK_MD5 * md5)
*p++ = '?';
// no query
- ink_debug_assert(sizeof(url->m_port) == 2);
+ ink_assert(sizeof(url->m_port) == 2);
uint16_t port = (uint16_t) url_canonicalize_port(url->m_url_type, url->m_port);
*p++ = ((char *) &port)[0];
*p++ = ((char *) &port)[1];
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/hdrs/URL.h
----------------------------------------------------------------------
diff --git a/proxy/hdrs/URL.h b/proxy/hdrs/URL.h
index 8f41e69..5960c0d 100644
--- a/proxy/hdrs/URL.h
+++ b/proxy/hdrs/URL.h
@@ -338,7 +338,7 @@ URL::create(HdrHeap *heap)
inline void
URL::copy(const URL *url)
{
- ink_debug_assert(url->valid());
+ ink_assert(url->valid());
url_copy_onto(url->m_url_impl, url->m_heap, m_url_impl, m_heap);
}
@@ -348,7 +348,7 @@ URL::copy(const URL *url)
inline void
URL::copy_shallow(const URL *url)
{
- ink_debug_assert(url->valid());
+ ink_assert(url->valid());
this->set(url);
m_url_impl = url->m_url_impl;
}
@@ -375,7 +375,7 @@ URL::reset()
inline void
URL::nuke_proxy_stuff()
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_nuke_proxy_stuff(m_url_impl);
}
@@ -385,7 +385,7 @@ URL::nuke_proxy_stuff()
inline int
URL::print(char *buf, int bufsize, int *bufindex, int *dumpoffset)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return url_print(m_url_impl, buf, bufsize, bufindex, dumpoffset);
}
@@ -395,7 +395,7 @@ URL::print(char *buf, int bufsize, int *bufindex, int *dumpoffset)
inline int
URL::length_get()
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return url_length_get(m_url_impl);
}
@@ -405,21 +405,21 @@ URL::length_get()
inline char *
URL::string_get(Arena *arena_or_null_for_malloc, int *length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return url_string_get(m_url_impl, arena_or_null_for_malloc, length, m_heap);
}
inline char *
URL::string_get_ref(int *length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return url_string_get_ref(m_heap, m_url_impl, length);
}
inline void
URL::clear_string_ref()
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_clear_string_ref(m_url_impl);
return;
}
@@ -429,7 +429,7 @@ URL::clear_string_ref()
inline char *
URL::string_get_buf(char *dstbuf, int dsbuf_size, int *length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return url_string_get_buf(m_url_impl, dstbuf, dsbuf_size, length);
}
@@ -439,7 +439,7 @@ URL::string_get_buf(char *dstbuf, int dsbuf_size, int *length)
inline void
URL::MD5_get(INK_MD5 *md5)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_MD5_get(m_url_impl, md5);
}
@@ -449,7 +449,7 @@ URL::MD5_get(INK_MD5 *md5)
inline void
URL::host_MD5_get(INK_MD5 *md5)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_host_MD5_get(m_url_impl, md5);
}
@@ -459,7 +459,7 @@ URL::host_MD5_get(INK_MD5 *md5)
inline const char *
URL::scheme_get(int *length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return (url_scheme_get(m_url_impl, length));
}
@@ -467,7 +467,7 @@ URL::scheme_get(int *length)
inline int
URL::scheme_get_wksidx()
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return (m_url_impl->m_scheme_wks_idx);
}
@@ -477,7 +477,7 @@ URL::scheme_get_wksidx()
inline void
URL::scheme_set(const char *value, int length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
int scheme_wks_idx = (value ? hdrtoken_tokenize(value, length) : -1);
url_scheme_set(m_heap, m_url_impl, value, scheme_wks_idx, length, true);
}
@@ -488,7 +488,7 @@ URL::scheme_set(const char *value, int length)
inline const char *
URL::user_get(int *length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
*length = m_url_impl->m_len_user;
return m_url_impl->m_ptr_user;
}
@@ -499,7 +499,7 @@ URL::user_get(int *length)
inline void
URL::user_set(const char *value, int length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_user_set(m_heap, m_url_impl, value, length, true);
}
@@ -509,7 +509,7 @@ URL::user_set(const char *value, int length)
inline const char *
URL::password_get(int *length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
*length = m_url_impl->m_len_password;
return m_url_impl->m_ptr_password;
}
@@ -520,7 +520,7 @@ URL::password_get(int *length)
inline void
URL::password_set(const char *value, int length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_password_set(m_heap, m_url_impl, value, length, true);
}
@@ -530,7 +530,7 @@ URL::password_set(const char *value, int length)
inline const char *
URL::host_get(int *length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
*length = m_url_impl->m_len_host;
return m_url_impl->m_ptr_host;
}
@@ -541,7 +541,7 @@ URL::host_get(int *length)
inline void
URL::host_set(const char *value, int length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_host_set(m_heap, m_url_impl, value, length, true);
}
@@ -551,7 +551,7 @@ URL::host_set(const char *value, int length)
inline int
URL::port_get()
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return url_canonicalize_port(m_url_impl->m_url_type, m_url_impl->m_port);
}
@@ -561,7 +561,7 @@ URL::port_get()
inline int
URL::port_get_raw()
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return m_url_impl->m_port;
}
@@ -571,7 +571,7 @@ URL::port_get_raw()
inline void
URL::port_set(int port)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_port_set(m_heap, m_url_impl, port);
}
@@ -581,7 +581,7 @@ URL::port_set(int port)
inline const char *
URL::path_get(int *length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
*length = m_url_impl->m_len_path;
return m_url_impl->m_ptr_path;
}
@@ -592,7 +592,7 @@ URL::path_get(int *length)
inline void
URL::path_set(const char *value, int length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_path_set(m_heap, m_url_impl, value, length, true);
}
@@ -602,7 +602,7 @@ URL::path_set(const char *value, int length)
inline int
URL::type_get()
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return m_url_impl->m_type_code;
}
@@ -612,7 +612,7 @@ URL::type_get()
inline void
URL::type_set(int type)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_type_set(m_url_impl, type);
}
@@ -622,7 +622,7 @@ URL::type_set(int type)
inline const char *
URL::params_get(int *length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
*length = m_url_impl->m_len_params;
return m_url_impl->m_ptr_params;
}
@@ -633,7 +633,7 @@ URL::params_get(int *length)
inline void
URL::params_set(const char *value, int length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_params_set(m_heap, m_url_impl, value, length, true);
}
@@ -643,7 +643,7 @@ URL::params_set(const char *value, int length)
inline const char *
URL::query_get(int *length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
*length = m_url_impl->m_len_query;
return m_url_impl->m_ptr_query;
}
@@ -654,7 +654,7 @@ URL::query_get(int *length)
inline void
URL::query_set(const char *value, int length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_query_set(m_heap, m_url_impl, value, length, true);
}
@@ -664,7 +664,7 @@ URL::query_set(const char *value, int length)
inline const char *
URL::fragment_get(int *length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
*length = m_url_impl->m_len_fragment;
return m_url_impl->m_ptr_fragment;
}
@@ -675,7 +675,7 @@ URL::fragment_get(int *length)
inline void
URL::fragment_set(const char *value, int length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
url_fragment_set(m_heap, m_url_impl, value, length, true);
}
@@ -687,7 +687,7 @@ URL::fragment_set(const char *value, int length)
inline MIMEParseResult
URL::parse(const char **start, const char *end)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
return url_parse(m_heap, m_url_impl, start, end, true);
}
@@ -699,7 +699,7 @@ URL::parse(const char **start, const char *end)
inline MIMEParseResult
URL::parse(const char *str, int length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
if (length < 0)
length = (int) strlen(str);
return parse(&str, str + length);
@@ -713,10 +713,10 @@ URL::parse(const char *str, int length)
inline MIMEParseResult
URL::parse_no_path_component_breakdown(const char *str, int length)
{
- ink_debug_assert(valid());
+ ink_assert(valid());
if (length < 0)
length = (int) strlen(str);
- ink_debug_assert(valid());
+ ink_assert(valid());
return url_parse_no_path_component_breakdown(m_heap, m_url_impl, &str, str + length, true);
}
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/http/HttpClientSession.cc
----------------------------------------------------------------------
diff --git a/proxy/http/HttpClientSession.cc b/proxy/http/HttpClientSession.cc
index 72720d4..2c77acb 100644
--- a/proxy/http/HttpClientSession.cc
+++ b/proxy/http/HttpClientSession.cc
@@ -39,7 +39,7 @@
#define DebugSsn(tag, ...) DebugSpecific(debug_on, tag, __VA_ARGS__)
#define STATE_ENTER(state_name, event, vio) { \
- /*ink_debug_assert (magic == HTTP_SM_MAGIC_ALIVE); REMEMBER (event, NULL, reentrancy_count); */ \
+ /*ink_assert (magic == HTTP_SM_MAGIC_ALIVE); REMEMBER (event, NULL, reentrancy_count); */ \
DebugSsn("http_cs", "[%" PRId64 "] [%s, %s]", con_id, \
#state_name, HttpDebugNames::get_event_name(event)); }
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/http/HttpSM.cc
----------------------------------------------------------------------
diff --git a/proxy/http/HttpSM.cc b/proxy/http/HttpSM.cc
index 3b0b151..300b890 100644
--- a/proxy/http/HttpSM.cc
+++ b/proxy/http/HttpSM.cc
@@ -155,7 +155,7 @@ HttpSM::_instantiate_func(HttpSM * prototype, HttpSM * new_instance)
pd[to[j]] = val[j];
}
- ink_debug_assert((memcmp((char *) new_instance, (char *) prototype, pre_history_len) == 0) &&
+ ink_assert((memcmp((char *) new_instance, (char *) prototype, pre_history_len) == 0) &&
(memcmp(((char *) new_instance) + post_offset, ((char *) prototype) + post_offset, post_history_len) == 0));
#else
// memcpy(new_instance, prototype, total_len);
@@ -294,7 +294,7 @@ history[pos].fileline = __FILE__ ":" _REMEMBER (__LINE__);
#undef STATE_ENTER
#endif
#define STATE_ENTER(state_name, event) { \
- /*ink_debug_assert (magic == HTTP_SM_MAGIC_ALIVE); */ REMEMBER (event, reentrancy_count); \
+ /*ink_assert (magic == HTTP_SM_MAGIC_ALIVE); */ REMEMBER (event, reentrancy_count); \
DebugSM("http", "[%" PRId64 "] [%s, %s]", sm_id, \
#state_name, HttpDebugNames::get_event_name(event)); }
@@ -849,7 +849,7 @@ HttpSM::state_drain_client_request_body(int event, void *data)
// Since we are only reading what's needed to complete
// the post, there must be something left to do
- ink_debug_assert(avail < left);
+ ink_assert(avail < left);
client_request_body_bytes += avail;
ua_buffer_reader->consume(avail);
@@ -863,7 +863,7 @@ HttpSM::state_drain_client_request_body(int event, void *data)
ua_buffer_reader->consume(avail);
client_request_body_bytes += avail;
- ink_debug_assert(client_request_body_bytes == t_state.hdr_info.request_content_length);
+ ink_assert(client_request_body_bytes == t_state.hdr_info.request_content_length);
ua_buffer_reader->mbuf->size_index = HTTP_HEADER_BUFFER_SIZE_INDEX;
ua_entry->vc_handler = &HttpSM::state_watch_for_client_abort;
@@ -1346,7 +1346,7 @@ HttpSM::state_api_callout(int event, void *data)
switch (event) {
case EVENT_INTERVAL:
- ink_debug_assert(pending_action == data);
+ ink_assert(pending_action == data);
pending_action = NULL;
// FALLTHROUGH
case EVENT_NONE:
@@ -1395,7 +1395,7 @@ HttpSM::state_api_callout(int event, void *data)
if (!plugin_lock) {
HTTP_SM_SET_DEFAULT_HANDLER(&HttpSM::state_api_callout);
- ink_debug_assert(pending_action == NULL);
+ ink_assert(pending_action == NULL);
pending_action = mutex->thread_holding->schedule_in(this, HRTIME_MSECONDS(10));
return 0;
}
@@ -1995,13 +1995,13 @@ HttpSM::process_srv_info(HostDBInfo * r)
t_state.srv_lookup = false;
DebugSM("dns_srv", "SRV records empty for %s", t_state.dns_info.lookup_name);
} else {
- ink_debug_assert(r->md5_high == srv->md5_high && r->md5_low == srv->md5_low &&
+ ink_assert(r->md5_high == srv->md5_high && r->md5_low == srv->md5_low &&
r->md5_low_low == srv->md5_low_low);
t_state.dns_info.srv_lookup_success = true;
t_state.dns_info.srv_port = srv->data.srv.srv_port;
t_state.dns_info.srv_app = srv->app;
//t_state.dns_info.single_srv = (rr->good == 1);
- ink_debug_assert(srv->data.srv.key == makeHostHash(t_state.dns_info.srv_hostname));
+ ink_assert(srv->data.srv.key == makeHostHash(t_state.dns_info.srv_hostname));
DebugSM("dns_srv", "select SRV records %s", t_state.dns_info.srv_hostname);
}
}
@@ -2077,7 +2077,7 @@ HttpSM::state_hostdb_lookup(int event, void *data)
{
STATE_ENTER(&HttpSM::state_hostdb_lookup, event);
-// ink_debug_assert (m_origin_server_vc == 0);
+// ink_assert (m_origin_server_vc == 0);
// REQ_FLAVOR_SCHEDULED_UPDATE can be transformed into
// REQ_FLAVOR_REVPROXY
ink_assert(t_state.req_flavor == HttpTransact::REQ_FLAVOR_SCHEDULED_UPDATE ||
@@ -3169,7 +3169,7 @@ HttpSM::tunnel_handler_cache_read(int event, HttpTunnelProducer * p)
switch (event) {
case VC_EVENT_ERROR:
case VC_EVENT_EOS:
- ink_debug_assert(t_state.cache_info.object_read->valid());
+ ink_assert(t_state.cache_info.object_read->valid());
if (t_state.cache_info.object_read->object_size_get() != INT64_MAX || event == VC_EVENT_ERROR) {
// Abnormal termination
t_state.squid_codes.log_code = SQUID_LOG_TCP_SWAPFAIL;
@@ -3720,7 +3720,7 @@ HttpSM::state_remap_request(int event, void *data)
switch (event) {
case EVENT_REMAP_ERROR:
{
- ink_debug_assert(!"this doesn't happen");
+ ink_assert(!"this doesn't happen");
pending_action = NULL;
Error("error remapping request [see previous errors]");
call_transact_and_set_next_state(HttpTransact::HandleRequest); //HandleRequest skips EndRemapRequest
@@ -3771,7 +3771,7 @@ HttpSM::do_remap_request(bool run_inline)
if (remap_action_handle != ACTION_RESULT_DONE) {
DebugSM("url_rewrite", "Still more remapping needed for [%" PRId64 "]", sm_id);
- ink_debug_assert(!pending_action);
+ ink_assert(!pending_action);
historical_action = pending_action = remap_action_handle;
}
@@ -3873,7 +3873,7 @@ HttpSM::do_hostdb_lookup()
}
return;
}
- ink_debug_assert(!"not reached");
+ ink_assert(!"not reached");
return;
}
@@ -3990,7 +3990,7 @@ HttpSM::parse_range_and_compare(MIMEField *field, int64_t content_length)
RangeRecord *ranges = NULL;
int64_t start, end;
- ink_debug_assert(field != NULL && t_state.range_setup == HttpTransact::RANGE_NONE && t_state.ranges == NULL);
+ ink_assert(field != NULL && t_state.range_setup == HttpTransact::RANGE_NONE && t_state.ranges == NULL);
if (content_length <= 0)
return;
@@ -4090,7 +4090,7 @@ HttpSM::parse_range_and_compare(MIMEField *field, int64_t content_length)
goto Lfaild;
}
- ink_debug_assert(start >= 0 && end >= 0 && start < content_length && end < content_length);
+ ink_assert(start >= 0 && end >= 0 && start < content_length && end < content_length);
prev_good_range = nr;
ranges[nr]._start = start;
@@ -4123,7 +4123,7 @@ HttpSM::calculate_output_cl(int64_t content_length, int64_t num_chars)
t_state.range_setup != HttpTransact::RANGE_NOT_TRANSFORM_REQUESTED)
return;
- ink_debug_assert(t_state.ranges);
+ ink_assert(t_state.ranges);
if (t_state.num_range_fields == 1) {
t_state.range_output_cl = t_state.ranges[0]._end - t_state.ranges[0]._start + 1;
@@ -4354,7 +4354,7 @@ HttpSM::do_cache_prepare_action(HttpCacheSM * c_sm, CacheHTTPInfo * object_read_
s_url->copy(c_url);
}
- ink_debug_assert(s_url != NULL && s_url->valid());
+ ink_assert(s_url != NULL && s_url->valid());
DebugSM("http_cache_write", "[%" PRId64 "] writing to cache with URL %s", sm_id, s_url->string_get(&t_state.arena));
Action *cache_action_handle = c_sm->open_write(s_url, &t_state.hdr_info.client_request,
object_read_info,
@@ -4520,7 +4520,7 @@ HttpSM::do_http_server_open(bool raw)
// between the statement above and the check below.
// If this happens, we might go over the max by 1 but this is ok.
if (sum >= t_state.http_config_param->server_max_connections) {
- ink_debug_assert(pending_action == NULL);
+ ink_assert(pending_action == NULL);
pending_action = eventProcessor.schedule_in(this, HRTIME_MSECONDS(100));
httpSessionManager.purge_keepalives();
return;
@@ -4535,7 +4535,7 @@ HttpSM::do_http_server_open(bool raw)
if (connections->getCount((t_state.current.server->addr)) >= t_state.txn_conf->origin_max_connections) {
DebugSM("http", "[%" PRId64 "] over the number of connection for this host: %s", sm_id,
ats_ip_ntop(&t_state.current.server->addr.sa, addrbuf, sizeof(addrbuf)));
- ink_debug_assert(pending_action == NULL);
+ ink_assert(pending_action == NULL);
pending_action = eventProcessor.schedule_in(this, HRTIME_MSECONDS(100));
return;
}
@@ -5138,7 +5138,7 @@ HttpSM::do_drain_request_body()
client_request_body_bytes = act_on;
ua_buffer_reader->consume(act_on);
- ink_debug_assert(client_request_body_bytes <= post_bytes);
+ ink_assert(client_request_body_bytes <= post_bytes);
if (client_request_body_bytes < post_bytes) {
ua_buffer_reader->mbuf->size_index = buffer_size_to_index(t_state.hdr_info.request_content_length);
@@ -7032,7 +7032,7 @@ HttpSM::set_next_state()
{
HTTP_SM_SET_DEFAULT_HANDLER(&HttpSM::state_mark_os_down);
- ink_debug_assert(t_state.dns_info.looking_up == HttpTransact::ORIGIN_SERVER);
+ ink_assert(t_state.dns_info.looking_up == HttpTransact::ORIGIN_SERVER);
// TODO: This might not be optimal (or perhaps even correct), but it will
// effectively mark the host as down. What's odd is that state_mark_os_down
@@ -7354,7 +7354,7 @@ HttpSM::get_http_schedule(int event, void * data)
if (!plugin_lock) {
HTTP_SM_SET_DEFAULT_HANDLER(&HttpSM::get_http_schedule);
- ink_debug_assert(pending_action == NULL);
+ ink_assert(pending_action == NULL);
pending_action = mutex->thread_holding->schedule_in(this, HRTIME_MSECONDS(10));
return 0;
}
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/dc6e42c6/proxy/http/HttpServerSession.h
----------------------------------------------------------------------
diff --git a/proxy/http/HttpServerSession.h b/proxy/http/HttpServerSession.h
index 89db5bd..53b6eea 100644
--- a/proxy/http/HttpServerSession.h
+++ b/proxy/http/HttpServerSession.h
@@ -85,8 +85,8 @@ public:
void reset_read_buffer(void)
{
- ink_debug_assert(read_buffer->_writer);
- ink_debug_assert(buf_reader != NULL);
+ ink_assert(read_buffer->_writer);
+ ink_assert(buf_reader != NULL);
read_buffer->dealloc_all_readers();
read_buffer->_writer = NULL;
buf_reader = read_buffer->alloc_reader();