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 [19/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/deployment/dep_engine.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c Wed May 31 08:54:07 2006
@@ -80,30 +80,30 @@
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_free (axis2_dep_engine_t *dep_engine,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_add_module(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_qname_t *module_qname);
     
 axis2_module_desc_t *AXIS2_CALL
 axis2_dep_engine_get_module(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_qname_t *module_name);
 
 axis2_arch_file_data_t *AXIS2_CALL
 axis2_dep_engine_get_current_file_item(axis2_dep_engine_t *dep_engine,
-                                        axis2_env_t **env);
+                                        const axis2_env_t *env);
                                         
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_set_current_file_item(axis2_dep_engine_t *dep_engine,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_arch_file_data_t *file_data);                                        
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_set_arch_reader(axis2_dep_engine_t *dep_engine,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_arch_reader_t *arch_reader);
 
 /**
@@ -111,7 +111,7 @@
  */
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_add_ws_to_deploy(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_arch_file_data_t *file);
 
 /**
@@ -119,12 +119,12 @@
  */
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_add_ws_to_undeploy(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_ws_info_t *file);
 
 axis2_phases_info_t *AXIS2_CALL
 axis2_dep_engine_get_phases_info(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env);
+                                    const axis2_env_t *env);
 
 /**
  * tio get ER
@@ -133,27 +133,27 @@
  */
 axis2_conf_t *AXIS2_CALL
 axis2_dep_engine_get_axis_conf(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env);
+                                const axis2_env_t *env);
 
 /**
  * To set hotDeployment and hot update
  */
 static axis2_status_t
 axis2_dep_engine_set_dep_features(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env);
+                                    const axis2_env_t *env);
 
 axis2_conf_t *AXIS2_CALL
 axis2_dep_engine_load(axis2_dep_engine_t *dep_engine,
-                        axis2_env_t **env);
+                        const axis2_env_t *env);
 
 axis2_conf_t *AXIS2_CALL
 axis2_dep_engine_load_client(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_char_t *client_home);
 
 static axis2_status_t
 axis2_dep_engine_check_client_home(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_char_t *client_home);
 
 /**
@@ -162,7 +162,7 @@
  */
 static axis2_status_t
 axis2_dep_engine_engage_modules(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env);
+                                    const axis2_env_t *env);
 
 /**
  * This method is to check wether some one has change the system pre defined phases for all the
@@ -171,11 +171,11 @@
  */
 static axis2_status_t
 axis2_dep_engine_validate_system_predefined_phases(axis2_dep_engine_t *dep_engine,
-                                                    axis2_env_t **env);
+                                                    const axis2_env_t *env);
 
 static axis2_status_t
 axis2_dep_engine_add_new_svc(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_svc_grp_t *svc_metadata);
 
 /**
@@ -186,48 +186,48 @@
  */
 static axis2_status_t
 axis2_dep_engine_load_svc_props(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_svc_t *svc);
 
 static axis2_status_t
 axis2_dep_engine_load_module_dll(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_module_desc_t *module_desc);
 
 static axis2_status_t
 axis2_dep_engine_add_module_flow_handlers(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_flow_t *flow,
                                     axis2_hash_t *handler_create_func_map);
 
 static axis2_status_t
 axis2_dep_engine_add_flow_handlers(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_flow_t *flow);
 
 
 void * AXIS2_CALL
 axis2_dep_engine_get_handler_dll(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_char_t *dll_name);
 
 
 static axis2_status_t
 axis2_dep_engine_add_new_module(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_module_desc_t *module_metadata);
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_do_deploy(axis2_dep_engine_t *dep_engine,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_undeploy(axis2_dep_engine_t *dep_engine,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_bool_t AXIS2_CALL
 axis2_dep_engine_is_hot_update(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env);
+                                const axis2_env_t *env);
 
 /**
  * This method is used to retrive service name form the arechive file name
@@ -238,12 +238,12 @@
  */
 static axis2_char_t *
 axis2_dep_engine_get_axis_svc_name(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_char_t *file_name);
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_set_phases_info(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_phases_info_t *phases_info);
 
 /**
@@ -259,7 +259,7 @@
  */
 axis2_svc_t *AXIS2_CALL
 axis2_dep_engine_build_svc(axis2_dep_engine_t *dep_engine,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_svc_t *svc,
                             axis2_char_t *file_name);
 
@@ -272,29 +272,29 @@
 
 axis2_module_desc_t *AXIS2_CALL
 axis2_dep_engine_build_module(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_file_t *module_archive,
                                 axis2_conf_t *conf);  
                                 
 axis2_char_t *AXIS2_CALL
 axis2_dep_engine_get_repos_path(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env);                                
+                                const axis2_env_t *env);                                
   
 /************************* End of function headers ****************************/	
 
 axis2_dep_engine_t *AXIS2_CALL
-axis2_dep_engine_create(axis2_env_t **env)
+axis2_dep_engine_create(const axis2_env_t *env)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     
-    dep_engine_impl = (axis2_dep_engine_impl_t *) AXIS2_MALLOC ((*env)->allocator
+    dep_engine_impl = (axis2_dep_engine_impl_t *) AXIS2_MALLOC (env->allocator
 		    , sizeof (axis2_dep_engine_impl_t));
     
 	if(NULL == dep_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;
     } 
     dep_engine_impl->conf = NULL;
@@ -327,11 +327,11 @@
     }
     
     dep_engine_impl->dep_engine.ops = (axis2_dep_engine_ops_t *) AXIS2_MALLOC(
-        (*env)->allocator, sizeof(axis2_dep_engine_ops_t));
+        env->allocator, sizeof(axis2_dep_engine_ops_t));
     
     if(NULL == dep_engine_impl->dep_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_dep_engine_free(&(dep_engine_impl->dep_engine), env);
         return NULL;
     }
@@ -370,7 +370,7 @@
 }
 axis2_dep_engine_t *AXIS2_CALL 
 axis2_dep_engine_create_with_repos_name (
-                                        axis2_env_t **env, 
+                                        const axis2_env_t *env, 
                                         axis2_char_t *repos_path)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
@@ -389,7 +389,7 @@
 }
 
 axis2_dep_engine_t *AXIS2_CALL
-axis2_dep_engine_create_with_repos_name_and_svr_xml_file(axis2_env_t **env,
+axis2_dep_engine_create_with_repos_name_and_svr_xml_file(const axis2_env_t *env,
                                                     axis2_char_t *repos_path,
                                                     axis2_char_t *svr_xml_file)
 {
@@ -398,11 +398,11 @@
     axis2_status_t status = AXIS2_FAILURE;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, repos_path, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, svr_xml_file, NULL);
+    AXIS2_PARAM_CHECK(env->error, repos_path, NULL);
+    AXIS2_PARAM_CHECK(env->error, svr_xml_file, NULL);
     if(0 == AXIS2_STRCMP("", repos_path))
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL,
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL,
             AXIS2_FAILURE);
         return NULL;
     }
@@ -411,7 +411,7 @@
     
 	if(NULL == dep_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;
     }
     
@@ -419,7 +419,7 @@
     if(AXIS2_SUCCESS != status)
     {
         axis2_dep_engine_free(&(dep_engine_impl->dep_engine), env);
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_REPOSITORY_NOT_EXIST, 
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPOSITORY_NOT_EXIST, 
             AXIS2_FAILURE);
         return NULL;
     }
@@ -428,7 +428,7 @@
     if(NULL == dep_engine_impl->folder_name)
 	{
         axis2_dep_engine_free(&(dep_engine_impl->dep_engine), 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;
 	}
     
@@ -436,24 +436,24 @@
     if(NULL == dep_engine_impl->axis2_repos)
 	{
         axis2_dep_engine_free(&(dep_engine_impl->dep_engine), 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;
 	}
    
     conf_file_l = AXIS2_STRACAT(repos_path, AXIS2_PATH_SEP_STR, env);
     dep_engine_impl->conf_name = AXIS2_STRACAT(conf_file_l, svr_xml_file, env);
-    AXIS2_FREE((*env)->allocator, conf_file_l);
+    AXIS2_FREE(env->allocator, conf_file_l);
     if(!dep_engine_impl->conf_name)
     {
             axis2_dep_engine_free(&(dep_engine_impl->dep_engine), env);
-            AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL , AXIS2_FAILURE);
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL , AXIS2_FAILURE);
             return NULL;
     }
     status = axis2_file_handler_access(dep_engine_impl->conf_name, AXIS2_F_OK);
     if(AXIS2_SUCCESS != status)
     {
         axis2_dep_engine_free(&(dep_engine_impl->dep_engine), env);
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_CONFIG_NOT_FOUND, 
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, 
             AXIS2_FAILURE);
         return NULL;
     }
