You are viewing a plain text version of this content. The canonical link for it is here.
Posted to axis-cvs@ws.apache.org by sa...@apache.org on 2006/05/31 17:54:39 UTC
svn commit: r410566 [24/49] - in /webservices/axis2/trunk/c: axiom/include/
axiom/src/attachments/ axiom/src/om/ axiom/src/parser/guththila/
axiom/src/parser/libxml2/ axiom/src/soap/ axiom/test/om/ axiom/test/soap/
axiom/test/unit/om/ include/ modules/...
Modified: webservices/axis2/trunk/c/modules/core/engine/engine.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/engine.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/engine.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/engine.c Wed May 31 08:54:07 2006
@@ -47,87 +47,87 @@
axis2_status_t AXIS2_CALL
axis2_engine_send(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx);
axis2_status_t AXIS2_CALL
axis2_engine_receive(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx);
axis2_status_t AXIS2_CALL
axis2_engine_send_fault(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx);
axis2_status_t AXIS2_CALL
axis2_engine_receive_fault(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx);
axis2_msg_ctx_t* AXIS2_CALL
axis2_engine_create_fault_msg_ctx(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *processing_context);
axis2_status_t AXIS2_CALL
axis2_engine_extract_fault_info_from_msg_ctx(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx,
struct axis2_soap_fault *fault);
axis2_status_t AXIS2_CALL
axis2_engine_verify_ctx_built(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx);
axis2_status_t AXIS2_CALL
axis2_engine_invoke_phases(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_array_list_t *phases,
axis2_msg_ctx_t *msg_ctx);
axis2_status_t AXIS2_CALL
axis2_engine_resume_invocation_phases(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_array_list_t *phases,
axis2_msg_ctx_t *msg_ctx);
axis2_char_t* AXIS2_CALL
axis2_engine_get_sender_fault_code(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_char_t *soap_namespace);
axis2_char_t* AXIS2_CALL
axis2_engine_get_receiver_fault_code(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_char_t *soap_namespace);
axis2_status_t AXIS2_CALL
axis2_engine_free(struct axis2_engine *engine,
- axis2_env_t **env);
+ const axis2_env_t *env);
-axis2_status_t axis2_engine_check_must_understand_headers(axis2_env_t **env,
+axis2_status_t axis2_engine_check_must_understand_headers(const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx);
AXIS2_DECLARE(axis2_engine_t*)
-axis2_engine_create(axis2_env_t **env,
+axis2_engine_create(const axis2_env_t *env,
axis2_conf_ctx_t *conf_ctx)
{
axis2_engine_impl_t *engine_impl = NULL;
AXIS2_ENV_CHECK(env, NULL);
- engine_impl = AXIS2_MALLOC( (*env)->allocator, sizeof(axis2_engine_impl_t) );
+ engine_impl = AXIS2_MALLOC( env->allocator, sizeof(axis2_engine_impl_t) );
if (!engine_impl)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
@@ -140,10 +140,10 @@
}
/* initialize ops */
- engine_impl->engine.ops = AXIS2_MALLOC( (*env)->allocator, sizeof(axis2_engine_ops_t) );
+ engine_impl->engine.ops = AXIS2_MALLOC( env->allocator, sizeof(axis2_engine_ops_t) );
if (!engine_impl->engine.ops)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
axis2_engine_free(&(engine_impl->engine), env);
return NULL;
}
@@ -189,7 +189,7 @@
axis2_status_t AXIS2_CALL
axis2_engine_free(struct axis2_engine *engine,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
axis2_engine_impl_t *engine_impl = NULL;
@@ -199,11 +199,11 @@
if (engine_impl->engine.ops)
{
- AXIS2_FREE((*env)->allocator, engine_impl->engine.ops);
+ AXIS2_FREE(env->allocator, engine_impl->engine.ops);
engine_impl->engine.ops = NULL;
}
- AXIS2_FREE((*env)->allocator, engine_impl);
+ AXIS2_FREE(env->allocator, engine_impl);
engine_impl = NULL;
return AXIS2_SUCCESS;
@@ -221,7 +221,7 @@
*/
axis2_status_t AXIS2_CALL
axis2_engine_send(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx)
{
axis2_engine_impl_t *engine_impl = NULL;
@@ -231,10 +231,10 @@
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_conf_t *conf = NULL;
- AXIS2_LOG_TRACE((*env)->log, AXIS2_LOG_SI, "axis2_engine_send start");
+ AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_engine_send start");
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
engine_impl = AXIS2_INTF_TO_IMPL(engine);
@@ -311,13 +311,13 @@
}
else
{
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI, "Transport out is not set in message context");
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Transport out is not set in message context");
return AXIS2_FAILURE;
}
}
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI, "Axis2 engine send successful");
- AXIS2_LOG_TRACE((*env)->log, AXIS2_LOG_SI, "axis2_engine_send end");
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Axis2 engine send successful");
+ AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_engine_send end");
return AXIS2_SUCCESS;
}
@@ -332,7 +332,7 @@
*/
axis2_status_t AXIS2_CALL
axis2_engine_receive(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx)
{
axis2_engine_impl_t *engine_impl = NULL;
@@ -345,7 +345,7 @@
axis2_status_t status = AXIS2_FAILURE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
engine_impl = AXIS2_INTF_TO_IMPL(engine);
@@ -428,7 +428,7 @@
receiver = AXIS2_OP_GET_MSG_RECEIVER(op, env);
if (!receiver)
{
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI, "Message receiver not set in operation description");
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Message receiver not set in operation description");
return AXIS2_FAILURE;
}
status = AXIS2_MSG_RECV_RECEIVE(receiver, env, msg_ctx, receiver->derived);
@@ -437,7 +437,7 @@
{
status = AXIS2_SUCCESS;
}
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI, "Axis2 engine receive successful");
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Axis2 engine receive successful");
return status;
}
@@ -449,13 +449,13 @@
*/
axis2_status_t AXIS2_CALL
axis2_engine_send_fault(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx)
{
axis2_op_ctx_t *op_ctx = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env);
@@ -515,13 +515,13 @@
*/
axis2_status_t AXIS2_CALL
axis2_engine_receive_fault(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx)
{
axis2_op_ctx_t *op_ctx = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env);
@@ -580,7 +580,7 @@
*/
axis2_msg_ctx_t* AXIS2_CALL
axis2_engine_create_fault_msg_ctx(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *processing_context)
{
axis2_msg_ctx_t *fault_ctx = NULL;
@@ -595,13 +595,13 @@
axis2_char_t *msg_uuid = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, processing_context, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, processing_context, AXIS2_FAILURE);
engine_impl = AXIS2_INTF_TO_IMPL(engine);
if (AXIS2_MSG_CTX_GET_PROCESS_FAULT(processing_context, env))
{
- AXIS2_ERROR_SET((*env)->error,
+ AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_INVALID_STATE_PROCESSING_FAULT_ALREADY, AXIS2_FAILURE);
return NULL;
}
@@ -650,7 +650,7 @@
if (!fault_to && !property)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NOWHERE_TO_SEND_FAULT, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NOWHERE_TO_SEND_FAULT, AXIS2_FAILURE);
return NULL;
}
property = NULL;
@@ -674,7 +674,7 @@
AXIS2_MSG_CTX_SET_MESSAGE_ID(fault_ctx, env, msg_uuid);
if(NULL != msg_uuid)
{
- AXIS2_FREE((*env)->allocator, msg_uuid);
+ AXIS2_FREE(env->allocator, msg_uuid);
msg_uuid = NULL;
}
@@ -761,15 +761,15 @@
*/
axis2_status_t AXIS2_CALL
axis2_engine_extract_fault_info_from_msg_ctx(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx,
struct axis2_soap_fault *fault)
{
/*axis2_char_t *soap_namespace_uri = NULL;*/
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, fault, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, fault, AXIS2_FAILURE);
/* get the current SOAP version */
/*if (AXIS2_MSG_CTX_GET_IS_SOAP_11(msg_ctx, env))
@@ -836,11 +836,11 @@
axis2_status_t AXIS2_CALL
axis2_engine_verify_ctx_built(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
if (!AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env))
{
@@ -860,7 +860,7 @@
axis2_status_t AXIS2_CALL
axis2_engine_invoke_phases(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_array_list_t *phases,
axis2_msg_ctx_t *msg_ctx)
{
@@ -869,8 +869,8 @@
axis2_status_t status = AXIS2_SUCCESS;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, phases, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, phases, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
count = AXIS2_ARRAY_LIST_SIZE(phases, env);
for (i = 0; (i < count && !(AXIS2_MSG_CTX_IS_PAUSED(msg_ctx, env))); i++)
@@ -878,7 +878,7 @@
axis2_phase_t *phase = (axis2_phase_t *)
AXIS2_ARRAY_LIST_GET(phases, env, i);
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI,
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Invoking phase %s", AXIS2_PHASE_GET_NAME(phase, env));
status = AXIS2_PHASE_INVOKE(phase, env, msg_ctx);
@@ -892,7 +892,7 @@
axis2_status_t AXIS2_CALL
axis2_engine_resume_invocation_phases(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_array_list_t *phases,
axis2_msg_ctx_t *msg_ctx)
{
@@ -901,8 +901,8 @@
axis2_bool_t found_match = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, phases, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, phases, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
AXIS2_MSG_CTX_SET_PAUSED(msg_ctx, env, AXIS2_FALSE);
@@ -937,11 +937,11 @@
axis2_char_t* AXIS2_CALL
axis2_engine_get_sender_fault_code(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_char_t *soap_namespace)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, soap_namespace, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, soap_namespace, AXIS2_FAILURE);
/*if (AXIS2_STRCMP(AXIS2_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, soap_namespace))
return AXIS2_SOAP12_FAULT_CODE_SENDER;
@@ -953,11 +953,11 @@
axis2_char_t* AXIS2_CALL
axis2_engine_get_receiver_fault_code(struct axis2_engine *engine,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_char_t *soap_namespace)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, soap_namespace, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, soap_namespace, AXIS2_FAILURE);
if (AXIS2_STRCMP(AXIS2_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, soap_namespace))
return AXIS2_SOAP12_FAULT_CODE_RECEIVER;
@@ -966,7 +966,7 @@
return NULL;
}
-axis2_status_t axis2_engine_check_must_understand_headers(axis2_env_t **env,
+axis2_status_t axis2_engine_check_must_understand_headers(const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx)
{
axis2_soap_envelope_t *soap_envelope = NULL;
@@ -975,7 +975,7 @@
axis2_hash_index_t *hash_index = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
soap_envelope = AXIS2_MSG_CTX_GET_SOAP_ENVELOPE(msg_ctx, env);
if (!soap_envelope)
Modified: webservices/axis2/trunk/c/modules/core/engine/event.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/event.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/event.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/event.c Wed May 31 08:54:07 2006
@@ -32,20 +32,20 @@
axis2_svc_t* AXIS2_CALL
axis2_event_get_svc(struct axis2_event *event,
- axis2_env_t **env);
+ const axis2_env_t *env);
int AXIS2_CALL
axis2_event_get_event_type(struct axis2_event *event,
- axis2_env_t **env);
+ const axis2_env_t *env);
axis2_status_t AXIS2_CALL
axis2_event_free(struct axis2_event *event,
- axis2_env_t **env);
+ const axis2_env_t *env);
axis2_event_t* AXIS2_CALL
-axis2_event_create(axis2_env_t **env,
+axis2_event_create(const axis2_env_t *env,
axis2_svc_t *svc,
int event_type)
{
@@ -53,10 +53,10 @@
AXIS2_ENV_CHECK(env, NULL);
- event_impl = AXIS2_MALLOC( (*env)->allocator, sizeof(axis2_event_impl_t) );
+ event_impl = AXIS2_MALLOC( env->allocator, sizeof(axis2_event_impl_t) );
if (!event_impl)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
@@ -70,10 +70,10 @@
}
/* initialize ops */
- event_impl->event.ops = AXIS2_MALLOC( (*env)->allocator, sizeof(axis2_event_ops_t) );
+ event_impl->event.ops = AXIS2_MALLOC( env->allocator, sizeof(axis2_event_ops_t) );
if (!event_impl->event.ops)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
axis2_event_free(&(event_impl->event), env);
return NULL;
}
@@ -87,7 +87,7 @@
axis2_svc_t* AXIS2_CALL
axis2_event_get_svc(struct axis2_event *event,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
return AXIS2_INTF_TO_IMPL(event)->svc;
@@ -95,7 +95,7 @@
int AXIS2_CALL
axis2_event_get_event_type(struct axis2_event *event,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
return AXIS2_INTF_TO_IMPL(event)->event_type;
@@ -103,7 +103,7 @@
axis2_status_t AXIS2_CALL
axis2_event_free (struct axis2_event *event,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
axis2_event_impl_t *event_impl = NULL;
@@ -113,11 +113,11 @@
if (event_impl->event.ops)
{
- AXIS2_FREE((*env)->allocator, event_impl->event.ops);
+ AXIS2_FREE(env->allocator, event_impl->event.ops);
event_impl->event.ops = NULL;
}
- AXIS2_FREE((*env)->allocator, event_impl);
+ AXIS2_FREE(env->allocator, event_impl);
event_impl = NULL;
return AXIS2_SUCCESS;
Modified: webservices/axis2/trunk/c/modules/core/engine/handler.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/handler.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/handler.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/handler.c Wed May 31 08:54:07 2006
@@ -33,52 +33,52 @@
axis2_status_t AXIS2_CALL
axis2_handler_free (struct axis2_handler * handler,
- axis2_env_t **env);
+ const axis2_env_t *env);
axis2_qname_t* AXIS2_CALL
axis2_handler_get_name(struct axis2_handler * handler,
- axis2_env_t **env) ;
+ const axis2_env_t *env) ;
axis2_status_t AXIS2_CALL
axis2_handler_invoke (struct axis2_handler * handler,
- axis2_env_t **env,
+ const axis2_env_t *env,
struct axis2_msg_ctx *msg_ctx);
axis2_param_t* AXIS2_CALL
axis2_handler_get_param (struct axis2_handler * handler,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_char_t *name);
axis2_status_t AXIS2_CALL
axis2_handler_init (struct axis2_handler * handler,
- axis2_env_t **env,
+ const axis2_env_t *env,
struct axis2_handler_desc *handler_desc);
axis2_handler_desc_t* AXIS2_CALL
axis2_handler_get_handler_desc (struct axis2_handler * handler,
- axis2_env_t **env);
+ const axis2_env_t *env);
/*void* AXIS2_CALL axis2_handler_get_derived(struct axis2_handler * handler,
- axis2_env_t **env);
+ const axis2_env_t *env);
axis2_status_t AXIS2_CALL axis2_handler_set_derived(struct axis2_handler * handler,
- axis2_env_t **env, void* derived);
+ const axis2_env_t *env, void* derived);
*/
axis2_handler_t* AXIS2_CALL
-axis2_handler_create(axis2_env_t **env)
+axis2_handler_create(const axis2_env_t *env)
{
axis2_handler_impl_t *handler_impl = NULL;
AXIS2_ENV_CHECK(env, NULL);
- handler_impl = AXIS2_MALLOC( (*env)->allocator, sizeof(axis2_handler_impl_t) );
+ handler_impl = AXIS2_MALLOC( env->allocator, sizeof(axis2_handler_impl_t) );
if (!handler_impl)
{
- AXIS2_ERROR_SET_ERROR_NUMBER((*env)->error, AXIS2_ERROR_NO_MEMORY);
- AXIS2_ERROR_SET_STATUS_CODE((*env)->error, AXIS2_FAILURE);
+ AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY);
+ AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE);
return NULL;
}
@@ -87,11 +87,11 @@
/* initialize ops */
handler_impl->handler.ops = NULL;
- handler_impl->handler.ops = AXIS2_MALLOC( (*env)->allocator, sizeof(axis2_handler_ops_t) );
+ handler_impl->handler.ops = AXIS2_MALLOC( env->allocator, sizeof(axis2_handler_ops_t) );
if (!handler_impl->handler.ops)
{
- AXIS2_ERROR_SET_ERROR_NUMBER((*env)->error, AXIS2_ERROR_NO_MEMORY);
- AXIS2_ERROR_SET_STATUS_CODE((*env)->error, AXIS2_FAILURE);
+ AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY);
+ AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE);
axis2_handler_free(&(handler_impl->handler), env);
return NULL;
}
@@ -122,18 +122,18 @@
axis2_status_t AXIS2_CALL
axis2_handler_free (struct axis2_handler * handler,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
axis2_handler_impl_t *handler_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
handler_impl = AXIS2_INTF_TO_IMPL(handler);
if (handler_impl->handler.ops)
{
- AXIS2_FREE((*env)->allocator, handler_impl->handler.ops);
+ AXIS2_FREE(env->allocator, handler_impl->handler.ops);
handler_impl->handler.ops = NULL;
}
- AXIS2_FREE((*env)->allocator, handler_impl);
+ AXIS2_FREE(env->allocator, handler_impl);
handler_impl = NULL;
return AXIS2_SUCCESS;
@@ -141,7 +141,7 @@
axis2_qname_t* AXIS2_CALL
axis2_handler_get_name(struct axis2_handler * handler,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
@@ -153,7 +153,7 @@
axis2_status_t AXIS2_CALL
axis2_handler_invoke (struct axis2_handler * handler,
- axis2_env_t **env,
+ const axis2_env_t *env,
struct axis2_msg_ctx *msg_ctx)
{
/**TODO invoke has to be implemented by an implementing handler */
@@ -162,7 +162,7 @@
axis2_param_t* AXIS2_CALL
axis2_handler_get_param (struct axis2_handler * handler,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_char_t *name)
{
AXIS2_ENV_CHECK(env, NULL);
@@ -175,7 +175,7 @@
axis2_status_t AXIS2_CALL
axis2_handler_init (struct axis2_handler * handler,
- axis2_env_t **env,
+ const axis2_env_t *env,
struct axis2_handler_desc *handler_desc)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -187,20 +187,20 @@
axis2_handler_desc_t* AXIS2_CALL
axis2_handler_get_handler_desc (struct axis2_handler * handler,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
return AXIS2_INTF_TO_IMPL(handler)->handler_desc;
}
/*void* AXIS2_CALL axis2_handler_get_derived(struct axis2_handler * handler,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
return AXIS2_INTF_TO_IMPL(handler)->derived;
}
axis2_status_t AXIS2_CALL axis2_handler_set_derived(struct axis2_handler * handler,
- axis2_env_t **env, void* derived)
+ const axis2_env_t *env, void* derived)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_INTF_TO_IMPL(handler)->derived = derived;
Modified: webservices/axis2/trunk/c/modules/core/engine/phase.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/phase.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/phase.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/phase.c Wed May 31 08:54:07 2006
@@ -51,113 +51,113 @@
axis2_status_t AXIS2_CALL
axis2_phase_add_handler_at(struct axis2_phase *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
int index,
axis2_handler_t *handler);
axis2_status_t AXIS2_CALL
axis2_phase_add_handler(struct axis2_phase *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t *handler);
axis2_status_t AXIS2_CALL
axis2_phase_invoke(struct axis2_phase *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx);
axis2_char_t* AXIS2_CALL
axis2_phase_get_name(struct axis2_phase *phase,
- axis2_env_t **env);
+ const axis2_env_t *env);
int AXIS2_CALL
axis2_phase_get_handler_count(struct axis2_phase *phase,
- axis2_env_t **env);
+ const axis2_env_t *env);
int AXIS2_CALL
_axis2_phase_get_before_after(axis2_handler_t *handler,
- axis2_env_t **env);
+ const axis2_env_t *env);
axis2_status_t AXIS2_CALL
axis2_phase_set_first_handler(struct axis2_phase *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler);
axis2_status_t AXIS2_CALL
axis2_phase_set_last_handler(struct axis2_phase *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler);
axis2_status_t AXIS2_CALL
axis2_phase_add_handler_desc(struct axis2_phase *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_desc_t * handler_desc);
axis2_bool_t AXIS2_CALL
_axis2_phase_is_valid_before(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler);
axis2_bool_t AXIS2_CALL
_axis2_phase_is_valid_after(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler);
axis2_status_t AXIS2_CALL
axis2_phase_insert_before(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler);
axis2_status_t AXIS2_CALL
axis2_phase_insert_after(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler) ;
axis2_status_t AXIS2_CALL
axis2_phase_insert_before_and_after(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler);
axis2_status_t AXIS2_CALL
axis2_phase_insert_handler_desc(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_desc_t * handler_desc);
axis2_array_list_t* AXIS2_CALL
axis2_phase_get_handlers(axis2_phase_t *phase,
- axis2_env_t **env);
+ const axis2_env_t *env);
axis2_status_t AXIS2_CALL
axis2_phase_invoke_start_from_handler(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_qname_t *qname,
axis2_msg_ctx_t *msg_ctx) ;
axis2_status_t AXIS2_CALL
axis2_phase_free (struct axis2_phase *phase,
- axis2_env_t **env);
+ const axis2_env_t *env);
axis2_phase_t* AXIS2_CALL
-axis2_phase_create(axis2_env_t **env,
+axis2_phase_create(const axis2_env_t *env,
const axis2_char_t *phase_name)
{
axis2_phase_impl_t *phase_impl = NULL;
AXIS2_ENV_CHECK(env, NULL);
- phase_impl = AXIS2_MALLOC( (*env)->allocator, sizeof(axis2_phase_impl_t) );
+ phase_impl = AXIS2_MALLOC( env->allocator, sizeof(axis2_phase_impl_t) );
if (!phase_impl)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
@@ -182,7 +182,7 @@
phase_impl->name = AXIS2_STRDUP(phase_name, env);
if (!(phase_impl->name))
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
axis2_phase_free(&(phase_impl->phase), env);
return NULL;
}
@@ -190,10 +190,10 @@
/* initialize ops */
phase_impl->phase.ops = NULL;
- phase_impl->phase.ops = AXIS2_MALLOC( (*env)->allocator, sizeof(axis2_phase_ops_t) );
+ phase_impl->phase.ops = AXIS2_MALLOC( env->allocator, sizeof(axis2_phase_ops_t) );
if (!phase_impl->phase.ops)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
axis2_phase_free(&(phase_impl->phase), env);
return NULL;
}
@@ -248,7 +248,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_add_handler_at(struct axis2_phase *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
int index,
axis2_handler_t *handler)
{
@@ -258,7 +258,7 @@
phase_impl = AXIS2_INTF_TO_IMPL(phase);
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI,
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"axis2_handler_t *%s added to the index %d of the phase %s",
AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_GET_NAME(handler, env), env),
index,
@@ -269,7 +269,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_add_handler(struct axis2_phase *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t *handler)
{
axis2_phase_impl_t *phase_impl = NULL;
@@ -278,7 +278,7 @@
phase_impl = AXIS2_INTF_TO_IMPL(phase);
- AXIS2_LOG_INFO((*env)->log, "Handler %s added to phase %s",
+ AXIS2_LOG_INFO(env->log, "Handler %s added to phase %s",
AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_GET_NAME(handler, env), env),
phase_impl->name);
@@ -287,7 +287,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_invoke(struct axis2_phase *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_msg_ctx_t *msg_ctx)
{
axis2_phase_impl_t *phase_impl = NULL;
@@ -309,7 +309,7 @@
}
else
{
- AXIS2_LOG_INFO((*env)->log,
+ AXIS2_LOG_INFO(env->log,
"Invoke the first handler %s within the phase %s",
AXIS2_QNAME_GET_LOCALPART(
AXIS2_HANDLER_GET_NAME(phase_impl->first_handler, env), env),
@@ -335,7 +335,7 @@
AXIS2_ARRAY_LIST_GET(phase_impl->handlers, env, index);
if (handler)
{
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI,
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Invoke the handler %s within the phase %s",
AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_GET_NAME(handler, env), env),
phase_impl->name);
@@ -359,7 +359,7 @@
}
else
{
- AXIS2_LOG_INFO((*env)->log, "Invoke the last handler %s within the phase %s",
+ AXIS2_LOG_INFO(env->log, "Invoke the last handler %s within the phase %s",
AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_GET_NAME(phase_impl->last_handler, env), env),
phase_impl->name);
status = AXIS2_HANDLER_INVOKE(phase_impl->last_handler, env, msg_ctx);
@@ -374,7 +374,7 @@
axis2_char_t* AXIS2_CALL
axis2_phase_get_name(struct axis2_phase *phase,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
return AXIS2_INTF_TO_IMPL(phase)->name;
@@ -382,7 +382,7 @@
int AXIS2_CALL
axis2_phase_get_handler_count(struct axis2_phase *phase,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
return AXIS2_ARRAY_LIST_SIZE(AXIS2_INTF_TO_IMPL(phase)->handlers, env );
@@ -393,7 +393,7 @@
int AXIS2_CALL
_axis2_phase_get_before_after(axis2_handler_t *handler,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
axis2_char_t *before = NULL, *after = NULL;
axis2_handler_desc_t *handler_desc = NULL;
@@ -404,14 +404,14 @@
handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(handler, env);
if (!handler_desc)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
rules = AXIS2_HANDLER_DESC_GET_RULES(handler_desc, env);
if (!rules)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -422,7 +422,7 @@
{
if (AXIS2_STRCMP(before, after) == 0 )
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_BEFORE_AFTER_HANDLERS_SAME, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_BEFORE_AFTER_HANDLERS_SAME, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
return AXIS2_PHASE_BOTH_BEFORE_AFTER;
@@ -443,7 +443,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_set_first_handler(struct axis2_phase *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler)
{
axis2_phase_impl_t *phase_impl = NULL;
@@ -454,14 +454,14 @@
if (phase_impl->first_handler_set)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_PHASE_FIRST_HANDLER_ALREADY_SET, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PHASE_FIRST_HANDLER_ALREADY_SET, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
else
{
if (_axis2_phase_get_before_after(handler, env) != AXIS2_PHASE_ANYWHERE)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_PHASE_FIRST_HANDLER, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_PHASE_FIRST_HANDLER, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
phase_impl->first_handler = handler;
@@ -473,7 +473,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_set_last_handler(struct axis2_phase *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler)
{
axis2_phase_impl_t *phase_impl = NULL;
@@ -484,14 +484,14 @@
if (phase_impl->last_handler_set)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_PHASE_LAST_HANDLER_ALREADY_SET, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PHASE_LAST_HANDLER_ALREADY_SET, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
else
{
if (_axis2_phase_get_before_after(handler, env) != AXIS2_PHASE_ANYWHERE)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_PHASE_LAST_HANDLER, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_PHASE_LAST_HANDLER, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
phase_impl->last_handler = handler;
@@ -503,7 +503,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_add_handler_desc(struct axis2_phase *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_desc_t * handler_desc)
{
axis2_phase_impl_t *phase_impl = NULL;
@@ -518,7 +518,7 @@
if (phase_impl->is_one_handler)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_PHASE_ADD_HANDLER_INVALID, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PHASE_ADD_HANDLER_INVALID, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
else
@@ -526,7 +526,7 @@
rules = AXIS2_HANDLER_DESC_GET_RULES(handler_desc, env);
if (!rules)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -537,14 +537,14 @@
{
if (AXIS2_ARRAY_LIST_SIZE(phase_impl->handlers, env) > 0 )
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_RULES, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_RULES, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
handler = AXIS2_HANDLER_DESC_GET_HANDLER(handler_desc, env);
if (!handler)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -558,7 +558,7 @@
handler = AXIS2_HANDLER_DESC_GET_HANDLER(handler_desc, env);
if (!handler)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
return axis2_phase_set_first_handler(phase, env, handler);
@@ -568,7 +568,7 @@
handler = AXIS2_HANDLER_DESC_GET_HANDLER(handler_desc, env);
if (!handler)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
return axis2_phase_set_last_handler(phase, env, handler);
@@ -578,7 +578,7 @@
handler = AXIS2_HANDLER_DESC_GET_HANDLER(handler_desc, env);
if (!handler)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -589,7 +589,7 @@
axis2_bool_t AXIS2_CALL
_axis2_phase_is_valid_before(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler)
{
axis2_phase_impl_t *phase_impl = NULL;
@@ -635,7 +635,7 @@
axis2_bool_t AXIS2_CALL
_axis2_phase_is_valid_after(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler)
{
axis2_phase_impl_t *phase_impl = NULL;
@@ -681,7 +681,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_insert_before(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler)
{
axis2_phase_impl_t *phase_impl = NULL;
@@ -698,21 +698,21 @@
handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(handler, env);
if (!handler_desc)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
rules = AXIS2_HANDLER_DESC_GET_RULES(handler_desc, env);
if (!rules)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
before = AXIS2_PHASE_RULE_GET_BEFORE(rules, env);
if (!before)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -721,14 +721,14 @@
handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(phase_impl->last_handler, env);
if (!handler_desc)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
handler_name = AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_DESC_GET_QNAME(handler_desc, env), env);
if (!handler_name)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -748,14 +748,14 @@
handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(temp_handler, env);
if (!handler_desc)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
handler_name = AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_DESC_GET_QNAME(handler_desc, env), env);
if (!handler_name)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -777,7 +777,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_insert_after(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler)
{
axis2_phase_impl_t *phase_impl = NULL;
@@ -794,21 +794,21 @@
handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(handler, env);
if (!handler_desc)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
rules = AXIS2_HANDLER_DESC_GET_RULES(handler_desc, env);
if (!rules)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
after = AXIS2_PHASE_RULE_GET_AFTER(rules, env);
if (!after)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -817,14 +817,14 @@
handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(phase_impl->first_handler, env);
if (!handler_desc)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
handler_name = AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_DESC_GET_QNAME(handler_desc, env), env);
if (!handler_name)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -844,14 +844,14 @@
handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(temp_handler, env);
if (!handler_desc)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
handler_name = AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_DESC_GET_QNAME(handler_desc, env), env);
if (!handler_name)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -873,7 +873,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_insert_before_and_after(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_t * handler)
{
int before = -1;
@@ -893,28 +893,28 @@
handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(handler, env);
if (!handler_desc)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
rules = AXIS2_HANDLER_DESC_GET_RULES(handler_desc, env);
if (!rules)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
before_name = AXIS2_PHASE_RULE_GET_BEFORE(rules, env);
if (!before_name)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
after_name = AXIS2_PHASE_RULE_GET_AFTER(rules, env);
if (!after_name)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -923,14 +923,14 @@
handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(phase_impl->first_handler, env);
if (!handler_desc)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
before_handler_name = AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_DESC_GET_QNAME(handler_desc, env), env);
if (!handler_name)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
@@ -940,14 +940,14 @@
handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(phase_impl->last_handler, env);
if (!handler_desc)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
after_handler_name = AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_DESC_GET_QNAME(handler_desc, env), env);
if (!handler_name)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
@@ -983,14 +983,14 @@
handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(temp_handler, env);
if (!handler_desc)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
handler_name = AXIS2_QNAME_GET_LOCALPART(AXIS2_HANDLER_DESC_GET_QNAME(handler_desc, env), env);
if (!handler_name)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -1005,7 +1005,7 @@
/*both the before and after indexes has been found */
if (after > before)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
else
@@ -1026,7 +1026,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_insert_handler_desc(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_desc_t * handler_desc)
{
axis2_phase_impl_t *phase_impl = NULL;
@@ -1042,19 +1042,19 @@
if (!handler)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
if (!_axis2_phase_is_valid_after(phase, env, handler))
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
if (!_axis2_phase_is_valid_before(phase, env, handler))
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -1083,7 +1083,7 @@
axis2_array_list_t* AXIS2_CALL
axis2_phase_get_handlers(axis2_phase_t *phase,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
return AXIS2_INTF_TO_IMPL(phase)->handlers;
@@ -1091,7 +1091,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_invoke_start_from_handler(axis2_phase_t *phase,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_qname_t *qname,
axis2_msg_ctx_t *msg_ctx)
{
@@ -1115,7 +1115,7 @@
axis2_handler_desc_t *handler_desc = AXIS2_HANDLER_GET_HANDLER_DESC(handler, env);
if (!handler_desc)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -1133,7 +1133,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_free (struct axis2_phase *phase,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
axis2_phase_impl_t *phase_impl = NULL;
@@ -1143,13 +1143,13 @@
if (phase_impl->phase.ops)
{
- AXIS2_FREE((*env)->allocator, phase_impl->phase.ops);
+ AXIS2_FREE(env->allocator, phase_impl->phase.ops);
phase_impl->phase.ops = NULL;
}
if (phase_impl->name)
{
- AXIS2_FREE((*env)->allocator, phase_impl->name);
+ AXIS2_FREE(env->allocator, phase_impl->name);
phase_impl->name = NULL;
}
@@ -1159,7 +1159,7 @@
phase_impl->handlers = NULL;
}
- AXIS2_FREE((*env)->allocator, phase_impl);
+ AXIS2_FREE(env->allocator, phase_impl);
phase_impl = NULL;
return AXIS2_SUCCESS;
Modified: webservices/axis2/trunk/c/modules/core/engine/req_uri_disp.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/req_uri_disp.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/req_uri_disp.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/req_uri_disp.c Wed May 31 08:54:07 2006
@@ -26,22 +26,22 @@
axis2_status_t AXIS2_CALL
axis2_req_uri_disp_invoke (struct axis2_handler * handler,
- axis2_env_t **env,
+ const axis2_env_t *env,
struct axis2_msg_ctx *msg_ctx);
axis2_svc_t* AXIS2_CALL
axis2_req_uri_disp_find_svc(axis2_msg_ctx_t *msg_ctx,
- axis2_env_t **env);
+ const axis2_env_t *env);
axis2_op_t* AXIS2_CALL
axis2_req_uri_disp_find_op(axis2_msg_ctx_t *msg_ctx,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_svc_t *svc);
axis2_disp_t* AXIS2_CALL
-axis2_req_uri_disp_create(axis2_env_t **env)
+axis2_req_uri_disp_create(const axis2_env_t *env)
{
axis2_disp_t *disp = NULL;
axis2_handler_t *handler = NULL;
@@ -56,14 +56,14 @@
disp = axis2_disp_create(env, qname);
if (!disp)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
handler = AXIS2_DISP_GET_BASE(disp, env);
if (!handler)
{
- AXIS2_ERROR_SET((*env)->error,
+ AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return NULL;
}
@@ -91,7 +91,7 @@
*/
axis2_svc_t* AXIS2_CALL
axis2_req_uri_disp_find_svc(axis2_msg_ctx_t *msg_ctx,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
axis2_endpoint_ref_t *endpoint_ref = NULL;
axis2_svc_t *svc = NULL;
@@ -108,7 +108,7 @@
if (address)
{
axis2_char_t **url_tokens = NULL;
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI,
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Checking for service using target endpoint address : %s", address);
url_tokens = axis2_parse_request_url_for_svc_and_op(env, address);
@@ -128,12 +128,12 @@
{
svc = AXIS2_CONF_GET_SVC(conf, env, url_tokens[0]);
if (svc)
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI,
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Service found using target endpoint address");
}
}
}
- AXIS2_FREE((*env)->allocator, url_tokens);
+ AXIS2_FREE(env->allocator, url_tokens);
url_tokens = NULL;
}
}
@@ -151,14 +151,14 @@
*/
axis2_op_t* AXIS2_CALL
axis2_req_uri_disp_find_op(axis2_msg_ctx_t *msg_ctx,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_svc_t *svc)
{
axis2_endpoint_ref_t *endpoint_ref = NULL;
axis2_op_t *op = NULL;
AXIS2_ENV_CHECK(env, NULL);
- AXIS2_PARAM_CHECK((*env)->error, svc, NULL);
+ AXIS2_PARAM_CHECK(env->error, svc, NULL);
endpoint_ref = AXIS2_MSG_CTX_GET_TO(msg_ctx, env);
@@ -178,20 +178,20 @@
if (url_tokens[1])
{
axis2_qname_t *op_qname = NULL;
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI,
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Checking for operation using target endpoint uri fragment : %s", url_tokens[1]);
op_qname = axis2_qname_create(env, url_tokens[1], NULL, NULL);
op = AXIS2_SVC_GET_OP_WITH_NAME(svc, env, AXIS2_QNAME_GET_LOCALPART(op_qname, env));
AXIS2_QNAME_FREE(op_qname, env);
if (op)
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI,
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Operation found using target endpoint uri fragment");
}
if(NULL != url_tokens[0])
- AXIS2_FREE((*env)->allocator, url_tokens[0]);
+ AXIS2_FREE(env->allocator, url_tokens[0]);
if(NULL != url_tokens[1])
- AXIS2_FREE((*env)->allocator, url_tokens[1]);
- AXIS2_FREE((*env)->allocator, url_tokens);
+ AXIS2_FREE(env->allocator, url_tokens[1]);
+ AXIS2_FREE(env->allocator, url_tokens);
}
}
}
@@ -201,7 +201,7 @@
axis2_status_t AXIS2_CALL
axis2_req_uri_disp_invoke(struct axis2_handler * handler,
- axis2_env_t **env,
+ const axis2_env_t *env,
struct axis2_msg_ctx *msg_ctx)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
Modified: webservices/axis2/trunk/c/modules/core/engine/soap_action_disp.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/soap_action_disp.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/soap_action_disp.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/soap_action_disp.c Wed May 31 08:54:07 2006
@@ -26,23 +26,23 @@
axis2_status_t AXIS2_CALL
axis2_soap_action_disp_invoke (struct axis2_handler * handler,
- axis2_env_t **env,
+ const axis2_env_t *env,
struct axis2_msg_ctx *msg_ctx);
axis2_svc_t* AXIS2_CALL
axis2_soap_action_disp_find_svc(axis2_msg_ctx_t *msg_ctx,
- axis2_env_t **env);
+ const axis2_env_t *env);
axis2_op_t* AXIS2_CALL
axis2_soap_action_disp_find_op(axis2_msg_ctx_t *msg_ctx,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_svc_t *svc);
axis2_disp_t* AXIS2_CALL
-axis2_soap_action_disp_create(axis2_env_t **env)
+axis2_soap_action_disp_create(const axis2_env_t *env)
{
axis2_disp_t *disp = NULL;
axis2_handler_t *handler = NULL;
@@ -57,14 +57,14 @@
disp = axis2_disp_create(env, qname);
if (!disp)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
handler = AXIS2_DISP_GET_BASE(disp, env);
if (!handler)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return NULL;
}
@@ -91,11 +91,11 @@
*/
axis2_svc_t* AXIS2_CALL
axis2_soap_action_disp_find_svc(axis2_msg_ctx_t *msg_ctx,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
AXIS2_ENV_CHECK(env, NULL);
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI, "Checking for service using SOAPAction is a TODO item");
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Checking for service using SOAPAction is a TODO item");
return NULL;
}
@@ -109,20 +109,20 @@
*/
axis2_op_t* AXIS2_CALL
axis2_soap_action_disp_find_op(axis2_msg_ctx_t *msg_ctx,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_svc_t *svc)
{
axis2_char_t *action = NULL;
axis2_op_t *op = NULL;
AXIS2_ENV_CHECK(env, NULL);
- AXIS2_PARAM_CHECK((*env)->error, svc, NULL);
+ AXIS2_PARAM_CHECK(env->error, svc, NULL);
action = AXIS2_MSG_CTX_GET_SOAP_ACTION(msg_ctx, env);
if (action)
{
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI,
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Checking for operation using SOAPAction : %s", action);
op = AXIS2_SVC_GET_OP_BY_SOAP_ACTION(svc, env, action);
@@ -152,7 +152,7 @@
}
if (op)
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI, "Operation found using SOAPAction");
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Operation found using SOAPAction");
}
return op;
@@ -160,7 +160,7 @@
axis2_status_t AXIS2_CALL
axis2_soap_action_disp_invoke(struct axis2_handler * handler,
- axis2_env_t **env,
+ const axis2_env_t *env,
struct axis2_msg_ctx *msg_ctx)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
Modified: webservices/axis2/trunk/c/modules/core/engine/soap_body_disp.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/engine/soap_body_disp.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/soap_body_disp.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/soap_body_disp.c Wed May 31 08:54:07 2006
@@ -26,22 +26,22 @@
axis2_status_t AXIS2_CALL
axis2_soap_body_disp_invoke (struct axis2_handler * handler,
- axis2_env_t **env,
+ const axis2_env_t *env,
struct axis2_msg_ctx *msg_ctx);
axis2_svc_t* AXIS2_CALL
axis2_soap_body_disp_find_svc(axis2_msg_ctx_t *msg_ctx,
- axis2_env_t **env);
+ const axis2_env_t *env);
axis2_op_t* AXIS2_CALL
axis2_soap_body_disp_find_op(axis2_msg_ctx_t *msg_ctx,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_svc_t *svc);
axis2_disp_t* AXIS2_CALL
-axis2_soap_body_disp_create(axis2_env_t **env)
+axis2_soap_body_disp_create(const axis2_env_t *env)
{
axis2_disp_t *disp = NULL;
axis2_handler_t *handler = NULL;
@@ -56,7 +56,7 @@
disp = axis2_disp_create(env, qname);
if (!disp)
{
- AXIS2_ERROR_SET((*env)->error,
+ AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
@@ -64,7 +64,7 @@
handler = AXIS2_DISP_GET_BASE(disp, env);
if (!handler)
{
- AXIS2_ERROR_SET((*env)->error,
+ AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
return NULL;
}
@@ -92,7 +92,7 @@
*/
axis2_svc_t* AXIS2_CALL
axis2_soap_body_disp_find_svc(axis2_msg_ctx_t *msg_ctx,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
axis2_soap_envelope_t *soap_envelope = NULL;
axis2_svc_t *svc = NULL;
@@ -125,7 +125,7 @@
if (uri)
{
axis2_char_t **url_tokens = NULL;
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI,
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Checking for service using SOAP message body's first child's namespace URI : %s", uri);
url_tokens = axis2_parse_request_url_for_svc_and_op(env, uri);
@@ -145,14 +145,14 @@
{
svc = AXIS2_CONF_GET_SVC(conf, env, url_tokens[0]);
if (svc)
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI,
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Service found using SOAP message body's first child's namespace URI");
}
}
- AXIS2_FREE((*env)->allocator, url_tokens[0]);
+ AXIS2_FREE(env->allocator, url_tokens[0]);
}
- AXIS2_FREE((*env)->allocator, url_tokens);
+ AXIS2_FREE(env->allocator, url_tokens);
url_tokens = NULL;
}
}
@@ -176,14 +176,14 @@
*/
axis2_op_t* AXIS2_CALL
axis2_soap_body_disp_find_op(axis2_msg_ctx_t *msg_ctx,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_svc_t *svc)
{
axis2_soap_envelope_t *soap_envelope = NULL;
axis2_op_t *op = NULL;
AXIS2_ENV_CHECK(env, NULL);
- AXIS2_PARAM_CHECK((*env)->error, svc, NULL);
+ AXIS2_PARAM_CHECK(env->error, svc, NULL);
soap_envelope = AXIS2_MSG_CTX_GET_SOAP_ENVELOPE(msg_ctx, env);
if (soap_envelope)
@@ -208,7 +208,7 @@
if (element_name)
{
axis2_qname_t *op_qname = NULL;
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI,
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Checking for operation using SOAP message body's first child's local name : %s",
element_name);
op_qname = axis2_qname_create(env, element_name, NULL, NULL);
@@ -217,7 +217,7 @@
AXIS2_QNAME_FREE(op_qname, env);
if (op)
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI,
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"Operation found using SOAP message body's first child's local name");
}
@@ -232,7 +232,7 @@
axis2_status_t AXIS2_CALL
axis2_soap_body_disp_invoke(struct axis2_handler * handler,
- axis2_env_t **env,
+ const axis2_env_t *env,
struct axis2_msg_ctx *msg_ctx)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
Modified: webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c (original)
+++ webservices/axis2/trunk/c/modules/core/phaseresolver/phase_holder.c Wed May 31 08:54:07 2006
@@ -35,44 +35,44 @@
axis2_status_t AXIS2_CALL
axis2_phase_holder_free (
axis2_phase_holder_t *phase_holder,
- axis2_env_t **env);
+ const axis2_env_t *env);
axis2_bool_t AXIS2_CALL
axis2_phase_holder_is_phase_exist(axis2_phase_holder_t *phase_holder,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_char_t *phase_name);
axis2_status_t AXIS2_CALL
axis2_phase_holder_add_handler(axis2_phase_holder_t *phase_holder,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_desc_t *handler);
axis2_phase_t * AXIS2_CALL
axis2_phase_holder_get_phase(axis2_phase_holder_t *phase_holder,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_char_t *phase_name);
axis2_status_t AXIS2_CALL
axis2_phase_holder_build_transport_handler_chain(axis2_phase_holder_t *phase_holder,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_phase_t *phase,
axis2_array_list_t *handlers);
/************************** End of function prototypes ************************/
AXIS2_DECLARE(axis2_phase_holder_t *)
-axis2_phase_holder_create (axis2_env_t **env)
+axis2_phase_holder_create (const axis2_env_t *env)
{
axis2_phase_holder_impl_t *phase_holder_impl = NULL;
AXIS2_ENV_CHECK(env, NULL);
- phase_holder_impl = (axis2_phase_holder_impl_t *) AXIS2_MALLOC((*env)->
+ phase_holder_impl = (axis2_phase_holder_impl_t *) AXIS2_MALLOC(env->
allocator, sizeof(axis2_phase_holder_impl_t));
if(NULL == phase_holder_impl)
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
@@ -80,11 +80,11 @@
phase_holder_impl->phase_holder.ops = NULL;
phase_holder_impl->phase_holder.ops =
- AXIS2_MALLOC ((*env)->allocator, sizeof(axis2_phase_holder_ops_t));
+ AXIS2_MALLOC (env->allocator, sizeof(axis2_phase_holder_ops_t));
if(NULL == phase_holder_impl->phase_holder.ops)
{
axis2_phase_holder_free(&(phase_holder_impl->phase_holder), env);
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
@@ -102,12 +102,15 @@
}
AXIS2_DECLARE(axis2_phase_holder_t *)
-axis2_phase_holder_create_with_phases (axis2_env_t **env, axis2_array_list_t *phases)
+axis2_phase_holder_create_with_phases (const axis2_env_t *env, axis2_array_list_t *phases)
{
axis2_phase_holder_impl_t *phase_holder_impl = NULL;
AXIS2_ENV_CHECK(env, NULL);
- AXIS2_PARAM_CHECK((*env)->error, phases, NULL);
+
+ if (!phases)
+ return NULL;
+ /*AXIS2_PARAM_CHECK(env->error, phases, NULL);*/
phase_holder_impl = (axis2_phase_holder_impl_t *)axis2_phase_holder_create(env);
@@ -120,7 +123,7 @@
axis2_status_t AXIS2_CALL
axis2_phase_holder_free (axis2_phase_holder_t *phase_holder,
- axis2_env_t **env)
+ const axis2_env_t *env)
{
axis2_phase_holder_impl_t *phase_holder_impl = NULL;
@@ -136,13 +139,13 @@
if(NULL != phase_holder->ops)
{
- AXIS2_FREE((*env)->allocator, phase_holder->ops);
+ AXIS2_FREE(env->allocator, phase_holder->ops);
phase_holder->ops = NULL;
}
if(phase_holder_impl)
{
- AXIS2_FREE((*env)->allocator, phase_holder_impl);
+ AXIS2_FREE(env->allocator, phase_holder_impl);
phase_holder_impl = NULL;
}
@@ -157,7 +160,7 @@
*/
axis2_bool_t AXIS2_CALL
axis2_phase_holder_is_phase_exist(axis2_phase_holder_t *phase_holder,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_char_t *phase_name)
{
int size = 0;
@@ -166,7 +169,7 @@
axis2_phase_holder_impl_t *phase_holder_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
- AXIS2_PARAM_CHECK((*env)->error, phase_name, AXIS2_FALSE);
+ AXIS2_PARAM_CHECK(env->error, phase_name, AXIS2_FALSE);
phase_holder_impl = AXIS2_INTF_TO_IMPL(phase_holder);
size = AXIS2_ARRAY_LIST_SIZE(phase_holder_impl->phase_list, env);
@@ -193,15 +196,15 @@
*/
axis2_status_t AXIS2_CALL
axis2_phase_holder_add_handler(axis2_phase_holder_t *phase_holder,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_handler_desc_t *handler)
{
axis2_char_t *phase_name = NULL;
axis2_status_t status = AXIS2_FAILURE;
- AXIS2_LOG_TRACE((*env)->log, AXIS2_LOG_SI, "axis2_phase_holder_add_handler start");
+ AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_phase_holder_add_handler start");
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, handler, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, handler, AXIS2_FAILURE);
phase_name = AXIS2_PHASE_RULE_GET_NAME(
AXIS2_HANDLER_DESC_GET_RULES(handler, env), env);
@@ -212,15 +215,15 @@
phase = axis2_phase_holder_get_phase(phase_holder, env, phase_name);
status = AXIS2_PHASE_ADD_HANDLER_DESC(phase, env, handler);
- AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI, "Add handler %s to phase %s",
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Add handler %s to phase %s",
AXIS2_QNAME_TO_STRING(AXIS2_HANDLER_DESC_GET_QNAME(handler, env), env), phase_name);
}
else
{
- AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_PHASE, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_PHASE, AXIS2_FAILURE);
status = AXIS2_FAILURE;
}
- AXIS2_LOG_TRACE((*env)->log, AXIS2_LOG_SI, "axis2_phase_holder_add_handler end status = %s",
+ AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_phase_holder_add_handler end status = %s",
status ? "SUCCESS" : "FAILURE");
return status;
}
@@ -233,7 +236,7 @@
*/
axis2_phase_t * AXIS2_CALL
axis2_phase_holder_get_phase(axis2_phase_holder_t *phase_holder,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_char_t *phase_name)
{
int size = 0;
@@ -242,7 +245,7 @@
axis2_phase_t *phase = NULL;
AXIS2_ENV_CHECK(env, NULL);
- AXIS2_PARAM_CHECK((*env)->error, phase_name, NULL);
+ AXIS2_PARAM_CHECK(env->error, phase_name, NULL);
phase_holder_impl = AXIS2_INTF_TO_IMPL(phase_holder);
@@ -272,7 +275,7 @@
*/
axis2_status_t AXIS2_CALL
axis2_phase_holder_build_transport_handler_chain(axis2_phase_holder_t *phase_holder,
- axis2_env_t **env,
+ const axis2_env_t *env,
axis2_phase_t *phase,
axis2_array_list_t *handlers)
{
@@ -283,8 +286,8 @@
axis2_handler_desc_t *handler_desc = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, phase, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK((*env)->error, handlers, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, phase, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, handlers, AXIS2_FAILURE);
size = AXIS2_ARRAY_LIST_SIZE(handlers, env);
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org