axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r410566 [22/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/...
Date Wed, 31 May 2006 15:54:39 GMT
Modified: webservices/axis2/trunk/c/modules/core/description/svc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/svc.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/svc.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/svc.c Wed May 31 08:54:07 2006
@@ -44,228 +44,228 @@
 /*************************** Function headers ********************************/
 
 axis2_status_t AXIS2_CALL 
-axis2_svc_free (axis2_svc_t *svc, axis2_env_t **env);
+axis2_svc_free (axis2_svc_t *svc, const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
-axis2_svc_add_op (axis2_svc_t *svc, axis2_env_t **env
+axis2_svc_add_op (axis2_svc_t *svc, const axis2_env_t *env
 		,                   axis2_op_t *op);
 
 axis2_op_t * AXIS2_CALL
-axis2_svc_get_op_with_qname (axis2_svc_t *svc, axis2_env_t **env,
+axis2_svc_get_op_with_qname (axis2_svc_t *svc, const axis2_env_t *env,
 		                            axis2_qname_t *op_name);
 		
 axis2_op_t * AXIS2_CALL
-axis2_svc_get_op_with_name (axis2_svc_t *svc, axis2_env_t **env,
+axis2_svc_get_op_with_name (axis2_svc_t *svc, const axis2_env_t *env,
 		                            const axis2_char_t* op_name);
 
 axis2_hash_t * AXIS2_CALL
-axis2_svc_get_ops (axis2_svc_t *svc, axis2_env_t **env);
+axis2_svc_get_ops (axis2_svc_t *svc, const axis2_env_t *env);
 		
 axis2_status_t AXIS2_CALL
-axis2_svc_set_parent (axis2_svc_t *svc, axis2_env_t **env, 
+axis2_svc_set_parent (axis2_svc_t *svc, const axis2_env_t *env, 
                         axis2_svc_grp_t *svc_grp);
 
 axis2_svc_grp_t * AXIS2_CALL
-axis2_svc_get_parent (axis2_svc_t *svc, axis2_env_t **env);
+axis2_svc_get_parent (axis2_svc_t *svc, const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_qname (axis2_svc_t *svc, 
-                    axis2_env_t **env,
+                    const axis2_env_t *env,
                     axis2_qname_t *qname);
 
 axis2_qname_t * AXIS2_CALL
 axis2_svc_get_qname (const axis2_svc_t *svc, 
-                    axis2_env_t **env);	
+                    const axis2_env_t *env);	
 
 axis2_status_t AXIS2_CALL
 axis2_svc_add_param (axis2_svc_t *svc, 
-                        axis2_env_t **env, 
+                        const axis2_env_t *env, 
                         axis2_param_t *param);
 
 axis2_param_t * AXIS2_CALL
 axis2_svc_get_param (axis2_svc_t *svc, 
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
 		                const axis2_char_t *name);
 
 axis2_array_list_t * AXIS2_CALL
 axis2_svc_get_params (axis2_svc_t *svc, 
-                        axis2_env_t **env);
+                        const axis2_env_t *env);
 
 axis2_bool_t AXIS2_CALL
 axis2_svc_is_param_locked (axis2_svc_t *svc, 
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
 		                    axis2_char_t *param_name);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_svc_interface(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_wsdl_interface_t *svc_interface);
 
 axis2_wsdl_interface_t * AXIS2_CALL
 axis2_svc_get_svc_interface(axis2_svc_t *svc,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_engage_module(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_module_desc_t * moduleref,
                             axis2_conf_t * conf);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_add_module_ops(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_module_desc_t * module,
                             axis2_conf_t * conf);
                                 
 axis2_status_t AXIS2_CALL
 axis2_svc_add_to_engaged_module_list(axis2_svc_t *svc,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_module_desc_t *module_name);
                                     
 axis2_array_list_t * AXIS2_CALL
 axis2_svc_get_engaged_modules(axis2_svc_t *svc,
-                                axis2_env_t **env);
+                                const axis2_env_t *env);
 
 
 void *AXIS2_CALL
 axis2_svc_get_wsdl_op(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_qname_t *op_name);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_context_path(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_char_t *context_path);
 
 axis2_char_t * AXIS2_CALL
 axis2_svc_get_context_path(axis2_svc_t *svc,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_style(axis2_svc_t *svc,
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
                         axis2_char_t * style);
 
 axis2_char_t * AXIS2_CALL
 axis2_svc_get_style(axis2_svc_t *svc,
-                    axis2_env_t **env);
+                    const axis2_env_t *env);
 
 axis2_flow_t * AXIS2_CALL
 axis2_svc_get_inflow(axis2_svc_t *svc,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_inflow(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_flow_t *inflow);
 
 axis2_flow_t * AXIS2_CALL
 axis2_svc_get_outflow(axis2_svc_t *svc,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_outflow(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_flow_t *outflow);
 
 axis2_flow_t *AXIS2_CALL
 axis2_svc_get_fault_inflow(axis2_svc_t *svc,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_fault_inflow(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_flow_t *fault_flow);
 
 axis2_flow_t * AXIS2_CALL
 axis2_svc_get_fault_outflow(axis2_svc_t *svc,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_fault_outflow(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_flow_t *fault_flow);
 
 axis2_op_t * AXIS2_CALL
 axis2_svc_get_op_by_soap_action(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_char_t *soap_action);
 
 
 axis2_op_t * AXIS2_CALL
 axis2_svc_get_op_by_soap_action_and_endpoint(axis2_svc_t *svc,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_char_t *soap_action,
                                         axis2_qname_t * endpoint);       
 
 axis2_char_t * AXIS2_CALL
 axis2_svc_get_axis2_svc_name(axis2_svc_t *svc,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_axis2_svc_name(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_char_t *axis_svc_name);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_last_update(axis2_svc_t *svc,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 long AXIS2_CALL
 axis2_svc_get_last_update(axis2_svc_t *svc,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_char_t * AXIS2_CALL
 axis2_svc_get_filename(axis2_svc_t *svc,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_filename(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_char_t *filename);
 
 axis2_hash_t * AXIS2_CALL
 axis2_svc_get_endpoints(axis2_svc_t *svc,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_endpoints(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_hash_t * endpoints);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_endpoint(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_wsdl_endpoint_t * endpoint);
 
 axis2_wsdl_endpoint_t * AXIS2_CALL
 axis2_svc_get_endpoint(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_qname_t * qname);
 
 axis2_char_t * AXIS2_CALL
 axis2_svc_get_namespace(axis2_svc_t *svc,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_add_mapping(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_char_t * mapping_key , 
                             axis2_op_t * op_desc);
  
 axis2_status_t AXIS2_CALL
 axis2_svc_add_module_ref(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_qname_t *moduleref);
 
 axis2_array_list_t *AXIS2_CALL
 axis2_svc_get_modules(axis2_svc_t *svc,
-                        axis2_env_t **env);
+                        const axis2_env_t *env);
 
 /************************* End of function headers ***************************/
 
 axis2_svc_t * AXIS2_CALL
-axis2_svc_create (axis2_env_t **env)
+axis2_svc_create (const axis2_env_t *env)
 {
     axis2_svc_impl_t *svc_impl = NULL;
     axis2_array_list_t *array_list_l = NULL;
@@ -277,10 +277,10 @@
     AXIS2_ENV_CHECK(env, NULL);
     
 	svc_impl = (axis2_svc_impl_t *)
-		AXIS2_MALLOC ((*env)->allocator, sizeof(axis2_svc_impl_t));
+		AXIS2_MALLOC (env->allocator, sizeof(axis2_svc_impl_t));
     if(NULL == svc_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;
 	}
     
@@ -298,7 +298,7 @@
 	if(NULL == svc_impl->svc.param_container)
 	{
         axis2_svc_free(&(svc_impl->svc), 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;		
 	}
     
@@ -306,7 +306,7 @@
 	if(NULL == svc_impl->svc.flow_container)
 	{
         axis2_svc_free(&(svc_impl->svc), 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;
 	}
     
@@ -314,7 +314,7 @@
 	if(NULL == svc_impl->svc.wsdl_svc)
 	{
         axis2_svc_free(&(svc_impl->svc), 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;
 	}
     
@@ -322,7 +322,7 @@
 	if(NULL == svc_impl->wasaction_op_map)
 	{
         axis2_svc_free(&(svc_impl->svc), 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;
 	}
     
@@ -331,15 +331,15 @@
     if(NULL == svc_impl->module_list)
     {
         axis2_svc_free(&(svc_impl->svc), 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;
     }
     
-    svc_impl->svc.ops = AXIS2_MALLOC((*env)->allocator, sizeof(axis2_svc_ops_t));
+    svc_impl->svc.ops = AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_ops_t));
 	if(NULL == svc_impl->svc.ops)
 	{
         axis2_svc_free(&(svc_impl->svc), 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;
 	}
 
@@ -347,7 +347,7 @@
     if(NULL == wsdl_interface_l)
     {
         axis2_svc_free(&(svc_impl->svc), 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;
     }
     
@@ -362,7 +362,7 @@
     if(NULL == param_container_l)
     {
         axis2_svc_free(&(svc_impl->svc), 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;
     } 
     property = axis2_property_create(env);
@@ -380,7 +380,7 @@
     if(NULL == array_list_l)
     {
         axis2_svc_free(&(svc_impl->svc), 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;
     }
     property = axis2_property_create(env);
@@ -452,18 +452,18 @@
 }
 
 axis2_svc_t * AXIS2_CALL
-axis2_svc_create_with_qname (axis2_env_t **env, 
+axis2_svc_create_with_qname (const axis2_env_t *env, 
                                 axis2_qname_t *qname)
 {
     axis2_svc_impl_t *svc_impl = NULL;
     axis2_status_t status = AXIS2_FAILURE;
     
-    AXIS2_PARAM_CHECK((*env)->error, qname, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
     
 	svc_impl = AXIS2_INTF_TO_IMPL(axis2_svc_create(env));
 	if(NULL == svc_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;
 	}
     
@@ -478,18 +478,18 @@
 }
 
 AXIS2_DECLARE(axis2_svc_t *)
-axis2_svc_create_with_wsdl_svc (axis2_env_t **env, 
+axis2_svc_create_with_wsdl_svc (const axis2_env_t *env, 
                                 axis2_wsdl_svc_t *wsdl_svc)
 {
     axis2_svc_impl_t *svc_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, wsdl_svc, NULL);
+    AXIS2_PARAM_CHECK(env->error, wsdl_svc, NULL);
     
 	 svc_impl = AXIS2_INTF_TO_IMPL(axis2_svc_create(env));
     
 	if(NULL == svc_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;
 	}
     if(NULL != svc_impl->svc.wsdl_svc)
@@ -506,7 +506,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_free (axis2_svc_t *svc, 
-                axis2_env_t **env)
+                const axis2_env_t *env)
 {
     axis2_svc_impl_t *svc_impl = NULL;
     
@@ -533,7 +533,7 @@
 
     if(svc_impl->filename)
     {
-        AXIS2_FREE((*env)->allocator, svc_impl->filename);
+        AXIS2_FREE(env->allocator, svc_impl->filename);
         svc_impl->filename = NULL;
     }
     
@@ -569,19 +569,19 @@
 
     if(NULL != svc_impl->axis_svc_name)
     {
-        AXIS2_FREE((*env)->allocator, svc_impl->axis_svc_name);
+        AXIS2_FREE(env->allocator, svc_impl->axis_svc_name);
         svc_impl->axis_svc_name = NULL;        
     }        
     
     if(NULL != svc_impl->svc.ops)
     {
-	    AXIS2_FREE((*env)->allocator, svc_impl->svc.ops);
+	    AXIS2_FREE(env->allocator, svc_impl->svc.ops);
         svc_impl->svc.ops = NULL;
     }
 
     if(svc_impl)
     {
-	    AXIS2_FREE((*env)->allocator, svc_impl);
+	    AXIS2_FREE(env->allocator, svc_impl);
         svc_impl = NULL;
     }
     
@@ -591,13 +591,13 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_add_op (axis2_svc_t *svc,
-                    axis2_env_t **env,
+                    const axis2_env_t *env,
                     axis2_op_t *op)
 {
     axis2_status_t status = AXIS2_FAILURE;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, op, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE);
     
     status = AXIS2_OP_SET_PARENT(op, env, svc);
     if(AXIS2_SUCCESS == status)
@@ -612,7 +612,7 @@
 
 axis2_op_t * AXIS2_CALL
 axis2_svc_get_op_with_qname (axis2_svc_t *svc,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
 		                                axis2_qname_t *op_name)
 {
     axis2_svc_impl_t *svc_impl = NULL;
@@ -622,7 +622,7 @@
     /*axis2_hash_t *all_ops = NULL; */
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, op_name, NULL);
+    AXIS2_PARAM_CHECK(env->error, op_name, NULL);
     svc_impl = AXIS2_INTF_TO_IMPL(svc);
     
     op_qname_str = AXIS2_QNAME_TO_STRING(op_name, env);    
@@ -657,14 +657,14 @@
 
 axis2_op_t * AXIS2_CALL
 axis2_svc_get_op_with_name (axis2_svc_t *svc, 
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
 		                            const axis2_char_t* nc_name)
 {
     axis2_wsdl_interface_t *wsdl_interface = NULL;
     axis2_hash_t *ops = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, nc_name, NULL);
+    AXIS2_PARAM_CHECK(env->error, nc_name, NULL);
     
     wsdl_interface = axis2_svc_get_svc_interface(svc, env);
     ops = AXIS2_WSDL_INTERFACE_GET_OPS(wsdl_interface, env);
@@ -673,7 +673,7 @@
 
 axis2_hash_t * AXIS2_CALL
 axis2_svc_get_ops (axis2_svc_t *svc, 
-                            axis2_env_t **env)
+                            const axis2_env_t *env)
 {
     axis2_wsdl_interface_t *wsdl_interface = NULL;
     
@@ -685,13 +685,13 @@
 	
 axis2_status_t AXIS2_CALL
 axis2_svc_set_parent (axis2_svc_t *svc, 
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
 		                axis2_svc_grp_t *svc_grp)
 {
     axis2_svc_impl_t *svc_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, svc_grp, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE);
     
     svc_impl = AXIS2_INTF_TO_IMPL(svc);
     
@@ -702,7 +702,7 @@
 
 axis2_svc_grp_t * AXIS2_CALL
 axis2_svc_get_parent (axis2_svc_t *svc, 
-                        axis2_env_t **env)
+                        const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 	
@@ -711,18 +711,18 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_qname (axis2_svc_t *svc, 
-                    axis2_env_t **env,
+                    const axis2_env_t *env,
                     axis2_qname_t *qname)
 {
 	AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, qname, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
     
     return AXIS2_WSDL_SVC_SET_QNAME(svc->wsdl_svc, env, qname);
 }
 
 axis2_qname_t * AXIS2_CALL
 axis2_svc_get_qname (const axis2_svc_t *svc, 
-                    axis2_env_t **env)
+                    const axis2_env_t *env)
 {
 	AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_WSDL_SVC_GET_QNAME(svc->wsdl_svc, env);
@@ -730,19 +730,19 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_add_param (axis2_svc_t *svc, 
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
 		                axis2_param_t *param)
 {
     axis2_param_container_t *param_container_l = NULL;
     axis2_property_t *property = NULL;
         
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, param, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
     
    
     if(axis2_svc_is_param_locked(svc, env, AXIS2_PARAM_GET_NAME(param, env)))
     {
-        AXIS2_ERROR_SET((*env)->error, 
+        AXIS2_ERROR_SET(env->error, 
             AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE);
         return AXIS2_FAILURE;
     } 
@@ -762,7 +762,7 @@
 
 axis2_param_t * AXIS2_CALL
 axis2_svc_get_param (axis2_svc_t *svc, 
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
 		                const axis2_char_t *name)
 {
     axis2_param_container_t *param_container_l = NULL;
@@ -783,7 +783,7 @@
 
 axis2_array_list_t * AXIS2_CALL
 axis2_svc_get_params (axis2_svc_t *svc, 
-                        axis2_env_t **env)
+                        const axis2_env_t *env)
 {
     axis2_param_container_t *param_container_l = NULL;
     axis2_property_t *property = NULL;
@@ -803,7 +803,7 @@
 
 axis2_bool_t AXIS2_CALL
 axis2_svc_is_param_locked (axis2_svc_t *svc, 
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
 		                    axis2_char_t *param_name)
 {
     axis2_bool_t locked = AXIS2_FALSE;
@@ -813,7 +813,7 @@
     axis2_bool_t ret = AXIS2_FALSE;
     
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
-    AXIS2_PARAM_CHECK((*env)->error, param_name, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE);
     
    /*checking the locked value of parent */
 
@@ -849,18 +849,18 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_svc_interface(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_wsdl_interface_t *svc_interface) 
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, svc_interface, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, svc_interface, AXIS2_FAILURE);
     
     return AXIS2_WSDL_SVC_SET_SVC_INTERFACE(svc->wsdl_svc, env, svc_interface);
 }
 
 axis2_wsdl_interface_t *AXIS2_CALL
 axis2_svc_get_svc_interface(axis2_svc_t *svc,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_WSDL_SVC_GET_SVC_INTERFACE(svc->wsdl_svc, env);
@@ -868,7 +868,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_engage_module(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_module_desc_t * moduleref,
                             axis2_conf_t * conf)
 {
@@ -881,8 +881,8 @@
     axis2_property_t *property = NULL;
         
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, moduleref, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, conf, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, moduleref, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
     
     property = (axis2_property_t *)
         AXIS2_WSDL_COMPONENT_GET_COMPONENT_PROPERTY(svc->wsdl_svc->wsdl_component,
@@ -895,9 +895,9 @@
         return AXIS2_FAILURE;
     }
     size = AXIS2_ARRAY_LIST_SIZE(collection_module, env);
-    if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE((*env)->error))
+    if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error))
     {
-        return AXIS2_ERROR_GET_STATUS_CODE((*env)->error);
+        return AXIS2_ERROR_GET_STATUS_CODE(env->error);
     }
     for(i = 0; i < size; i++)
     {
@@ -909,7 +909,7 @@
             /* module has already been engaged on the service. Operation 
              *terminated !!! 
              */
-            AXIS2_ERROR_SET((*env)->error, 
+            AXIS2_ERROR_SET(env->error, 
                 AXIS2_ERROR_MODULE_ALREADY_ENGAGED_TO_SVC, AXIS2_FAILURE);
             return AXIS2_FAILURE;            
         }
@@ -938,7 +938,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_add_module_ops(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_module_desc_t *module_desc,
                             axis2_conf_t *conf) 
 {
@@ -951,8 +951,8 @@
     axis2_status_t status = AXIS2_FAILURE;
    
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, module_desc, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, conf, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
     
     map = AXIS2_MODULE_DESC_GET_OPS(module_desc, env);
     pr = axis2_phase_resolver_create_with_config_and_svc(env, conf, svc);
@@ -974,7 +974,7 @@
         /* Adding wsa-maping into service */
         size = AXIS2_ARRAY_LIST_SIZE(params, env);
         
-        if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE((*env)->error))
+        if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error))
         {
             if(pr)
             {
@@ -1039,7 +1039,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_add_to_engaged_module_list(axis2_svc_t *svc,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_module_desc_t *module_name) 
 {
     axis2_array_list_t *collection_module = NULL;
@@ -1049,7 +1049,7 @@
     axis2_property_t *property = NULL;
  
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, module_name, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE);
     
     property = (axis2_property_t *) 
         AXIS2_WSDL_COMPONENT_GET_COMPONENT_PROPERTY(svc->wsdl_svc->
@@ -1064,9 +1064,9 @@
     
     size = AXIS2_ARRAY_LIST_SIZE(collection_module, env);
     
-    if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE((*env)->error))
+    if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error))
     {
-        return AXIS2_ERROR_GET_STATUS_CODE((*env)->error);
+        return AXIS2_ERROR_GET_STATUS_CODE(env->error);
     }
     
     for(i = 0; i < size; i++)
@@ -1081,8 +1081,8 @@
             
         if(AXIS2_QNAME_EQUALS(module_d_name, env, module_d_name_l))
         {
-            AXIS2_ERROR_SET((*env)->error, 
-                AXIS2_ERROR_MODULE_ALREADY_ENGAGED_TO_SVC, AXIS2_FAILURE);
+            /*AXIS2_ERROR_SET(env->error, 
+                AXIS2_ERROR_MODULE_ALREADY_ENGAGED_TO_SVC, AXIS2_FAILURE);*/
             return AXIS2_SUCCESS;
         }
     }
@@ -1091,7 +1091,7 @@
 
 axis2_array_list_t * AXIS2_CALL
 axis2_svc_get_engaged_modules(axis2_svc_t *svc,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     axis2_property_t *property = NULL;
 
@@ -1107,14 +1107,14 @@
 
 void * AXIS2_CALL
 axis2_svc_get_wsdl_op(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_qname_t *op_name)
 {
     axis2_wsdl_interface_t *svc_interface = NULL;
     axis2_char_t * op_str = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, op_name, NULL);
+    AXIS2_PARAM_CHECK(env->error, op_name, NULL);
     
     op_str = AXIS2_QNAME_GET_LOCALPART(op_name, env);
     svc_interface = axis2_svc_get_svc_interface(svc, env);
@@ -1129,19 +1129,19 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_context_path(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_char_t *context_path) 
 {
     axis2_char_t *context_path_l = NULL;
     axis2_property_t *property = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, context_path, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, context_path, AXIS2_FAILURE);
     
     context_path_l = AXIS2_STRDUP(context_path, env);
     if(context_path_l)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return AXIS2_FAILURE;        
     }
     property = axis2_property_create(env);
@@ -1154,7 +1154,7 @@
 
 axis2_char_t * AXIS2_CALL
 axis2_svc_get_context_path(axis2_svc_t *svc,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     axis2_property_t *property = NULL;
 
@@ -1170,19 +1170,19 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_style(axis2_svc_t *svc,
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
                         axis2_char_t * style) 
 {
     axis2_char_t *style_l = NULL;
     axis2_property_t *property = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, style, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, style, AXIS2_FAILURE);
     
     style_l = AXIS2_STRDUP(style, env);
     if(!style_l)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
     property = axis2_property_create(env);
@@ -1195,7 +1195,7 @@
 
 axis2_char_t * AXIS2_CALL
 axis2_svc_get_style(axis2_svc_t *svc,
-                    axis2_env_t **env) 
+                    const axis2_env_t *env) 
 {
     axis2_property_t *property = NULL;
 
@@ -1211,7 +1211,7 @@
 
 axis2_flow_t * AXIS2_CALL
 axis2_svc_get_inflow(axis2_svc_t *svc,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     axis2_property_t *property = NULL;
 
@@ -1227,13 +1227,13 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_inflow(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_flow_t *inflow) 
 {
     axis2_property_t *property = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, inflow, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, inflow, AXIS2_FAILURE);
     
     property = axis2_property_create(env);
     AXIS2_PROPERTY_SET_VALUE(property, env, inflow);
@@ -1244,7 +1244,7 @@
 
 axis2_flow_t * AXIS2_CALL
 axis2_svc_get_outflow(axis2_svc_t *svc,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     axis2_property_t *property = NULL;
 
@@ -1260,13 +1260,13 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_outflow(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_flow_t *outflow) 
 {
     axis2_property_t *property = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, outflow, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, outflow, AXIS2_FAILURE);
     
     property = axis2_property_create(env);
     AXIS2_PROPERTY_SET_VALUE(property, env, outflow);
@@ -1277,7 +1277,7 @@
 
 axis2_flow_t *AXIS2_CALL
 axis2_svc_get_fault_inflow(axis2_svc_t *svc,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     axis2_property_t *property = NULL;
 
@@ -1293,13 +1293,13 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_fault_inflow(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_flow_t *fault_flow) 
 {
     axis2_property_t *property = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, fault_flow, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, fault_flow, AXIS2_FAILURE);
     
     property = axis2_property_create(env);
     AXIS2_PROPERTY_SET_VALUE(property, env, fault_flow);
@@ -1310,7 +1310,7 @@
 
 axis2_flow_t * AXIS2_CALL
 axis2_svc_get_fault_outflow(axis2_svc_t *svc,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     axis2_property_t *property = NULL;
     AXIS2_ENV_CHECK(env, NULL);
@@ -1325,13 +1325,13 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_fault_outflow(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_flow_t *fault_flow) 
 {
     axis2_property_t *property = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, fault_flow, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, fault_flow, AXIS2_FAILURE);
     
     property = axis2_property_create(env);
     AXIS2_PROPERTY_SET_VALUE(property, env, fault_flow);
@@ -1342,7 +1342,7 @@
 
 axis2_op_t * AXIS2_CALL
 axis2_svc_get_op_by_soap_action(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_char_t *soap_action) 
 {
     axis2_svc_impl_t *svc_impl = NULL;
@@ -1352,7 +1352,7 @@
     axis2_wsdl_endpoint_t * endpoint = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, soap_action, NULL);
+    AXIS2_PARAM_CHECK(env->error, soap_action, NULL);
     svc_impl = AXIS2_INTF_TO_IMPL(svc);
     
     if(0 == AXIS2_STRCMP(soap_action, ""))
@@ -1380,7 +1380,7 @@
 
 axis2_op_t * AXIS2_CALL
 axis2_svc_get_op_by_soap_action_and_endpoint(axis2_svc_t *svc,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_char_t *soap_action,
                                         axis2_qname_t * endpoint) 
 {
@@ -1420,7 +1420,7 @@
             binding_op->extensible_component->wsdl_component, env);
         
         size = AXIS2_LINKED_LIST_SIZE(extensiblity_elements, env);
-        status = AXIS2_ERROR_GET_STATUS_CODE((*env)->error);
+        status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
         if(AXIS2_SUCCESS != status)
         {
             return NULL;
@@ -1463,7 +1463,7 @@
        
 axis2_char_t * AXIS2_CALL
 axis2_svc_get_axis2_svc_name(axis2_svc_t *svc,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     axis2_svc_impl_t *svc_impl = NULL;
     axis2_qname_t *qname = NULL;
@@ -1486,24 +1486,24 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_axis2_svc_name(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_char_t *axis_svc_name) 
 {
     axis2_svc_impl_t *svc_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, axis_svc_name, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, axis_svc_name, AXIS2_FAILURE);
     svc_impl = AXIS2_INTF_TO_IMPL(svc);
     
     if(svc_impl->axis_svc_name)
     {
-        AXIS2_FREE((*env)->allocator, svc_impl->axis_svc_name);
+        AXIS2_FREE(env->allocator, svc_impl->axis_svc_name);
         svc_impl->axis_svc_name = NULL;
     }
     svc_impl->axis_svc_name = AXIS2_STRDUP(axis_svc_name, env);
     if(!svc_impl->axis_svc_name)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
     return AXIS2_SUCCESS;
@@ -1512,45 +1512,45 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_last_update(axis2_svc_t *svc,
-                            axis2_env_t **env)
+                            const axis2_env_t *env)
 {
     return AXIS2_SUCCESS;
 }
 
 long AXIS2_CALL
 axis2_svc_get_last_update(axis2_svc_t *svc,
-                            axis2_env_t **env)
+                            const axis2_env_t *env)
 {
     return AXIS2_INTF_TO_IMPL(svc)->last_update;
 }
 
 axis2_char_t * AXIS2_CALL
 axis2_svc_get_filename(axis2_svc_t *svc,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     return AXIS2_INTF_TO_IMPL(svc)->filename;
 }
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_filename(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_char_t *filename) 
 {
     axis2_svc_impl_t *svc_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, filename, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, filename, AXIS2_FAILURE);
     
     svc_impl = AXIS2_INTF_TO_IMPL(svc);
     if(svc_impl->filename)
     {
-        AXIS2_FREE((*env)->allocator, svc_impl->filename);
+        AXIS2_FREE(env->allocator, svc_impl->filename);
         svc_impl->filename = NULL;
     }
     svc_impl->filename = (axis2_char_t *) AXIS2_STRDUP(filename, env);
     if(!svc_impl->filename)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
     return AXIS2_SUCCESS;
@@ -1558,14 +1558,14 @@
 
 axis2_hash_t * AXIS2_CALL
 axis2_svc_get_endpoints(axis2_svc_t *svc,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     return AXIS2_WSDL_SVC_GET_ENDPOINTS(svc->wsdl_svc, env);
 }
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_endpoints(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_hash_t * endpoints) 
 {
     return AXIS2_WSDL_SVC_SET_ENDPOINTS(svc->wsdl_svc, env, endpoints);
@@ -1573,7 +1573,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_set_endpoint(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_wsdl_endpoint_t * endpoint)
 {
     return AXIS2_WSDL_SVC_SET_ENDPOINT(svc->wsdl_svc, env, endpoint);
@@ -1581,7 +1581,7 @@
 
 axis2_wsdl_endpoint_t * AXIS2_CALL
 axis2_svc_get_endpoint(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_qname_t * qname) 
 {
     return AXIS2_WSDL_SVC_GET_ENDPOINT(svc->wsdl_svc, env, qname);
@@ -1589,22 +1589,22 @@
 
 axis2_char_t * AXIS2_CALL
 axis2_svc_get_namespace(axis2_svc_t *svc,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     return AXIS2_WSDL_SVC_GET_NAMESPACE(svc->wsdl_svc, env);
 }
 
 axis2_status_t AXIS2_CALL
 axis2_svc_add_mapping(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_char_t * mapping_key , 
                             axis2_op_t * op_desc)
 {
     axis2_svc_impl_t *svc_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, mapping_key, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, op_desc, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, mapping_key, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE);
     svc_impl = AXIS2_INTF_TO_IMPL(svc);
     
     axis2_hash_set(svc_impl->wasaction_op_map, mapping_key, 
@@ -1614,14 +1614,14 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_add_module_ref(axis2_svc_t *svc,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_qname_t *moduleref)
 {
     axis2_svc_impl_t *svc_impl = NULL;
     axis2_qname_t *qmoduleref_l = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, moduleref, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, moduleref, AXIS2_FAILURE);
     svc_impl = AXIS2_INTF_TO_IMPL(svc);
 
     qmoduleref_l = AXIS2_QNAME_CLONE(moduleref, env);
@@ -1631,7 +1631,7 @@
 
 axis2_array_list_t *AXIS2_CALL
 axis2_svc_get_modules(axis2_svc_t *svc,
-                        axis2_env_t **env)
+                        const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     

Modified: webservices/axis2/trunk/c/modules/core/description/svc_grp.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/svc_grp.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/svc_grp.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/svc_grp.c Wed May 31 08:54:07 2006
@@ -40,115 +40,115 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_svc_grp_free (axis2_svc_grp_t *svc_grp, 
-                    axis2_env_t **env);
+                    const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL 
 axis2_svc_grp_set_svc_grp_name (axis2_svc_grp_t *svc_grp, 
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
 		                axis2_char_t *name);
 
 axis2_char_t * AXIS2_CALL 
 axis2_svc_grp_get_svc_grp_name (axis2_svc_grp_t *svc_grp, 
-                        axis2_env_t **env);
+                        const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL 
 axis2_svc_grp_add_svc (axis2_svc_grp_t* svc_grp, 
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
 		                axis2_svc_t *svc);
 
 axis2_svc_t * AXIS2_CALL 
 axis2_svc_grp_get_svc (axis2_svc_grp_t *svc_grp, 
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
 		                axis2_qname_t* svc_name);
 
 axis2_hash_t *AXIS2_CALL
 axis2_svc_grp_get_svcs(axis2_svc_grp_t *svc_grp, 
-                        axis2_env_t **env);
+                        const axis2_env_t *env);
                         
 axis2_status_t AXIS2_CALL 
 axis2_svc_grp_remove_svc (axis2_svc_grp_t *svc_grp, 
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
 		                    axis2_qname_t* svc_name);
 		
 axis2_status_t AXIS2_CALL 
 axis2_svc_grp_add_param (axis2_svc_grp_t *svc_grp, 
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
 		                    axis2_param_t *param);
 		
 
 axis2_param_t * AXIS2_CALL 
 axis2_svc_grp_get_param(axis2_svc_grp_t *svc_grp, 
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
 		                const axis2_char_t *name);
 		
 axis2_array_list_t * AXIS2_CALL 
 axis2_svc_grp_get_params (axis2_svc_grp_t *svc_grp, 
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 		
 axis2_bool_t AXIS2_CALL 
 axis2_svc_grp_is_param_locked(axis2_svc_grp_t *svc_grp, 
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
 		                        axis2_char_t *param_name);
                                 
 axis2_status_t AXIS2_CALL
 axis2_svc_grp_add_module(axis2_svc_grp_t *svc_grp, 
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_qname_t *module_qname);                                
 
 axis2_conf_t * AXIS2_CALL
 axis2_svc_grp_get_parent(axis2_svc_grp_t *svc_grp,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_grp_set_parent(axis2_svc_grp_t *svc_grp,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_conf_t *parent);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_grp_engage_module_to_grp(axis2_svc_grp_t *svc_grp,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_qname_t *module_name);
 
 axis2_array_list_t *AXIS2_CALL
 axis2_svc_grp_get_svc_grp_modules(axis2_svc_grp_t *svc_grp,
-                                    axis2_env_t **env);
+                                    const axis2_env_t *env);
 
 axis2_conf_t *AXIS2_CALL
 axis2_svc_grp_get_axis_desc(axis2_svc_grp_t *svc_grp,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_grp_set_axis_desc(axis2_svc_grp_t *svc_grp,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_conf_t *axis2_desc);
 
 axis2_status_t AXIS2_CALL
 axis2_svc_grp_add_moduleref(axis2_svc_grp_t *svc_grp,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_qname_t *moduleref);
 
 axis2_array_list_t *AXIS2_CALL
 axis2_svc_grp_get_modules(axis2_svc_grp_t *svc_grp,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
                             
 axis2_svc_grp_ctx_t *AXIS2_CALL
 axis2_svc_grp_get_svc_grp_ctx(axis2_svc_grp_t *svc_grp,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_conf_ctx_t *parent);                            
                           
 /***************************** End of function headers ************************/
 
 AXIS2_DECLARE(axis2_svc_grp_t *) 
-axis2_svc_grp_create (axis2_env_t **env)
+axis2_svc_grp_create (const axis2_env_t *env)
 {
     axis2_svc_grp_impl_t *svc_grp_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     svc_grp_impl = (axis2_svc_grp_impl_t *)
-		AXIS2_MALLOC ((*env)->allocator, sizeof(axis2_svc_grp_impl_t));
+		AXIS2_MALLOC (env->allocator, sizeof(axis2_svc_grp_impl_t));
     
 	if(NULL == svc_grp_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;
     }
 	
@@ -164,7 +164,7 @@
     if(NULL == svc_grp_impl->svc_grp.param_container)
     {
         axis2_svc_grp_free(&(svc_grp_impl->svc_grp), 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;
     }
     
@@ -172,7 +172,7 @@
     if(NULL == svc_grp_impl->modules)
     {
         axis2_svc_grp_free(&(svc_grp_impl->svc_grp), 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;
     }
     
@@ -180,7 +180,7 @@
     if(NULL == svc_grp_impl->module_list)
     {
         axis2_svc_grp_free(&(svc_grp_impl->svc_grp), 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;
     }
     
@@ -188,16 +188,16 @@
 	if(NULL == svc_grp_impl->svcs)
     {
         axis2_svc_grp_free(&(svc_grp_impl->svc_grp), 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;
     }
     
-    svc_grp_impl->svc_grp.ops = AXIS2_MALLOC((*env)->allocator, 
+    svc_grp_impl->svc_grp.ops = AXIS2_MALLOC(env->allocator, 
             sizeof(axis2_svc_grp_ops_t));
 	if(NULL == svc_grp_impl->svc_grp.ops)
 	{
-        AXIS2_FREE((*env)->allocator, svc_grp_impl);
-		AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_FREE(env->allocator, svc_grp_impl);
+		AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
 	}
     
@@ -227,13 +227,13 @@
 }
 
 AXIS2_DECLARE(axis2_svc_grp_t *) 
-axis2_svc_grp_create_with_conf (axis2_env_t **env,
+axis2_svc_grp_create_with_conf (const axis2_env_t *env,
                                          axis2_conf_t *conf)
 {
     axis2_svc_grp_impl_t *svc_grp_impl = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, conf, NULL);
+    AXIS2_PARAM_CHECK(env->error, conf, NULL);
     
     svc_grp_impl = (axis2_svc_grp_impl_t *) axis2_svc_grp_create(env);
     if(NULL != svc_grp_impl)
@@ -246,7 +246,7 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_svc_grp_free (axis2_svc_grp_t *svc_grp, 
-                    axis2_env_t **env)
+                    const axis2_env_t *env)
 {
     axis2_svc_grp_impl_t *svc_grp_impl = NULL;
  
@@ -256,7 +256,7 @@
 
     if(NULL != svc_grp->ops)
     {
-		AXIS2_FREE((*env)->allocator, svc_grp->ops);
+		AXIS2_FREE(env->allocator, svc_grp->ops);
         svc_grp->ops = NULL;
     }
     
@@ -269,7 +269,7 @@
     
     if(NULL != svc_grp_impl->svc_grp_name)
     {
-        AXIS2_FREE((*env)->allocator, svc_grp_impl->svc_grp_name);
+        AXIS2_FREE(env->allocator, svc_grp_impl->svc_grp_name);
         svc_grp_impl->svc_grp_name = NULL;
     }
     
@@ -294,7 +294,7 @@
    
     if(NULL != svc_grp_impl) 
     {
-	    AXIS2_FREE((*env)->allocator, svc_grp_impl);
+	    AXIS2_FREE(env->allocator, svc_grp_impl);
         svc_grp_impl = NULL;
     }
 	return AXIS2_SUCCESS;
@@ -302,7 +302,7 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_svc_grp_set_svc_grp_name (axis2_svc_grp_t *svc_grp, 
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
 		                axis2_char_t *name)
 {
     axis2_svc_grp_impl_t *svc_grp_impl = NULL;
@@ -311,11 +311,11 @@
     svc_grp_impl = AXIS2_INTF_TO_IMPL(svc_grp);
 	
     if(svc_grp_impl->svc_grp_name)
-        AXIS2_FREE((*env)->allocator, svc_grp_impl->svc_grp_name);
+        AXIS2_FREE(env->allocator, svc_grp_impl->svc_grp_name);
 	svc_grp_impl->svc_grp_name = AXIS2_STRDUP(name, env); 
     if(!svc_grp_impl->svc_grp_name)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
     
@@ -324,7 +324,7 @@
 
 axis2_char_t * AXIS2_CALL 
 axis2_svc_grp_get_svc_grp_name (axis2_svc_grp_t *svc_grp, 
-                        axis2_env_t **env)
+                        const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 	
@@ -333,7 +333,7 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_svc_grp_add_svc (axis2_svc_grp_t *svc_grp, 
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
 		                axis2_svc_t *svc)
 {
     axis2_svc_grp_impl_t *svc_grp_impl = NULL;
@@ -343,7 +343,7 @@
     axis2_char_t *svc_name = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, svc, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, svc, AXIS2_FAILURE);
 	
     svc_grp_impl = AXIS2_INTF_TO_IMPL(svc_grp);
     
@@ -402,14 +402,14 @@
 
 axis2_svc_t *AXIS2_CALL
 axis2_svc_grp_get_svc(axis2_svc_grp_t *svc_grp,
-                        axis2_env_t **env,
+                        const axis2_env_t *env,
                         axis2_qname_t *qname)
 {
     axis2_svc_grp_impl_t *svc_grp_impl = NULL;
     axis2_char_t *name = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, qname, NULL);
+    AXIS2_PARAM_CHECK(env->error, qname, NULL);
     svc_grp_impl = AXIS2_INTF_TO_IMPL(svc_grp);
 
     name = AXIS2_QNAME_TO_STRING(qname, env);
@@ -419,7 +419,7 @@
 
 axis2_hash_t *AXIS2_CALL
 axis2_svc_grp_get_svcs(axis2_svc_grp_t *svc_grp, 
-                        axis2_env_t **env)
+                        const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(svc_grp)->svcs;
@@ -427,14 +427,14 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_svc_grp_remove_svc (axis2_svc_grp_t *svc_grp, 
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
 		                    axis2_qname_t* svc_qname)
 {
     axis2_svc_t *svc = NULL;
     axis2_char_t *svc_name = NULL;
         
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-	AXIS2_PARAM_CHECK((*env)->error, svc_name, AXIS2_FAILURE);
+	AXIS2_PARAM_CHECK(env->error, svc_name, AXIS2_FAILURE);
     
     svc = axis2_svc_grp_get_svc(svc_grp, env, svc_qname);
     if (NULL != svc) 
@@ -450,11 +450,11 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_svc_grp_add_param (axis2_svc_grp_t *svc_grp, 
-                            axis2_env_t **env, 
+                            const axis2_env_t *env, 
                             axis2_param_t *param)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, param, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);
     
     if(NULL == svc_grp->param_container)
     {
@@ -470,14 +470,14 @@
 
 axis2_param_t * AXIS2_CALL 
 axis2_svc_grp_get_param (axis2_svc_grp_t *svc_grp, 
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
 		                    const axis2_char_t *name)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, name, NULL);
+    AXIS2_PARAM_CHECK(env->error, name, NULL);
 	if(NULL == svc_grp->param_container)
     {
-	    AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_STATE_PARAM_CONTAINER,
+	    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PARAM_CONTAINER,
             AXIS2_FAILURE);
         return NULL;
     }
@@ -487,7 +487,7 @@
 
 axis2_array_list_t * AXIS2_CALL 
 axis2_svc_grp_get_params (axis2_svc_grp_t *svc_grp, 
-                            axis2_env_t **env)
+                            const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 	
@@ -497,7 +497,7 @@
 
 axis2_bool_t AXIS2_CALL
 axis2_svc_grp_is_param_locked(axis2_svc_grp_t *svc_grp,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_char_t *param_name) 
 {
     axis2_bool_t locked = AXIS2_FALSE;
@@ -506,7 +506,7 @@
     axis2_bool_t ret = AXIS2_FALSE;
     
     AXIS2_ENV_CHECK(env, AXIS2_FALSE);
-    AXIS2_PARAM_CHECK((*env)->error, param_name, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE);
 
     parent = axis2_svc_grp_get_parent(svc_grp, env);
     /* checking the locked value of parent */
@@ -533,7 +533,7 @@
     
 axis2_status_t AXIS2_CALL
 axis2_svc_grp_add_module(axis2_svc_grp_t *svc_grp, 
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_qname_t *module_qname)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -544,7 +544,7 @@
 
 axis2_conf_t * AXIS2_CALL
 axis2_svc_grp_get_parent(axis2_svc_grp_t *svc_grp,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     
@@ -553,13 +553,13 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_grp_set_parent(axis2_svc_grp_t *svc_grp,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_conf_t *parent) 
 {
     axis2_svc_grp_impl_t *svc_grp_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, parent, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, parent, AXIS2_FAILURE);
     
     svc_grp_impl = AXIS2_INTF_TO_IMPL(svc_grp);
     if(svc_grp_impl->parent)
@@ -570,7 +570,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_grp_engage_module_to_grp(axis2_svc_grp_t *svc_grp,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_qname_t *module_name) 
 {
     axis2_svc_grp_impl_t *svc_grp_impl = NULL;
@@ -586,11 +586,11 @@
     int size = 0;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, module_name, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE);
     
     svc_grp_impl = AXIS2_INTF_TO_IMPL(svc_grp);
     size = AXIS2_ARRAY_LIST_SIZE(svc_grp_impl->modules, env);
-    if(AXIS2_TRUE != AXIS2_ERROR_GET_STATUS_CODE((*env)->error))
+    if(AXIS2_TRUE != AXIS2_ERROR_GET_STATUS_CODE(env->error))
     {
         return AXIS2_FAILURE;
     }
@@ -601,7 +601,7 @@
         module_name_local = AXIS2_QNAME_GET_LOCALPART(module_name, env);
         if(0 == AXIS2_STRCMP(modu_local, module_name_local))
         {
-            AXIS2_ERROR_SET((*env)->error, 
+            AXIS2_ERROR_SET(env->error, 
                 AXIS2_ERROR_MODULE_ALREADY_ENGAGED_TO_SVC_GRP, AXIS2_FAILURE);
             return AXIS2_FAILURE;
         }
@@ -657,7 +657,7 @@
 
 axis2_array_list_t *AXIS2_CALL
 axis2_svc_grp_get_svc_grp_modules(axis2_svc_grp_t *svc_grp,
-                                    axis2_env_t **env)
+                                    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     
@@ -666,7 +666,7 @@
 
 axis2_conf_t *AXIS2_CALL
 axis2_svc_grp_get_axis_desc(axis2_svc_grp_t *svc_grp,
-                            axis2_env_t **env) 
+                            const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     
@@ -675,13 +675,13 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_grp_set_axis_desc(axis2_svc_grp_t *svc_grp,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_conf_t *axis2_desc) 
 {
     axis2_svc_grp_impl_t *svc_grp_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, axis2_desc, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, axis2_desc, AXIS2_FAILURE);
     
     svc_grp_impl = AXIS2_INTF_TO_IMPL(svc_grp);
     
@@ -694,13 +694,13 @@
 
 axis2_status_t AXIS2_CALL
 axis2_svc_grp_add_moduleref(axis2_svc_grp_t *svc_grp,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_qname_t *moduleref)
 {
     axis2_svc_grp_impl_t *svc_grp_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, moduleref, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, moduleref, AXIS2_FAILURE);
     
     svc_grp_impl = AXIS2_INTF_TO_IMPL(svc_grp);
     if(!svc_grp_impl->module_list)
@@ -714,7 +714,7 @@
 
 axis2_array_list_t *AXIS2_CALL
 axis2_svc_grp_get_modules(axis2_svc_grp_t *svc_grp,
-                            axis2_env_t **env)
+                            const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     
@@ -723,13 +723,13 @@
 
 axis2_svc_grp_ctx_t *AXIS2_CALL
 axis2_svc_grp_get_svc_grp_ctx(axis2_svc_grp_t *svc_grp,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_conf_ctx_t *parent)
 {
     axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, parent, NULL);
+    AXIS2_PARAM_CHECK(env->error, parent, NULL);
     
     svc_grp_ctx = axis2_svc_grp_ctx_create(env, svc_grp, parent);
     if(!svc_grp_ctx)

Modified: webservices/axis2/trunk/c/modules/core/description/transport_in_desc.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/description/transport_in_desc.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/transport_in_desc.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/transport_in_desc.c Wed May 31 08:54:07 2006
@@ -58,95 +58,95 @@
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_free (
                 axis2_transport_in_desc_t *transport_in,
-				axis2_env_t **env);
+				const axis2_env_t *env);
 
 axis2_qname_t *AXIS2_CALL
 axis2_transport_in_desc_get_qname(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env);
+                                        const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_set_qname(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_qname_t *qname);
 
 axis2_flow_t *AXIS2_CALL
 axis2_transport_in_desc_get_inflow(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env);
+                                        const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_set_inflow(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_flow_t *inflow);
 
 axis2_flow_t *AXIS2_CALL
 axis2_transport_in_desc_get_faultflow(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env);
+                                        const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_set_faultflow(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_flow_t *faultflow);
 
 axis2_transport_receiver_t * AXIS2_CALL
 axis2_transport_in_desc_get_recv(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env);
+                                        const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_set_recv(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_transport_receiver_t *recv);
 
 axis2_phase_t * AXIS2_CALL
 axis2_transport_in_desc_get_in_phase(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env);
+                                        const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_set_in_phase(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_phase_t *in_phase);
                                             
 axis2_phase_t *AXIS2_CALL
 axis2_transport_in_desc_get_faultphase(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env);
+                                        const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_set_faultphase(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_phase_t *faultphase);
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_add_param(axis2_transport_in_desc_t *transport_in_desc,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_param_t *param);
 
 axis2_param_t *AXIS2_CALL
 axis2_transport_in_desc_get_param(axis2_transport_in_desc_t *transport_in_desc,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_char_t *param_name);
 
 axis2_bool_t AXIS2_CALL
 axis2_transport_in_desc_is_param_locked (axis2_transport_in_desc_t *
                                                 transport_in_desc,
-                                            axis2_env_t **env,
+                                            const axis2_env_t *env,
                                             axis2_char_t *param_name);
 
 /************************** End of function prototypes ************************/
 
 AXIS2_DECLARE(axis2_transport_in_desc_t *) 
-axis2_transport_in_desc_create_with_qname (axis2_env_t **env, 
+axis2_transport_in_desc_create_with_qname (const axis2_env_t *env, 
                                            axis2_qname_t *qname)
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, qname, NULL);
+    AXIS2_PARAM_CHECK(env->error, qname, NULL);
     
-    transport_in_impl = (axis2_transport_in_desc_impl_t *) AXIS2_MALLOC((*env)->
+    transport_in_impl = (axis2_transport_in_desc_impl_t *) AXIS2_MALLOC(env->
         allocator, sizeof(axis2_transport_in_desc_impl_t));
 	
 	if(NULL == transport_in_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;
     }
     
@@ -163,18 +163,18 @@
     if(NULL == transport_in_impl->transport_in.param_container)
     {
         axis2_transport_in_desc_free(&(transport_in_impl->transport_in), 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;
     }
     
     transport_in_impl->qname = AXIS2_QNAME_CLONE(qname, env);
     
 	transport_in_impl->transport_in.ops = 
-		AXIS2_MALLOC ((*env)->allocator, sizeof(axis2_transport_in_desc_ops_t));
+		AXIS2_MALLOC (env->allocator, sizeof(axis2_transport_in_desc_ops_t));
 	if(NULL == transport_in_impl->transport_in.ops)
     {
         axis2_transport_in_desc_free(&(transport_in_impl->transport_in), 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;
     }
     
@@ -218,7 +218,7 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_transport_in_desc_free (axis2_transport_in_desc_t *transport_in, 
-                            axis2_env_t **env)
+                            const axis2_env_t *env)
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
     
@@ -234,7 +234,7 @@
       
 	if(NULL != transport_in->ops)
     {
-        AXIS2_FREE((*env)->allocator, transport_in->ops);
+        AXIS2_FREE(env->allocator, transport_in->ops);
         transport_in->ops = NULL;
     }
     
@@ -274,14 +274,14 @@
         transport_in_impl->faultphase = NULL;
     }
     
-    AXIS2_FREE((*env)->allocator, transport_in_impl);
+    AXIS2_FREE(env->allocator, transport_in_impl);
     
 	return AXIS2_SUCCESS;
 }
 
 axis2_qname_t *AXIS2_CALL
 axis2_transport_in_desc_get_qname(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env) 
+                                        const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(transport_in)->qname;
@@ -289,13 +289,13 @@
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_set_qname(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_qname_t *qname) 
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, qname, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
     
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
     
@@ -310,7 +310,7 @@
 
 axis2_flow_t *AXIS2_CALL
 axis2_transport_in_desc_get_inflow(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env) 
+                                        const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(transport_in)->inflow;
@@ -318,12 +318,12 @@
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_set_inflow(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_flow_t *inflow) 
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, inflow, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, inflow, AXIS2_FAILURE);
     
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
     if(transport_in_impl->inflow)
@@ -337,19 +337,19 @@
 
 axis2_flow_t *AXIS2_CALL
 axis2_transport_in_desc_get_faultflow(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env) 
+                                        const axis2_env_t *env) 
 {
     return AXIS2_INTF_TO_IMPL(transport_in)->faultflow;
 }
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_set_faultflow(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_flow_t *faultflow) 
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, faultflow, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, faultflow, AXIS2_FAILURE);
     
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
     if(transport_in_impl->faultflow)
@@ -363,7 +363,7 @@
 
 axis2_transport_receiver_t * AXIS2_CALL
 axis2_transport_in_desc_get_recv(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env) 
+                                        const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(transport_in)->recv;
@@ -371,12 +371,12 @@
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_set_recv(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_transport_receiver_t *recv) 
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, recv, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, recv, AXIS2_FAILURE);
    
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
     
@@ -392,7 +392,7 @@
 
 axis2_phase_t * AXIS2_CALL
 axis2_transport_in_desc_get_in_phase(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env) 
+                                        const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     
@@ -401,13 +401,13 @@
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_set_in_phase(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_phase_t *in_phase) 
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, in_phase, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, in_phase, AXIS2_FAILURE);
     
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
     if(transport_in_impl->in_phase)
@@ -421,7 +421,7 @@
 
 axis2_phase_t *AXIS2_CALL
 axis2_transport_in_desc_get_faultphase(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env) 
+                                        const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     
@@ -430,13 +430,13 @@
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_set_faultphase(axis2_transport_in_desc_t *transport_in,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_phase_t *faultphase) 
 {
     axis2_transport_in_desc_impl_t *transport_in_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, faultphase, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, faultphase, AXIS2_FAILURE);
     
     transport_in_impl = AXIS2_INTF_TO_IMPL(transport_in);
     if(transport_in_impl->faultphase)
@@ -451,11 +451,11 @@
 
 axis2_status_t AXIS2_CALL
 axis2_transport_in_desc_add_param(axis2_transport_in_desc_t *transport_in_desc,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_param_t *param)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, param, AXIS2_FAILURE);    
+    AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE);    
     
     return AXIS2_PARAM_CONTAINER_ADD_PARAM(transport_in_desc->
             param_container, env, param);
@@ -463,11 +463,11 @@
 
 axis2_param_t *AXIS2_CALL
 axis2_transport_in_desc_get_param(axis2_transport_in_desc_t *transport_in_desc,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_char_t *param_name)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, param_name, NULL);    
+    AXIS2_PARAM_CHECK(env->error, param_name, NULL);    
     
     return AXIS2_PARAM_CONTAINER_GET_PARAM(transport_in_desc->param_container, 
         env, param_name);
@@ -476,11 +476,11 @@
 axis2_bool_t AXIS2_CALL
 axis2_transport_in_desc_is_param_locked (axis2_transport_in_desc_t *
                                                 transport_in_desc,
-                                            axis2_env_t **env,
+                                            const axis2_env_t *env,
                                             axis2_char_t *param_name)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, param_name, AXIS2_FAILURE);    
+    AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE);    
 
     return AXIS2_PARAM_CONTAINER_IS_PARAM_LOCKED(transport_in_desc->
         param_container, env, param_name);



---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org


Mime
View raw message