@@ -465,7 +465,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_free (axis2_dep_engine_t *dep_engine,
-                        axis2_env_t **env)
+                        const axis2_env_t *env)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     
@@ -558,17 +558,17 @@
     }
     if(dep_engine_impl->folder_name)
     {
-        AXIS2_FREE((*env)->allocator, dep_engine_impl->folder_name);
+        AXIS2_FREE(env->allocator, dep_engine_impl->folder_name);
         dep_engine_impl->folder_name = NULL;
     }
     if(dep_engine_impl->conf_name)
     {
-        AXIS2_FREE((*env)->allocator, dep_engine_impl->conf_name);
+        AXIS2_FREE(env->allocator, dep_engine_impl->conf_name);
         dep_engine_impl->conf_name = NULL;
     }
     if(dep_engine_impl->axis2_repos)
     {
-        AXIS2_FREE((*env)->allocator, dep_engine_impl->axis2_repos);
+        AXIS2_FREE(env->allocator, dep_engine_impl->axis2_repos);
         dep_engine_impl->axis2_repos = NULL;
     }
     
@@ -580,13 +580,13 @@
 
 	if(NULL != dep_engine->ops)
     {
-		AXIS2_FREE((*env)->allocator, dep_engine->ops);
+		AXIS2_FREE(env->allocator, dep_engine->ops);
         dep_engine->ops = NULL;
     }
     
     if(dep_engine_impl)
     {
-        AXIS2_FREE((*env)->allocator, dep_engine_impl);
+        AXIS2_FREE(env->allocator, dep_engine_impl);
         dep_engine_impl = NULL;
     }
     
@@ -596,14 +596,14 @@
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_add_module(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_qname_t *module_qname) 
 {
     axis2_qname_t *qname = NULL;
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, module_qname, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, module_qname, AXIS2_FAILURE);
     dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
     qname = AXIS2_QNAME_CLONE(module_qname, env);
@@ -621,13 +621,13 @@
     
 struct axis2_module_desc *AXIS2_CALL
 axis2_dep_engine_get_module(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_qname_t *module_name) 
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, module_name, NULL);
+    AXIS2_PARAM_CHECK(env->error, module_name, NULL);
     
     dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     return AXIS2_CONF_GET_MODULE(dep_engine_impl->conf, env, module_name);
@@ -635,7 +635,7 @@
 
 struct axis2_arch_file_data *AXIS2_CALL
 axis2_dep_engine_get_current_file_item(axis2_dep_engine_t *dep_engine,
-                                        axis2_env_t **env)
+                                        const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     
@@ -647,12 +647,12 @@
  */
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_add_ws_to_deploy(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_arch_file_data_t *file) 
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, file, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, file, AXIS2_FAILURE);
     dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
     return AXIS2_ARRAY_LIST_ADD(dep_engine_impl->ws_to_deploy, env, file);
@@ -663,12 +663,12 @@
  */
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_add_ws_to_undeploy(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_ws_info_t *file) 
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, file, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, file, AXIS2_FAILURE);
     dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     if(!(dep_engine_impl->ws_to_undeploy))
     {
@@ -679,7 +679,7 @@
 
 axis2_phases_info_t *AXIS2_CALL
 axis2_dep_engine_get_phases_info(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env)
+                                    const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return AXIS2_INTF_TO_IMPL(dep_engine)->phases_info;
@@ -692,7 +692,7 @@
  */
 axis2_conf_t *AXIS2_CALL
 axis2_dep_engine_get_axis_conf(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env) 
+                                const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     
@@ -704,7 +704,7 @@
  */
 static axis2_status_t
 axis2_dep_engine_set_dep_features(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env) 
+                                    const axis2_env_t *env) 
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_char_t *value = NULL;
@@ -741,7 +741,7 @@
 
 axis2_conf_t *AXIS2_CALL
 axis2_dep_engine_load(axis2_dep_engine_t *dep_engine,
-                        axis2_env_t **env) 
+                        const axis2_env_t *env) 
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_status_t status = AXIS2_FAILURE;
@@ -750,7 +750,7 @@
     
     if(NULL == dep_engine_impl->conf_name)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_PATH_TO_CONFIG_CAN_NOT_BE_NULL,
+        AXIS2_ERROR_SET(env->error, AXIS2_PATH_TO_CONFIG_CAN_NOT_BE_NULL,
             AXIS2_FAILURE);
         return NULL;        
     }
@@ -811,7 +811,7 @@
     {
         AXIS2_REPOS_LISTENER_FREE(dep_engine_impl->repos_listener, env);
         AXIS2_CONF_FREE(dep_engine_impl->conf, env);
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED, 
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED, 
             AXIS2_FAILURE);
         return NULL;
     }
@@ -831,7 +831,7 @@
     {
         AXIS2_REPOS_LISTENER_FREE(dep_engine_impl->repos_listener, env);
         AXIS2_CONF_FREE(dep_engine_impl->conf, env);
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED, 
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED, 
             AXIS2_FAILURE);
         return NULL;
     }
@@ -843,7 +843,7 @@
 
 axis2_conf_t *AXIS2_CALL
 axis2_dep_engine_load_client(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_char_t *client_home) 
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
@@ -851,13 +851,13 @@
     axis2_status_t status = AXIS2_FAILURE;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, client_home, NULL);
+    AXIS2_PARAM_CHECK(env->error, client_home, NULL);
     dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
     dep_engine_impl->axis2_repos = AXIS2_STRDUP(client_home, env);
     if(!dep_engine_impl->axis2_repos)
     {
-        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 != client_home && 0 != AXIS2_STRCMP("", client_home))
@@ -874,7 +874,7 @@
                 env);
         if(!dep_engine_impl->conf_name)
         {
-            AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
             return NULL;
         }
     }
@@ -921,7 +921,7 @@
     {
         AXIS2_REPOS_LISTENER_FREE(dep_engine_impl->repos_listener, env);
         AXIS2_CONF_FREE(dep_engine_impl->conf, env);
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED, 
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED, 
             AXIS2_FAILURE);
         return NULL;
     }
@@ -932,7 +932,7 @@
 
 static axis2_status_t
 axis2_dep_engine_check_client_home(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_char_t *client_home)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
@@ -944,18 +944,18 @@
     dep_engine_impl->folder_name = AXIS2_STRDUP(client_home, env);
     if(!dep_engine_impl->folder_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;
     }
     path_l = AXIS2_STRACAT(client_home, AXIS2_PATH_SEP_STR, env);
     dep_engine_impl->conf_name = AXIS2_STRACAT(path_l,AXIS2_SERVER_XML_FILE, env);
-    AXIS2_FREE((*env)->allocator, path_l);
+    AXIS2_FREE(env->allocator, path_l);
     if(!dep_engine_impl->conf_name)
     {
         dep_engine_impl->conf_name = AXIS2_STRDUP(AXIS2_CONFIGURATION_RESOURCE, env);
         if(!dep_engine_impl->conf_name)
         {
-            AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_CONFIG_NOT_FOUND,
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND,
                 AXIS2_FAILURE)
             return AXIS2_FAILURE;
         }  
@@ -963,7 +963,7 @@
     status = axis2_file_handler_access(dep_engine_impl->conf_name, AXIS2_F_OK);
     if(AXIS2_SUCCESS != status)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_CONFIG_NOT_FOUND, 
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, 
             AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
@@ -973,7 +973,7 @@
 
 static axis2_status_t
 axis2_dep_engine_engage_modules(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env)
+                                    const axis2_env_t *env)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     int size = 0;
@@ -1008,7 +1008,7 @@
 
 static axis2_status_t
 axis2_dep_engine_validate_system_predefined_phases(axis2_dep_engine_t *dep_engine,
-                                                    axis2_env_t **env) 
+                                                    const axis2_env_t *env) 
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_array_list_t *in_phases = NULL;
@@ -1034,7 +1034,7 @@
         (phase2 && 0 != AXIS2_STRCMP(phase2, AXIS2_PHASE_DISPATCH)) ||
         (phase3 && 0 != AXIS2_STRCMP(phase3, AXIS2_PHASE_POST_DISPATCH)))
     {
-        AXIS2_ERROR_SET((*env)->error, AXI2_ERROR_INVALID_PHASE, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXI2_ERROR_INVALID_PHASE, AXIS2_FAILURE);
         return AXIS2_SUCCESS;
     }
     
@@ -1048,7 +1048,7 @@
 
 static axis2_status_t
 axis2_dep_engine_add_new_svc(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_svc_grp_t *svc_metadata)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
@@ -1057,7 +1057,7 @@
     int i = 0;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, svc_metadata, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, svc_metadata, AXIS2_FAILURE);
     dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
 /*  Iterator services = currentArchiveFile.getService().values().iterator(); */
@@ -1104,7 +1104,7 @@
             } 
             else 
             {
-                AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_MODUELE_REF,
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODUELE_REF,
                     AXIS2_FAILURE);
                 return AXIS2_FAILURE;
             }
@@ -1129,7 +1129,7 @@
             } 
             else 
             {
-                AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_MODUELE_REF,
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODUELE_REF,
                     AXIS2_FAILURE);
                 return AXIS2_FAILURE;
             }
@@ -1169,7 +1169,7 @@
                 } 
                 else 
                 {
-                    AXIS2_ERROR_SET((*env)->error,
+                    AXIS2_ERROR_SET(env->error,
                         AXIS2_ERROR_INVALID_MODUELE_REF_BY_OP, AXIS2_FAILURE);
                     return AXIS2_FAILURE;
                 }
@@ -1182,7 +1182,7 @@
 
 static axis2_status_t
 axis2_dep_engine_load_svc_props(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_svc_t *svc)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
@@ -1192,7 +1192,7 @@
     axis2_flow_t *out_fault_flow = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, svc, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, svc, AXIS2_FAILURE);
     dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
     in_flow = AXIS2_SVC_GET_INFLOW(svc, env);
@@ -1224,7 +1224,7 @@
 
 static axis2_status_t
 axis2_dep_engine_load_module_dll(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_module_desc_t *module_desc)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
@@ -1241,7 +1241,7 @@
     axis2_char_t *dll_name = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, module_desc, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
     dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
     read_in_dll = AXIS2_ARCH_FILE_DATA_GET_MODULE_DLL_NAME(dep_engine_impl->
@@ -1256,7 +1256,7 @@
     module_folder_path = AXIS2_FILE_GET_PATH(module_folder, env);
     temp_path = AXIS2_STRACAT(module_folder_path, AXIS2_PATH_SEP_STR, env);
     dll_path = AXIS2_STRACAT(temp_path, dll_name, env);
-    AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI, 
+    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, 
         "axis2_dep_engine_load_module_dll; dll path is : %s", dll_path);
     status = AXIS2_DLL_DESC_SET_NAME(dll_desc, env, dll_path);
     if(AXIS2_SUCCESS != status)
@@ -1265,9 +1265,9 @@
         return AXIS2_FAILURE;
     }
     /* free all temp vars */
-    AXIS2_FREE((*env)->allocator, temp_path);
+    AXIS2_FREE(env->allocator, temp_path);
     temp_path = NULL;
-    AXIS2_FREE((*env)->allocator, dll_path);
+    AXIS2_FREE(env->allocator, dll_path);
     dll_path = NULL;
     
     AXIS2_DLL_DESC_SET_TYPE(dll_desc, env, AXIS2_MODULE_DLL);
@@ -1288,7 +1288,7 @@
 
 static axis2_status_t
 axis2_dep_engine_add_module_flow_handlers(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_flow_t *flow,
                                     axis2_hash_t *handler_create_func_map)
 {
@@ -1296,7 +1296,7 @@
     int j = 0;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, flow, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, flow, AXIS2_FAILURE);
     
     count = AXIS2_FLOW_GET_HANDLER_COUNT(flow, env);
     
@@ -1322,14 +1322,14 @@
 
 static axis2_status_t
 axis2_dep_engine_add_flow_handlers(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_flow_t *flow)
 {
     int count = 0;
     int j = 0;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, flow, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, flow, AXIS2_FAILURE);
     
     count = AXIS2_FLOW_GET_HANDLER_COUNT(flow, env);
     
@@ -1365,7 +1365,7 @@
 
 void * AXIS2_CALL
 axis2_dep_engine_get_handler_dll(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_char_t *class_name)
 {
     axis2_dll_desc_t *dll_desc = NULL;
@@ -1374,7 +1374,7 @@
     axis2_char_t *dll_name = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, class_name, NULL);
+    AXIS2_PARAM_CHECK(env->error, class_name, NULL);
     
     dll_desc = axis2_dll_desc_create(env);
     dll_name = 
@@ -1395,7 +1395,7 @@
 
 static axis2_status_t
 axis2_dep_engine_add_new_module(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_module_desc_t *module_metadata)
 {
     axis2_flow_t *in_flow = NULL;
@@ -1457,7 +1457,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_do_deploy(axis2_dep_engine_t *dep_engine,
-                            axis2_env_t **env)
+                            const axis2_env_t *env)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     int size = 0;
@@ -1498,7 +1498,7 @@
                     if(AXIS2_SUCCESS != status)
                     {
                         AXIS2_ARCH_READER_FREE(arch_reader, env);
-                        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_SVC, 
+                        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SVC, 
                             AXIS2_FAILURE);
                         return status;
                     }
@@ -1507,7 +1507,7 @@
                     if(AXIS2_SUCCESS != status)
                     {
                         AXIS2_ARCH_READER_FREE(arch_reader, env);
-                        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_SVC, 
+                        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SVC, 
                             AXIS2_FAILURE);
                         return status;
                     }
@@ -1525,7 +1525,7 @@
                     if(AXIS2_SUCCESS != status)
                     {
                         AXIS2_ARCH_READER_FREE(arch_reader, env);
-                        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_MODULE, 
+                        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE, 
                             AXIS2_FAILURE);
                         return AXIS2_FAILURE;
                     }
@@ -1534,7 +1534,7 @@
                     if(AXIS2_SUCCESS != status)
                     {
                         AXIS2_ARCH_READER_FREE(arch_reader, env);
-                        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_MODULE, 
+                        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE, 
                             AXIS2_FAILURE);
                         return AXIS2_FAILURE;
                     }
@@ -1550,7 +1550,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_undeploy(axis2_dep_engine_t *dep_engine,
-                            axis2_env_t **env)
+                            const axis2_env_t *env)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     int size = 0;
@@ -1593,7 +1593,7 @@
 
 axis2_bool_t AXIS2_CALL
 axis2_dep_engine_is_hot_update(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env) 
+                                const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     return AXIS2_INTF_TO_IMPL(dep_engine)->hot_update;
@@ -1601,7 +1601,7 @@
 
 static axis2_char_t *
 axis2_dep_engine_get_axis_svc_name(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_char_t *file_name) 
 {
     axis2_char_t name_sep = '.';
@@ -1618,19 +1618,19 @@
     ptr = AXIS2_STRRCHR(temp_name, name_sep);
     ptr[0] = '\0';
     len = strlen(temp_name);
-    svc_name = AXIS2_MALLOC((*env)->allocator, len + 1);
+    svc_name = AXIS2_MALLOC(env->allocator, len + 1);
     sscanf(temp_name, "%s", svc_name);
-    AXIS2_FREE((*env)->allocator, file_name_l);
+    AXIS2_FREE(env->allocator, file_name_l);
     return svc_name;
 }
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_set_phases_info(axis2_dep_engine_t *dep_engine,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_phases_info_t *phases_info) 
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, phases_info, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE);
     AXIS2_INTF_TO_IMPL(dep_engine)->phases_info = phases_info;
     return AXIS2_SUCCESS;
 }
@@ -1648,7 +1648,7 @@
  */
 axis2_svc_t *AXIS2_CALL
 axis2_dep_engine_build_svc(axis2_dep_engine_t *dep_engine,
-                            axis2_env_t **env,
+                            const axis2_env_t *env,
                             axis2_svc_t *svc,
                             axis2_char_t *file_name)
 {
@@ -1656,7 +1656,7 @@
     axis2_om_node_t *node = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, file_name, NULL);
+    AXIS2_PARAM_CHECK(env->error, file_name, NULL);
     dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
     dep_engine_impl->curr_file = axis2_arch_file_data_create_with_type_and_name(
@@ -1683,7 +1683,7 @@
 
 axis2_module_desc_t *AXIS2_CALL
 axis2_dep_engine_build_module(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_file_t *module_archive,
                                 axis2_conf_t *conf)
 {
@@ -1700,8 +1700,8 @@
     axis2_status_t status = AXIS2_FAILURE;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, module_archive, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, conf, NULL);
+    AXIS2_PARAM_CHECK(env->error, module_archive, NULL);
+    AXIS2_PARAM_CHECK(env->error, conf, NULL);
     dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
     phases_info = AXIS2_CONF_GET_PHASESINFO(conf, env);
@@ -1764,14 +1764,14 @@
 
 axis2_char_t *AXIS2_CALL
 axis2_dep_engine_get_repos_path(axis2_dep_engine_t *dep_engine,
-                                axis2_env_t **env)
+                                const axis2_env_t *env)
 {
     return AXIS2_INTF_TO_IMPL(dep_engine)->folder_name;
 }
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_set_current_file_item(axis2_dep_engine_t *dep_engine,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_arch_file_data_t *file_data)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;
@@ -1791,7 +1791,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_dep_engine_set_arch_reader(axis2_dep_engine_t *dep_engine,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_arch_reader_t *arch_reader)
 {
     axis2_dep_engine_impl_t *dep_engine_impl = NULL;

Modified: webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c Wed May 31 08:54:07 2006
@@ -44,30 +44,30 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_desc_builder_free (axis2_desc_builder_t *desc_builder, 
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_om_node_t *AXIS2_CALL
 axis2_build_OM(axis2_desc_builder_t *desc_builder,
-                axis2_env_t **env);
+                const axis2_env_t *env);
 
 
 struct axis2_flow *AXIS2_CALL
 axis2_desc_builder_process_flow(axis2_desc_builder_t *desc_builder,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 struct axis2_om_element *flow_element,
                                 axis2_param_container_t *parent,
                                 axis2_om_node_t *node);
 
 struct axis2_handler_desc *AXIS2_CALL
 axis2_desc_builder_process_handler(axis2_desc_builder_t *desc_builder,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_om_node_t *handler_element,
                                     axis2_param_container_t *parent);
 
 
 axis2_status_t AXIS2_CALL
 axis2_desc_builder_process_params(axis2_desc_builder_t *desc_builder,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_om_children_qname_iterator_t *params,
                                 axis2_param_container_t *param_container,
                                 axis2_param_container_t *parent );
@@ -75,52 +75,52 @@
 
 axis2_status_t AXIS2_CALL
 axis2_desc_builder_process_op_module_refs(axis2_desc_builder_t *desc_builder,
-                          axis2_env_t **env,
+                          const axis2_env_t *env,
                           axis2_om_children_qname_iterator_t *module_refs, 
                           struct axis2_op *op);
                               
 struct axis2_msg_recv *AXIS2_CALL
 axis2_desc_builder_load_msg_recv(axis2_desc_builder_t *desc_builder,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_om_element_t *recv_element);
 
 struct axis2_msg_recv *AXIS2_CALL
 axis2_desc_builder_load_default_msg_recv(axis2_desc_builder_t *desc_builder,
-                                            axis2_env_t **env);
+                                            const axis2_env_t *env);
 
 
 axis2_char_t *AXIS2_CALL
 axis2_desc_builder_get_short_file_name(axis2_desc_builder_t *desc_builder,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_char_t *file_name);
 
 axis2_char_t *AXIS2_CALL
 axis2_desc_builder_get_file_name_without_prefix(axis2_desc_builder_t *desc_builder,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_char_t *short_file_name);
 
 axis2_char_t *AXIS2_CALL
 axis2_desc_builder_get_value(axis2_desc_builder_t *desc_builder,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_char_t *in);
 
                                 
 /************************** End of function prototypes ************************/
 
 axis2_desc_builder_t * AXIS2_CALL 
-axis2_desc_builder_create (axis2_env_t **env)
+axis2_desc_builder_create (const axis2_env_t *env)
 {
     axis2_desc_builder_impl_t *desc_builder_impl = NULL;
     
 	AXIS2_ENV_CHECK(env, NULL);
 	
-	desc_builder_impl = (axis2_desc_builder_impl_t *) AXIS2_MALLOC((*env)->
+	desc_builder_impl = (axis2_desc_builder_impl_t *) AXIS2_MALLOC(env->
         allocator, sizeof(axis2_desc_builder_impl_t));
 	
 	
 	if(NULL == desc_builder_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;
     }
     desc_builder_impl->file_name = NULL;
@@ -129,11 +129,11 @@
     desc_builder_impl->desc_builder.ops = NULL;
     
 	desc_builder_impl->desc_builder.ops = 
-		AXIS2_MALLOC ((*env)->allocator, sizeof(axis2_desc_builder_ops_t));
+		AXIS2_MALLOC (env->allocator, sizeof(axis2_desc_builder_ops_t));
 	if(NULL == desc_builder_impl->desc_builder.ops)
     {
         axis2_desc_builder_free(&(desc_builder_impl->desc_builder), 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;
     }
     
@@ -163,28 +163,28 @@
 
 axis2_desc_builder_t * AXIS2_CALL 
 axis2_desc_builder_create_with_file_and_dep_engine (
-                                        axis2_env_t **env, 
+                                        const axis2_env_t *env, 
                                         axis2_char_t *file_name, 
                                         axis2_dep_engine_t *engine)
 {
     axis2_desc_builder_impl_t *desc_builder_impl = NULL;
     
 	AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, file_name, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, engine, NULL);
+    AXIS2_PARAM_CHECK(env->error, file_name, NULL);
+    AXIS2_PARAM_CHECK(env->error, engine, NULL);
 	
 	desc_builder_impl = (axis2_desc_builder_impl_t *) 
         axis2_desc_builder_create(env);
 	if(NULL == desc_builder_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;
     }
     
     desc_builder_impl->file_name = AXIS2_STRDUP(file_name, env);
     if(!desc_builder_impl->file_name)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     desc_builder_impl->desc_builder.engine = engine;
@@ -194,19 +194,19 @@
 
 axis2_desc_builder_t * AXIS2_CALL 
 axis2_desc_builder_create_with_dep_engine (
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         struct axis2_dep_engine *engine)
 {
     axis2_desc_builder_impl_t *desc_builder_impl = NULL;
     
 	AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, engine, NULL);
+    AXIS2_PARAM_CHECK(env->error, engine, NULL);
 	
 	desc_builder_impl = (axis2_desc_builder_impl_t *)
         axis2_desc_builder_create(env);
 	if(NULL == desc_builder_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;
     }
     
@@ -219,7 +219,7 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_desc_builder_free (axis2_desc_builder_t *desc_builder, 
-                            axis2_env_t **env)
+                            const axis2_env_t *env)
 {
     axis2_desc_builder_impl_t *desc_builder_impl = NULL;
     
@@ -229,7 +229,7 @@
     
     if(desc_builder_impl->file_name)
     {
-        AXIS2_FREE((*env)->allocator, desc_builder_impl->file_name);
+        AXIS2_FREE(env->allocator, desc_builder_impl->file_name);
         desc_builder_impl->file_name = NULL;
     }
 
@@ -243,11 +243,11 @@
     desc_builder->engine = NULL;
     
 	if(NULL != desc_builder->ops)
-        AXIS2_FREE((*env)->allocator, desc_builder->ops);
+        AXIS2_FREE(env->allocator, desc_builder->ops);
     
     if(desc_builder_impl)
     {
-        AXIS2_FREE((*env)->allocator, desc_builder_impl);
+        AXIS2_FREE(env->allocator, desc_builder_impl);
         desc_builder_impl = NULL;
     }
 	return AXIS2_SUCCESS;
@@ -255,7 +255,7 @@
 
 axis2_om_node_t *AXIS2_CALL
 axis2_build_OM(axis2_desc_builder_t *desc_builder,
-                axis2_env_t **env) 
+                const axis2_env_t *env) 
 {
     axis2_desc_builder_impl_t *desc_builder_impl = NULL;
     axis2_xml_reader_t *reader = NULL;
@@ -267,7 +267,7 @@
     
     if(!desc_builder_impl->file_name)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_STATE_DESC_BUILDER,
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_DESC_BUILDER,
             AXIS2_FAILURE);
         return NULL;
     }
@@ -277,7 +277,7 @@
 
     if(!reader)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_CREATING_XML_STREAM_READER,
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CREATING_XML_STREAM_READER,
             AXIS2_FAILURE)
         return NULL;
     }
@@ -287,7 +287,7 @@
 
     if(!(desc_builder_impl->builder))
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_CREATING_XML_STREAM_READER,
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CREATING_XML_STREAM_READER,
             AXIS2_FAILURE)
         return NULL;
     }
@@ -310,7 +310,7 @@
 
 axis2_flow_t *AXIS2_CALL
 axis2_desc_builder_process_flow(axis2_desc_builder_t *desc_builder,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_om_element_t *flow_element,
                                 axis2_param_container_t *parent,
                                 axis2_om_node_t *flow_node)
@@ -320,13 +320,13 @@
     axis2_qname_t *qchild = NULL;
         
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, parent, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, flow_node, NULL);
+    AXIS2_PARAM_CHECK(env->error, parent, NULL);
+    AXIS2_PARAM_CHECK(env->error, flow_node, NULL);
         
     flow = axis2_flow_create(env);
     if(!flow)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     
@@ -365,7 +365,7 @@
 
 struct axis2_handler_desc *AXIS2_CALL
 axis2_desc_builder_process_handler(axis2_desc_builder_t *desc_builder,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     axis2_om_node_t *handler_node,
                                     struct axis2_param_container *parent)
 {
@@ -382,8 +382,8 @@
     axis2_qname_t *order_qname = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, handler_node, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, parent, NULL);
+    AXIS2_PARAM_CHECK(env->error, handler_node, NULL);
+    AXIS2_PARAM_CHECK(env->error, parent, NULL);
     
     handler_desc = axis2_handler_desc_create_with_qname(env, NULL);
     if(!handler_desc)
@@ -403,7 +403,7 @@
     if(!name_attrib)
     {
         AXIS2_HANDLER_DESC_FREE(handler_desc, env);
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE,
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE,
             AXIS2_FAILURE);
         return NULL;
     }
@@ -435,7 +435,7 @@
     if(NULL == class_attrib)
     {
         AXIS2_HANDLER_DESC_FREE(handler_desc, env);
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE,
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE,
             AXIS2_FAILURE);
         return NULL;   
     }
@@ -461,7 +461,7 @@
     if(NULL == order_element || NULL == order_node)
     {
         AXIS2_HANDLER_DESC_FREE(handler_desc, env);
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, 
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, 
             AXIS2_FAILURE);
         return NULL;
     }
@@ -544,7 +544,7 @@
                     if(AXIS2_SUCCESS != status)
                     {
                         AXIS2_HANDLER_DESC_FREE(handler_desc, env);
-                        AXIS2_FREE((*env)->allocator, bool_val);
+                        AXIS2_FREE(env->allocator, bool_val);
                         return NULL;
                     }
                 }
@@ -557,11 +557,11 @@
                     if(AXIS2_SUCCESS != status)
                     {
                         AXIS2_HANDLER_DESC_FREE(handler_desc, env);
-                        AXIS2_FREE((*env)->allocator, bool_val);
+                        AXIS2_FREE(env->allocator, bool_val);
                         return NULL;
                     }
                 }
-                AXIS2_FREE((*env)->allocator, bool_val);
+                AXIS2_FREE(env->allocator, bool_val);
             }
             index_i = axis2_hash_next (env, index_i);
         }
@@ -591,7 +591,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_desc_builder_process_params(axis2_desc_builder_t *desc_builder,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_om_children_qname_iterator_t *params,
                                 axis2_param_container_t *param_container,
                                 axis2_param_container_t *parent )
@@ -599,9 +599,9 @@
     axis2_status_t status = AXIS2_FAILURE;
         
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, params, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, param_container, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, parent, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, params, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, param_container, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, parent, AXIS2_FAILURE);
     
     while(AXIS2_FALSE != AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(params, env))
     {
@@ -660,7 +660,7 @@
                 if(!obj)
                 {
                     AXIS2_PARAM_FREE(param, env);
-                    AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, 
+                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, 
                             AXIS2_FAILURE);
                     return AXIS2_FAILURE;
                 }
@@ -721,7 +721,7 @@
             if(AXIS2_SUCCESS != status)
             {
                 AXIS2_PARAM_FREE(param, env);
-                AXIS2_FREE((*env)->allocator, para_test_value);
+                AXIS2_FREE(env->allocator, para_test_value);
                 return status;
             }
             AXIS2_PARAM_SET_PARAM_TYPE(param, env, AXIS2_TEXT_PARAM);
@@ -756,7 +756,7 @@
                 if(parent && AXIS2_TRUE == is_param_locked)
                 {
                     AXIS2_PARAM_FREE(param, env);
-                    AXIS2_ERROR_SET((*env)->error, 
+                    AXIS2_ERROR_SET(env->error, 
                         AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE);
                     return AXIS2_FAILURE;
                 }
@@ -807,7 +807,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_desc_builder_process_op_module_refs(axis2_desc_builder_t *desc_builder,
-                              axis2_env_t **env,
+                              const axis2_env_t *env,
                               axis2_om_children_qname_iterator_t *module_refs, 
                               axis2_op_t *op)
 {
@@ -818,7 +818,7 @@
     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);
     desc_builder_impl = AXIS2_INTF_TO_IMPL(desc_builder);
     
     while(module_refs && AXIS2_TRUE == AXIS2_OM_CHILDREN_QNAME_ITERATOR_HAS_NEXT(module_refs,
@@ -842,7 +842,7 @@
             if(NULL == module_desc)
             {
                 AXIS2_QNAME_FREE(ref_qname, env);
-                AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_MODULE_NOT_FOUND, 
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, 
                     AXIS2_FAILURE);
                 return AXIS2_FAILURE;
             }
@@ -852,7 +852,7 @@
                 AXIS2_QNAME_FREE(ref_qname, env);
                 if(AXIS2_SUCCESS != status)
                 {
-                    AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_MODULE_NOT_FOUND, 
+                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, 
                         AXIS2_FAILURE);
                     return AXIS2_FAILURE;
                 }
@@ -864,7 +864,7 @@
 
 axis2_msg_recv_t *AXIS2_CALL
 axis2_desc_builder_load_msg_recv(axis2_desc_builder_t *desc_builder,
-                                    axis2_env_t **env,
+                                    const axis2_env_t *env,
                                     struct axis2_om_element *recv_element)
 {
     axis2_om_attribute_t *recv_name = NULL;
@@ -882,7 +882,7 @@
     axis2_char_t *msg_recv_dll_name = NULL;
         
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, recv_element, NULL);
+    AXIS2_PARAM_CHECK(env->error, recv_element, NULL);
 
     class_qname = axis2_qname_create(env, AXIS2_CLASSNAME, NULL, NULL);
     recv_name = AXIS2_OM_ELEMENT_GET_ATTRIBUTE(recv_element, env, class_qname);
@@ -907,11 +907,11 @@
         temp_path2 = AXIS2_STRACAT(temp_path, AXIS2_LIB_FOLDER, env);
         temp_path3 = AXIS2_STRACAT(temp_path2, AXIS2_PATH_SEP_STR, env);
         dll_name = AXIS2_STRACAT(temp_path3, msg_recv_dll_name, env);
-        AXIS2_FREE((*env)->allocator, temp_path);
-        AXIS2_FREE((*env)->allocator, temp_path2);
-        AXIS2_FREE((*env)->allocator, temp_path3);
+        AXIS2_FREE(env->allocator, temp_path);
+        AXIS2_FREE(env->allocator, temp_path2);
+        AXIS2_FREE(env->allocator, temp_path3);
         AXIS2_DLL_DESC_SET_NAME(dll_desc, env, dll_name);
-        AXIS2_FREE((*env)->allocator, dll_name);
+        AXIS2_FREE(env->allocator, dll_name);
         AXIS2_DLL_DESC_SET_TYPE(dll_desc, env, AXIS2_MSG_RECV_DLL);
         impl_info_param = axis2_param_create(env, class_name, NULL);
         AXIS2_PARAM_SET_VALUE(impl_info_param, env, dll_desc);
@@ -930,7 +930,7 @@
 
 struct axis2_msg_recv *AXIS2_CALL
 axis2_desc_builder_load_default_msg_recv(axis2_desc_builder_t *desc_builder,
-                                            axis2_env_t **env)
+                                            const axis2_env_t *env)
 {
     axis2_msg_recv_t *msg_recv = NULL;
   
@@ -940,7 +940,7 @@
 
 axis2_char_t *AXIS2_CALL
 axis2_desc_builder_get_short_file_name(axis2_desc_builder_t *desc_builder,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_char_t *file_name) 
 {
     axis2_char_t *separator = NULL;
@@ -949,12 +949,12 @@
     axis2_char_t *short_name = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, file_name, NULL);
+    AXIS2_PARAM_CHECK(env->error, file_name, NULL);
     
     file_name_l = AXIS2_STRDUP(file_name, env);
     if(!file_name_l)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     separator = ".";
@@ -969,18 +969,18 @@
 
 axis2_char_t *AXIS2_CALL
 axis2_desc_builder_get_file_name_without_prefix(axis2_desc_builder_t *desc_builder,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_char_t *short_file_name)
 {
     axis2_char_t *file_name_l = NULL;
     axis2_char_t *short_name = NULL;
     int len = 0;
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, short_file_name, NULL);
+    AXIS2_PARAM_CHECK(env->error, short_file_name, NULL);
     file_name_l = AXIS2_STRDUP(short_file_name, env);
     if(!file_name_l)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     len = AXIS2_STRLEN(AXIS2_LIB_PREFIX);
@@ -991,7 +991,7 @@
 
 axis2_char_t *AXIS2_CALL
 axis2_desc_builder_get_value(axis2_desc_builder_t *desc_builder,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_char_t *in) 
 {
     axis2_char_t *separator = ":";
@@ -999,12 +999,12 @@
     axis2_char_t *in_l = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, in, NULL);
+    AXIS2_PARAM_CHECK(env->error, in, NULL);
     
     in_l = AXIS2_STRDUP(in, env);
     if(!in_l)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     value = AXIS2_STRSTR(in_l, separator);

Modified: webservices/axis2/trunk/c/modules/core/deployment/module_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/deployment/module_builder.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/module_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/module_builder.c Wed May 31 08:54:07 2006
@@ -35,45 +35,45 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_module_builder_free (axis2_module_builder_t *module_builder, 
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 
 axis2_status_t AXIS2_CALL
 axis2_module_builder_populate_module(axis2_module_builder_t *module_builder,
-                                        axis2_env_t **env);
+                                        const axis2_env_t *env);
 
 axis2_array_list_t *AXIS2_CALL
 axis2_module_builder_process_ops(axis2_module_builder_t *module_builder,
-            axis2_env_t **env,
+            const axis2_env_t *env,
             axis2_om_children_qname_iterator_t *op_itr);
                                 
 /************************** End of function prototypes ************************/
 
 axis2_module_builder_t * AXIS2_CALL 
-axis2_module_builder_create (axis2_env_t **env)
+axis2_module_builder_create (const axis2_env_t *env)
 {
     axis2_module_builder_impl_t *module_builder_impl = NULL;
     
 	AXIS2_ENV_CHECK(env, NULL);
 	
-	module_builder_impl = (axis2_module_builder_impl_t *) AXIS2_MALLOC((*env)->
+	module_builder_impl = (axis2_module_builder_impl_t *) AXIS2_MALLOC(env->
         allocator, sizeof(axis2_module_builder_impl_t));
 	
 	
 	if(NULL == module_builder_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;
     }
     
     module_builder_impl->module_builder.ops = NULL;
     
 	module_builder_impl->module_builder.ops = 
-		AXIS2_MALLOC ((*env)->allocator, sizeof(axis2_module_builder_ops_t));
+		AXIS2_MALLOC (env->allocator, sizeof(axis2_module_builder_ops_t));
 	if(NULL == module_builder_impl->module_builder.ops)
     {
         axis2_module_builder_free(&(module_builder_impl->module_builder), 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;
     }
     
@@ -85,7 +85,7 @@
 }
 
 axis2_module_builder_t * AXIS2_CALL 
-axis2_module_builder_create_with_file_and_dep_engine_and_module (axis2_env_t **env,
+axis2_module_builder_create_with_file_and_dep_engine_and_module (const axis2_env_t *env,
                                                 axis2_char_t *file_name,
                                                 axis2_dep_engine_t *dep_engine,
                                                 axis2_module_desc_t *module_desc)
@@ -97,7 +97,7 @@
 	builder_impl = (axis2_module_builder_impl_t *) axis2_module_builder_create(env);
 	if(NULL == builder_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;
     }
     builder_impl->module_builder.desc_builder = 
@@ -116,7 +116,7 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_module_builder_free (axis2_module_builder_t *module_builder, 
-                            axis2_env_t **env)
+                            const axis2_env_t *env)
 {
     axis2_module_builder_impl_t *module_builder_impl = NULL;
     
@@ -132,13 +132,13 @@
 
 	if(NULL != module_builder->ops)
     {
-        AXIS2_FREE((*env)->allocator, module_builder->ops);
+        AXIS2_FREE(env->allocator, module_builder->ops);
         module_builder->ops = NULL;
     }
     
     if(module_builder_impl)
     {
-        AXIS2_FREE((*env)->allocator, module_builder_impl);
+        AXIS2_FREE(env->allocator, module_builder_impl);
         module_builder_impl = NULL;
     }
     
@@ -147,7 +147,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_module_builder_populate_module(axis2_module_builder_t *module_builder,
-                                        axis2_env_t **env)
+                                        const axis2_env_t *env)
 {
     axis2_module_builder_impl_t *builder_impl = NULL;
     axis2_om_element_t *module_element = NULL;
@@ -177,7 +177,7 @@
     int i = 0;
     axis2_status_t status = AXIS2_FAILURE;
     
-    AXIS2_LOG_TRACE((*env)->log, AXIS2_LOG_SI, "axis2_module_builder_populate_module start");
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_module_builder_populate_module start");
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     builder_impl = AXIS2_INTF_TO_IMPL(module_builder);
@@ -202,7 +202,7 @@
         if(NULL != module_name && (0 != AXIS2_STRCMP("", module_name)))
         {
             axis2_qname_t *qmodule_name = NULL;
-            AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI, "Populate module %s", module_name);
+            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Populate module %s", module_name);
             
             qmodule_name = axis2_qname_create(env, module_name, NULL, NULL);
             AXIS2_MODULE_DESC_SET_NAME(builder_impl->module_desc, env, qmodule_name);
@@ -218,7 +218,7 @@
             file_data = AXIS2_DEP_ENGINE_GET_CURRENT_FILE_ITEM(module_builder->
                 desc_builder->engine, env);
             module_name = AXIS2_ARCH_FILE_DATA_GET_MODULE_NAME(file_data, env);
-            AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI, "Populate module %s", module_name);
+            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Populate module %s", module_name);
      
             module_qname = axis2_qname_create(env, module_name, NULL, NULL);
             AXIS2_MODULE_DESC_SET_NAME(builder_impl->module_desc, env, module_qname);
@@ -389,21 +389,21 @@
         AXIS2_MODULE_DESC_ADD_OP(builder_impl->module_desc, env, op);
     }
     AXIS2_ARRAY_LIST_FREE(ops, env);
-    AXIS2_LOG_TRACE((*env)->log, AXIS2_LOG_SI, "axis2_module_builder_populate_module end");
+    AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_module_builder_populate_module end");
     return AXIS2_SUCCESS;
 }
 
 
 axis2_array_list_t *AXIS2_CALL
 axis2_module_builder_process_ops(axis2_module_builder_t *module_builder,
-            axis2_env_t **env,
+            const axis2_env_t *env,
             axis2_om_children_qname_iterator_t *op_itr)
 {
     axis2_module_builder_impl_t *builder_impl = NULL;
     axis2_array_list_t *ops = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
-    AXIS2_PARAM_CHECK((*env)->error, op_itr, NULL);
+    AXIS2_PARAM_CHECK(env->error, op_itr, NULL);
     builder_impl = AXIS2_INTF_TO_IMPL(module_builder);
     
     ops = axis2_array_list_create(env, 0);
@@ -439,7 +439,7 @@
 
         if(NULL == op_name_att)
         {
-            AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_OP_NAME_MISSING,
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OP_NAME_MISSING,
                 AXIS2_FAILURE);
             return NULL;
         }

Modified: webservices/axis2/trunk/c/modules/core/deployment/phases_info.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/deployment/phases_info.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/phases_info.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/phases_info.c Wed May 31 08:54:07 2006
@@ -21,79 +21,79 @@
 
 axis2_status_t AXIS2_CALL
 axis2_phases_info_free (axis2_phases_info_t *phases_info,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL 
 axis2_phases_info_set_in_phases(axis2_phases_info_t *phases_info,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_array_list_t *in_phases);
 
 axis2_status_t AXIS2_CALL 
 axis2_phases_info_set_out_phases(axis2_phases_info_t *phases_info,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_array_list_t *out_phases);
 
 axis2_status_t AXIS2_CALL 
 axis2_phases_info_set_in_faultphases(axis2_phases_info_t *phases_info,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_array_list_t *in_faultphases);
                                 
 axis2_status_t AXIS2_CALL 
 axis2_phases_info_set_out_faultphases(axis2_phases_info_t *phases_info,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_array_list_t * out_faultphases);
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_in_phases(axis2_phases_info_t *phases_info,
-                                axis2_env_t **env);
+                                const axis2_env_t *env);
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_out_phases(axis2_phases_info_t *phases_info,
-                                axis2_env_t **env);
+                                const axis2_env_t *env);
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_in_faultphases(axis2_phases_info_t *phases_info,
-                                        axis2_env_t **env);
+                                        const axis2_env_t *env);
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_out_faultphases(axis2_phases_info_t *phases_info,
-                                        axis2_env_t **env);
+                                        const axis2_env_t *env);
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_op_in_phases(axis2_phases_info_t *phases_info,
-                                        axis2_env_t **env);
+                                        const axis2_env_t *env);
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_op_out_phases(axis2_phases_info_t *phases_info,
-                                            axis2_env_t **env);
+                                            const axis2_env_t *env);
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_op_in_faultphases(axis2_phases_info_t *phases_info,
-                                                axis2_env_t **env);
+                                                const axis2_env_t *env);
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_op_out_faultphases(axis2_phases_info_t *phases_info,
-                                                axis2_env_t **env);
+                                                const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL 
 axis2_phases_info_set_op_phases(axis2_phases_info_t *phases_info,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         struct axis2_op *op_desc);
                                     
 /***************************** End of function headers ************************/
 
 axis2_phases_info_t * AXIS2_CALL 
-axis2_phases_info_create (axis2_env_t **env)
+axis2_phases_info_create (const axis2_env_t *env)
 {
     axis2_phases_info_impl_t *phases_info_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
     
-	phases_info_impl = (axis2_phases_info_impl_t *) AXIS2_MALLOC ((*env)->allocator, 
+	phases_info_impl = (axis2_phases_info_impl_t *) AXIS2_MALLOC (env->allocator, 
         sizeof(axis2_phases_info_impl_t));
     
 	if(NULL == phases_info_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;
 	}
        
@@ -103,13 +103,13 @@
     phases_info_impl->out_faultphases = NULL;
 	
 	phases_info_impl->phases_info.ops = (axis2_phases_info_ops_t *)
-		AXIS2_MALLOC ((*env)->allocator, sizeof(axis2_phases_info_ops_t));
+		AXIS2_MALLOC (env->allocator, sizeof(axis2_phases_info_ops_t));
     
 	if(NULL == phases_info_impl->phases_info.ops)
 	{
-		AXIS2_FREE ((*env)->allocator, phases_info_impl);
+		AXIS2_FREE (env->allocator, phases_info_impl);
         phases_info_impl = NULL;
-		AXIS2_ERROR_SET ((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+		AXIS2_ERROR_SET (env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;        
 	}
     
@@ -161,7 +161,7 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_phases_info_free (axis2_phases_info_t *phases_info, 
-                            axis2_env_t **env)
+                            const axis2_env_t *env)
 {
     axis2_phases_info_impl_t *phases_info_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -193,13 +193,13 @@
 
 	if(NULL != phases_info->ops)
     {
-        AXIS2_FREE((*env)->allocator, phases_info->ops);
+        AXIS2_FREE(env->allocator, phases_info->ops);
         phases_info->ops = NULL;
     }
     
     if(NULL != phases_info_impl)
     {
-        AXIS2_FREE((*env)->allocator, phases_info_impl);
+        AXIS2_FREE(env->allocator, phases_info_impl);
         phases_info_impl = NULL;
     }
     
@@ -209,13 +209,13 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_phases_info_set_in_phases(axis2_phases_info_t *phases_info,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_array_list_t *in_phases) 
 {
     axis2_phases_info_impl_t *phases_info_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, in_phases, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, in_phases, AXIS2_FAILURE);
     phases_info_impl = AXIS2_INTF_TO_IMPL(phases_info);
 
     if(phases_info_impl->in_phases)
@@ -230,13 +230,13 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_phases_info_set_out_phases(axis2_phases_info_t *phases_info,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_array_list_t *out_phases) 
 {
     axis2_phases_info_impl_t *phases_info_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, out_phases, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, out_phases, AXIS2_FAILURE);
     
     phases_info_impl = AXIS2_INTF_TO_IMPL(phases_info);
     if(phases_info_impl->out_phases)
@@ -250,13 +250,13 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_phases_info_set_in_faultphases(axis2_phases_info_t *phases_info,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_array_list_t *in_faultphases) 
 {
     axis2_phases_info_impl_t *phases_info_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, in_faultphases, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, in_faultphases, AXIS2_FAILURE);
     
     phases_info_impl = AXIS2_INTF_TO_IMPL(phases_info);
     if(phases_info_impl->in_faultphases)
@@ -270,13 +270,13 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_phases_info_set_out_faultphases(axis2_phases_info_t *phases_info,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_array_list_t * out_faultphases) 
 {
     axis2_phases_info_impl_t *phases_info_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, out_faultphases, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, out_faultphases, AXIS2_FAILURE);
     
     phases_info_impl = AXIS2_INTF_TO_IMPL(phases_info);
     if(phases_info_impl->out_faultphases)
@@ -290,7 +290,7 @@
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_in_phases(axis2_phases_info_t *phases_info,
-                                axis2_env_t **env) 
+                                const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     
@@ -299,7 +299,7 @@
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_out_phases(axis2_phases_info_t *phases_info,
-                                axis2_env_t **env) 
+                                const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     
@@ -308,7 +308,7 @@
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_in_faultphases(axis2_phases_info_t *phases_info,
-                                        axis2_env_t **env) 
+                                        const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     
@@ -317,7 +317,7 @@
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_out_faultphases(axis2_phases_info_t *phases_info,
-                                        axis2_env_t **env) 
+                                        const axis2_env_t *env) 
 {
     AXIS2_ENV_CHECK(env, NULL);
     
@@ -326,7 +326,7 @@
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_op_in_phases(axis2_phases_info_t *phases_info,
-                                        axis2_env_t **env) 
+                                        const axis2_env_t *env) 
 {
     axis2_phases_info_impl_t *phases_info_impl = NULL;
     struct axis2_phase *phase = NULL;
@@ -342,7 +342,7 @@
     op_in_phases = axis2_array_list_create(env, 0);
     if(!op_in_phases)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     phase = axis2_phase_create(env, AXIS2_PHASE_POLICY_DETERMINATION);
@@ -402,7 +402,7 @@
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_op_out_phases(axis2_phases_info_t *phases_info,
-                                            axis2_env_t **env) 
+                                            const axis2_env_t *env) 
 {
     axis2_phases_info_impl_t *phases_info_impl = NULL;
     struct axis2_phase *phase = NULL;
@@ -421,7 +421,7 @@
     op_out_phases = axis2_array_list_create(env, 0);
     if(!op_out_phases)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     for (i = 0; i < size; i++) 
@@ -505,7 +505,7 @@
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_op_in_faultphases(axis2_phases_info_t *phases_info,
-                                                axis2_env_t **env) 
+                                                const axis2_env_t *env) 
 {
     axis2_phases_info_impl_t *phases_info_impl = NULL;
     int i = 0;
@@ -530,7 +530,7 @@
     op_in_faultphases = axis2_array_list_create(env, 0);
     if(!op_in_faultphases)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     for (i = 0; i < size; i++) 
@@ -565,7 +565,7 @@
 
 axis2_array_list_t *AXIS2_CALL 
 axis2_phases_info_get_op_out_faultphases(axis2_phases_info_t *phases_info,
-                                                axis2_env_t **env) 
+                                                const axis2_env_t *env) 
 {
     axis2_phases_info_impl_t *phases_info_impl = NULL;
     int i = 0;
@@ -589,7 +589,7 @@
     op_out_faultphases = axis2_array_list_create(env, 0);
     if(!op_out_faultphases)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     for (i = 0; i < size; i++) 
@@ -624,7 +624,7 @@
 
 axis2_status_t AXIS2_CALL 
 axis2_phases_info_set_op_phases(axis2_phases_info_t *phases_info,
-                                        axis2_env_t **env,
+                                        const axis2_env_t *env,
                                         axis2_op_t *op_desc) 
 {
     axis2_status_t status = AXIS2_FAILURE;
@@ -636,14 +636,14 @@
     axis2_phases_info_impl_t *phases_info_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, op_desc, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE);
     
     phases_info_impl = AXIS2_INTF_TO_IMPL(phases_info);
     
     op_in_phases = axis2_phases_info_get_op_in_phases(phases_info, env);
     if(NULL == op_in_phases)
     {
-        status = AXIS2_ERROR_GET_STATUS_CODE((*env)->error);
+        status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
         /* op_in_phases cannot be NULL */
         return status;
     }
@@ -651,7 +651,7 @@
     op_out_phases = axis2_phases_info_get_op_out_phases(phases_info, env);
     if(NULL == op_out_phases)
     {
-        status = AXIS2_ERROR_GET_STATUS_CODE((*env)->error);
+        status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
         /* op_out_phases cannot be NULL */
         return status;
     }
@@ -667,7 +667,7 @@
     }
     else
     {
-        status = AXIS2_ERROR_GET_STATUS_CODE((*env)->error);
+        status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
         if(AXIS2_SUCCESS != status)
         {
             return status;
@@ -680,7 +680,7 @@
     }
     else    
     {
-        status = AXIS2_ERROR_GET_STATUS_CODE((*env)->error);
+        status = AXIS2_ERROR_GET_STATUS_CODE(env->error);
         if(AXIS2_SUCCESS != status)
         {
             return status;

Modified: webservices/axis2/trunk/c/modules/core/deployment/repos_listener.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/deployment/repos_listener.c?rev=410566&r1=410565&r2=410566&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/repos_listener.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/repos_listener.c Wed May 31 08:54:07 2006
@@ -49,30 +49,30 @@
 
 axis2_status_t AXIS2_CALL
 axis2_repos_listener_free (axis2_repos_listener_t *repos_listener,
-                            axis2_env_t **env);
+                            const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_repos_listener_check_modules(axis2_repos_listener_t *listener,
-                                    axis2_env_t **env);
+                                    const axis2_env_t *env);
 
 
 axis2_status_t AXIS2_CALL
 axis2_repos_listener_check_svcs(axis2_repos_listener_t *listener,
-                                    axis2_env_t **env);
+                                    const axis2_env_t *env);
 
 axis2_status_t AXIS2_CALL
 axis2_repos_listener_update(axis2_repos_listener_t *listener,
-                                    axis2_env_t **env);
+                                    const axis2_env_t *env);
 
 
 axis2_status_t AXIS2_CALL
 axis2_repos_listener_init(axis2_repos_listener_t *listener,
-                                    axis2_env_t **env);
+                                    const axis2_env_t *env);
 
 
 axis2_status_t AXIS2_CALL
 axis2_repos_listener_start_listen(axis2_repos_listener_t *listener,
-                                    axis2_env_t **env);
+                                    const axis2_env_t *env);
 
 /**
  * This method is to search a given folder  for jar files
@@ -80,25 +80,25 @@
  */
 static axis2_status_t
 axis2_repos_listener_search(axis2_repos_listener_t *listener,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_char_t *folder_name,
                                 int type);
 
 /************************* End of function headers ****************************/	
 
 axis2_repos_listener_t *AXIS2_CALL
-axis2_repos_listener_create(axis2_env_t **env)
+axis2_repos_listener_create(const axis2_env_t *env)
 {
     axis2_repos_listener_impl_t *listener_impl = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     
-    listener_impl = (axis2_repos_listener_impl_t *) AXIS2_MALLOC ((*env)->allocator
+    listener_impl = (axis2_repos_listener_impl_t *) AXIS2_MALLOC (env->allocator
 		    , sizeof (axis2_repos_listener_impl_t));
     
 	if(NULL == listener_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;
     } 
     listener_impl->folder_name = NULL;
@@ -107,11 +107,11 @@
     listener_impl->repos_listener.ops = NULL;
     
     listener_impl->repos_listener.ops = (axis2_repos_listener_ops_t *) 
-        AXIS2_MALLOC((*env)->allocator, sizeof(axis2_repos_listener_ops_t));
+        AXIS2_MALLOC(env->allocator, sizeof(axis2_repos_listener_ops_t));
     
 	if(NULL == listener_impl->repos_listener.ops)
 	{
-        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,7 +140,7 @@
  */
 
 axis2_repos_listener_t *AXIS2_CALL
-axis2_repos_listener_create_with_folder_name_and_dep_engine(axis2_env_t **env,
+axis2_repos_listener_create_with_folder_name_and_dep_engine(const axis2_env_t *env,
                                                 axis2_char_t *folder_name,
                                                 axis2_dep_engine_t *dep_engine)
 {
@@ -158,7 +158,7 @@
     listener_impl->folder_name = AXIS2_STRDUP(folder_name, env);
     if(!listener_impl->folder_name)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     listener_impl->info_list = axis2_ws_info_list_create_with_dep_engine(
@@ -170,7 +170,7 @@
     status = axis2_repos_listener_init(&(listener_impl->repos_listener), env);
     if(AXIS2_SUCCESS != status)
     {
-        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_REPOS_LISTENER_INIT_FAILED,
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPOS_LISTENER_INIT_FAILED,
             AXIS2_FAILURE);
         return NULL;        
     }
@@ -182,7 +182,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_repos_listener_free (axis2_repos_listener_t *repos_listener,
-                        axis2_env_t **env)
+                        const axis2_env_t *env)
 {
     axis2_repos_listener_impl_t *listener_impl = NULL;
     
@@ -192,7 +192,7 @@
    
     if(listener_impl->folder_name)
     {
-        AXIS2_FREE((*env)->allocator, listener_impl->folder_name);
+        AXIS2_FREE(env->allocator, listener_impl->folder_name);
         listener_impl->folder_name = NULL;
     }
     
@@ -204,11 +204,11 @@
 
 	if(NULL != repos_listener->ops)
     {
-		AXIS2_FREE((*env)->allocator, repos_listener->ops);
+		AXIS2_FREE(env->allocator, repos_listener->ops);
         repos_listener->ops = NULL;
     }
     
-    AXIS2_FREE((*env)->allocator, listener_impl);
+    AXIS2_FREE(env->allocator, listener_impl);
     listener_impl = NULL;
 
 	return AXIS2_SUCCESS;
@@ -216,7 +216,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_repos_listener_check_modules(axis2_repos_listener_t *listener,
-                                    axis2_env_t **env) 
+                                    const axis2_env_t *env) 
 {
     axis2_repos_listener_impl_t *listener_impl = NULL;
     axis2_char_t *module_path = NULL;
@@ -229,15 +229,15 @@
     temp_path = AXIS2_STRACAT(listener_impl->folder_name, AXIS2_PATH_SEP_STR, 
         env);
     module_path = AXIS2_STRACAT(temp_path, AXIS2_MODULE_PATH, env);
-    AXIS2_FREE((*env)->allocator, temp_path);
+    AXIS2_FREE(env->allocator, temp_path);
     status = axis2_repos_listener_search(listener, env, module_path, AXIS2_MODULE);
-    AXIS2_FREE((*env)->allocator, module_path);
+    AXIS2_FREE(env->allocator, module_path);
     return status;
 }
 
 axis2_status_t AXIS2_CALL
 axis2_repos_listener_check_svcs(axis2_repos_listener_t *listener,
-                                    axis2_env_t **env) 
+                                    const axis2_env_t *env) 
 {
     axis2_repos_listener_impl_t *listener_impl = NULL;
     axis2_char_t *svc_path = NULL;
@@ -250,15 +250,15 @@
     temp_path = AXIS2_STRACAT(listener_impl->folder_name, AXIS2_PATH_SEP_STR, 
         env);
     svc_path = AXIS2_STRACAT(temp_path, AXIS2_SVC_PATH, env);
-    AXIS2_FREE((*env)->allocator, temp_path);
+    AXIS2_FREE(env->allocator, temp_path);
     status = axis2_repos_listener_search(listener, env, svc_path, AXIS2_SVC);
-    AXIS2_FREE((*env)->allocator, svc_path);
+    AXIS2_FREE(env->allocator, svc_path);
     return status;
 }
 
 axis2_status_t AXIS2_CALL
 axis2_repos_listener_update(axis2_repos_listener_t *listener,
-                                    axis2_env_t **env) 
+                                    const axis2_env_t *env) 
 {
     axis2_repos_listener_impl_t *listener_impl = NULL;
     
@@ -272,7 +272,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_repos_listener_init(axis2_repos_listener_t *listener,
-                                    axis2_env_t **env) 
+                                    const axis2_env_t *env) 
 {
     axis2_repos_listener_impl_t *listener_impl = NULL;
     axis2_status_t status = AXIS2_FAILURE;
@@ -300,7 +300,7 @@
 
 axis2_status_t AXIS2_CALL
 axis2_repos_listener_start_listen(axis2_repos_listener_t *listener,
-                                    axis2_env_t **env) 
+                                    const axis2_env_t *env) 
 {
     axis2_repos_listener_impl_t *listener_impl = NULL;
     
@@ -316,7 +316,7 @@
 
 static axis2_status_t
 axis2_repos_listener_search(axis2_repos_listener_t *listener,
-                                axis2_env_t **env,
+                                const axis2_env_t *env,
                                 axis2_char_t *folder_name,
                                 int type) 
 {
@@ -327,7 +327,7 @@
     axis2_status_t status = AXIS2_FAILURE;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    AXIS2_PARAM_CHECK((*env)->error, folder_name, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, folder_name, AXIS2_FAILURE);
     listener_impl = AXIS2_INTF_TO_IMPL(listener);
 
     current_info_list = AXIS2_DIR_HANDLER_LIST_SERVICE_OR_MODULE_DIRS(env, 
@@ -336,12 +336,12 @@
     {
         axis2_status_t status_code = AXIS2_FAILURE;
 
-        status_code = AXIS2_ERROR_GET_STATUS_CODE((*env)->error);
+        status_code = AXIS2_ERROR_GET_STATUS_CODE(env->error);
         if(AXIS2_SUCCESS != status)
         {
             return status;
         }
-        AXIS2_LOG_DEBUG((*env)->log, AXIS2_LOG_SI, "No %s in the folder.", folder_name); 
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No %s in the folder.", folder_name); 
         return AXIS2_SUCCESS;
     }
     size = AXIS2_ARRAY_LIST_SIZE(current_info_list, env);



---------------------------------------------------------------------
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