axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dami...@apache.org
Subject svn commit: r380321 - in /webservices/axis2/trunk/c/modules/core: deployment/ description/ engine/ phaseresolver/ receivers/
Date Fri, 24 Feb 2006 03:32:09 GMT
Author: damitha
Date: Thu Feb 23 19:32:06 2006
New Revision: 380321

URL: http://svn.apache.org/viewcvs?rev=380321&view=rev
Log:
More memory leak fixes

Modified:
    webservices/axis2/trunk/c/modules/core/deployment/arch_reader.c
    webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c
    webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c
    webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c
    webservices/axis2/trunk/c/modules/core/deployment/module_builder.c
    webservices/axis2/trunk/c/modules/core/description/op.c
    webservices/axis2/trunk/c/modules/core/engine/conf.c
    webservices/axis2/trunk/c/modules/core/phaseresolver/Makefile.am
    webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c
    webservices/axis2/trunk/c/modules/core/receivers/msg_recv.c
    webservices/axis2/trunk/c/modules/core/receivers/raw_xml_in_out_msg_recv.c

Modified: webservices/axis2/trunk/c/modules/core/deployment/arch_reader.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/deployment/arch_reader.c?rev=380321&r1=380320&r2=380321&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/arch_reader.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/arch_reader.c Thu Feb 23 19:32:06 2006
@@ -28,9 +28,7 @@
 typedef struct axis2_arch_reader_impl
 {
 	axis2_arch_reader_t arch_reader;
-    
     axis2_desc_builder_t *desc_builder;
-    
     axis2_module_builder_t *module_builder;
     	
 } axis2_arch_reader_impl_t;
@@ -126,30 +124,32 @@
 axis2_arch_reader_free (axis2_arch_reader_t *arch_reader, 
                             axis2_env_t **env)
 {
-    axis2_arch_reader_impl_t *feature_impl = NULL;
+    axis2_arch_reader_impl_t *arch_reader_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     
-    feature_impl = AXIS2_INTF_TO_IMPL(arch_reader);
+    arch_reader_impl = AXIS2_INTF_TO_IMPL(arch_reader);
     
 	if(NULL != arch_reader->ops)
         AXIS2_FREE((*env)->allocator, arch_reader->ops);
    
-    /* TODO: it fails to load svc so file if I do this. Fix this - Samisa
-	if(NULL != feature_impl->desc_builder)
+	if(NULL != arch_reader_impl->desc_builder)
     {
-        AXIS2_DESC_BUILDER_FREE(feature_impl->desc_builder, env);
-        feature_impl->desc_builder = NULL;
-    }*/
-    
-	if(NULL != feature_impl->module_builder)
+        AXIS2_DESC_BUILDER_FREE(arch_reader_impl->desc_builder, env);
+        arch_reader_impl->desc_builder = NULL;
+    }
+
+	if(NULL != arch_reader_impl->module_builder)
     {
-        AXIS2_DESC_BUILDER_FREE(feature_impl->module_builder, env);
-        feature_impl->module_builder = NULL;
+        AXIS2_MODULE_BUILDER_FREE(arch_reader_impl->module_builder, env);
+        arch_reader_impl->module_builder = NULL;
+    }
+   
+    if(arch_reader_impl) 
+    {
+        AXIS2_FREE((*env)->allocator, arch_reader_impl);
+        arch_reader_impl = NULL;
     }
-    
-    AXIS2_FREE((*env)->allocator, feature_impl);
-    feature_impl = NULL;
     
 	return AXIS2_SUCCESS;
 }
@@ -379,7 +379,7 @@
                                 axis2_dep_engine_t *dep_engine,
                                 axis2_svc_grp_t *svc_grp)
 {                       
-    axis2_arch_reader_impl_t *feature_impl = NULL;
+    axis2_arch_reader_impl_t *arch_reader_impl = NULL;
     axis2_char_t *root_element_name = NULL;
     axis2_om_node_t *svcs = NULL;
     axis2_om_element_t *svcs_element = NULL;
@@ -389,15 +389,15 @@
     AXIS2_PARAM_CHECK((*env)->error, svc_xml, AXIS2_FAILURE);    
     AXIS2_PARAM_CHECK((*env)->error, dep_engine, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, svc_grp, AXIS2_FAILURE);
-    feature_impl = AXIS2_INTF_TO_IMPL(arch_reader);
+    arch_reader_impl = AXIS2_INTF_TO_IMPL(arch_reader);
     
-    feature_impl->desc_builder = axis2_desc_builder_create_with_file_and_dep_engine(env, 
+    arch_reader_impl->desc_builder = axis2_desc_builder_create_with_file_and_dep_engine(env, 
         svc_xml, dep_engine);
-    if(!(feature_impl->desc_builder))
+    if(!(arch_reader_impl->desc_builder))
     {
         return AXIS2_FAILURE;
     }
-    svcs = AXIS2_DESC_BUILDER_BUILD_OM(feature_impl->desc_builder, env);
+    svcs = AXIS2_DESC_BUILDER_BUILD_OM(arch_reader_impl->desc_builder, env);
     svcs_element = AXIS2_OM_NODE_GET_DATA_ELEMENT(svcs, env);
     root_element_name = AXIS2_OM_ELEMENT_GET_LOCALNAME(svcs_element, env);
     if(0 == AXIS2_STRCMP(AXIS2_SVC_ELEMENT, root_element_name))
@@ -426,7 +426,6 @@
             }
         }
         AXIS2_SVC_SET_PARENT(svc, env, svc_grp);
-        /*axisService.setClassLoader(engine.getCurrentFileItem().getClassLoader());*/
         
         svc_builder = axis2_svc_builder_create_with_dep_engine_and_svc(env,
             dep_engine, svc);
@@ -457,7 +456,6 @@
         grp_builder = axis2_svc_grp_builder_create_with_svc_and_dep_engine(env, 
             svcs, dep_engine);
         status = AXIS2_SVC_GRP_BUILDER_POPULATE_SVC_GRP(grp_builder, env, svc_grp);
-        AXIS2_SVC_GRP_BUILDER_FREE(grp_builder, env);
     }
     return status;
 }
@@ -469,7 +467,7 @@
                                     axis2_dep_engine_t *dep_engine,
                                     axis2_module_desc_t *module_desc)
 {
-    axis2_arch_reader_impl_t *feature_impl = NULL;
+    axis2_arch_reader_impl_t *arch_reader_impl = NULL;
     axis2_status_t status = AXIS2_FAILURE;
     axis2_char_t *module_xml = NULL;
     axis2_char_t *repos_path = NULL;
@@ -483,8 +481,8 @@
     AXIS2_PARAM_CHECK((*env)->error, file_name, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, dep_engine, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, module_desc, AXIS2_FAILURE);
+    arch_reader_impl = AXIS2_INTF_TO_IMPL(arch_reader);
     
-    feature_impl = AXIS2_INTF_TO_IMPL(arch_reader);
     repos_path = AXIS2_DEP_ENGINE_GET_REPOS_PATH(dep_engine, env);
     temp_path = AXIS2_STRACAT(repos_path, AXIS2_PATH_SEP_STR, env);
     temp_path2 = AXIS2_STRACAT(temp_path, AXIS2_MODULE_FOLDER, env);
@@ -505,12 +503,17 @@
     status = axis2_file_handler_access(module_xml, AXIS2_F_OK);
     
     if(AXIS2_SUCCESS == status)
-    {
-        
-        feature_impl->module_builder = 
+    { 
+        if(arch_reader_impl->module_builder)
+        {
+            AXIS2_MODULE_BUILDER_FREE(arch_reader_impl->module_builder, env);
+            arch_reader_impl->module_builder = NULL;
+        }
+        arch_reader_impl->module_builder = 
             axis2_module_builder_create_with_file_and_dep_engine_and_module(env,
                 module_xml, dep_engine, module_desc);
-        status = AXIS2_MODULE_BUILDER_POPULATE_MODULE(feature_impl->module_builder, env);
+        status = AXIS2_MODULE_BUILDER_POPULATE_MODULE(arch_reader_impl->
+            module_builder, env);
         if(AXIS2_SUCCESS != status)
         {
             return AXIS2_FAILURE;

Modified: webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c?rev=380321&r1=380320&r2=380321&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/conf_builder.c Thu Feb 23 19:32:06 2006
@@ -147,17 +147,17 @@
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     
     conf_builder_impl = AXIS2_INTF_TO_IMPL(conf_builder);
+
+    if (conf_builder->desc_builder)
+    {
+        AXIS2_DESC_BUILDER_FREE(conf_builder->desc_builder, env);
+        conf_builder->desc_builder = NULL;
+    }
     
 	if(NULL != conf_builder->ops)
     {
         AXIS2_FREE((*env)->allocator, conf_builder->ops);
         conf_builder->ops = NULL;
-    }
-
-    if (conf_builder_impl->conf_builder.desc_builder)
-    {
-        AXIS2_DESC_BUILDER_FREE(conf_builder_impl->conf_builder.desc_builder, env);
-        conf_builder_impl->conf_builder.desc_builder = NULL;
     }
     
     if(conf_builder_impl)

Modified: webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c?rev=380321&r1=380320&r2=380321&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c Thu Feb 23 19:32:06 2006
@@ -293,107 +293,107 @@
 axis2_dep_engine_t *AXIS2_CALL
 axis2_dep_engine_create(axis2_env_t **env)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     
-    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 == engine_impl)
+	if(NULL == dep_engine_impl)
     {
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     } 
-    engine_impl->conf = NULL;
-    engine_impl->axis2_repos = NULL;
-    engine_impl->curr_file = NULL;
-    engine_impl->arch_reader = NULL;
-    engine_impl->ws_to_deploy = NULL;
-    engine_impl->ws_to_undeploy = NULL;
-    engine_impl->phases_info = NULL;
-    engine_impl->module_list = NULL;
-    engine_impl->folder_name = NULL;
-    engine_impl->conf_name = NULL; 
-    engine_impl->dep_engine.ops = NULL;
-    engine_impl->repos_listener = NULL;
-    engine_impl->conf_builder = NULL;
-    engine_impl->svc_builder = NULL;
+    dep_engine_impl->conf = NULL;
+    dep_engine_impl->axis2_repos = NULL;
+    dep_engine_impl->curr_file = NULL;
+    dep_engine_impl->arch_reader = NULL;
+    dep_engine_impl->ws_to_deploy = NULL;
+    dep_engine_impl->ws_to_undeploy = NULL;
+    dep_engine_impl->phases_info = NULL;
+    dep_engine_impl->module_list = NULL;
+    dep_engine_impl->folder_name = NULL;
+    dep_engine_impl->conf_name = NULL; 
+    dep_engine_impl->dep_engine.ops = NULL;
+    dep_engine_impl->repos_listener = NULL;
+    dep_engine_impl->conf_builder = NULL;
+    dep_engine_impl->svc_builder = NULL;
 
-    engine_impl->ws_to_deploy = axis2_array_list_create(env, 0);
-    if (!(engine_impl->ws_to_deploy))
+    dep_engine_impl->ws_to_deploy = axis2_array_list_create(env, 0);
+    if (!(dep_engine_impl->ws_to_deploy))
     {
-        axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+        axis2_dep_engine_free(&(dep_engine_impl->dep_engine), env);
         return NULL;
     }
     
-    engine_impl->phases_info = axis2_phases_info_create(env);
-    if (!(engine_impl->phases_info))
+    dep_engine_impl->phases_info = axis2_phases_info_create(env);
+    if (!(dep_engine_impl->phases_info))
     {
-        axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+        axis2_dep_engine_free(&(dep_engine_impl->dep_engine), env);
         return NULL;
     }
     
-    engine_impl->dep_engine.ops = (axis2_dep_engine_ops_t *) AXIS2_MALLOC(
+    dep_engine_impl->dep_engine.ops = (axis2_dep_engine_ops_t *) AXIS2_MALLOC(
         (*env)->allocator, sizeof(axis2_dep_engine_ops_t));
     
-    if(NULL == engine_impl->dep_engine.ops)
+    if(NULL == dep_engine_impl->dep_engine.ops)
     {
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+        axis2_dep_engine_free(&(dep_engine_impl->dep_engine), env);
         return NULL;
     }
     
-    engine_impl->dep_engine.ops->free = axis2_dep_engine_free;
-    engine_impl->dep_engine.ops->add_module = axis2_dep_engine_add_module;
-    engine_impl->dep_engine.ops->get_module = axis2_dep_engine_get_module;
-    engine_impl->dep_engine.ops->get_current_file_item = 
+    dep_engine_impl->dep_engine.ops->free = axis2_dep_engine_free;
+    dep_engine_impl->dep_engine.ops->add_module = axis2_dep_engine_add_module;
+    dep_engine_impl->dep_engine.ops->get_module = axis2_dep_engine_get_module;
+    dep_engine_impl->dep_engine.ops->get_current_file_item = 
             axis2_dep_engine_get_current_file_item; 
-    engine_impl->dep_engine.ops->add_ws_to_deploy = 
+    dep_engine_impl->dep_engine.ops->add_ws_to_deploy = 
             axis2_dep_engine_add_ws_to_deploy;
-    engine_impl->dep_engine.ops->add_ws_to_undeploy = 
+    dep_engine_impl->dep_engine.ops->add_ws_to_undeploy = 
             axis2_dep_engine_add_ws_to_undeploy;
-    engine_impl->dep_engine.ops->get_phases_info = 
+    dep_engine_impl->dep_engine.ops->get_phases_info = 
             axis2_dep_engine_get_phases_info;
     
-    engine_impl->dep_engine.ops->get_axis_conf = axis2_dep_engine_get_axis_conf;
-    engine_impl->dep_engine.ops->load = axis2_dep_engine_load;
-    engine_impl->dep_engine.ops->load_client = axis2_dep_engine_load_client; 
-    engine_impl->dep_engine.ops->get_handler_dll = 
+    dep_engine_impl->dep_engine.ops->get_axis_conf = axis2_dep_engine_get_axis_conf;
+    dep_engine_impl->dep_engine.ops->load = axis2_dep_engine_load;
+    dep_engine_impl->dep_engine.ops->load_client = axis2_dep_engine_load_client; 
+    dep_engine_impl->dep_engine.ops->get_handler_dll = 
             axis2_dep_engine_get_handler_dll;
-    engine_impl->dep_engine.ops->do_deploy = axis2_dep_engine_do_deploy;
-    engine_impl->dep_engine.ops->undeploy = axis2_dep_engine_undeploy;
-    engine_impl->dep_engine.ops->is_hot_update = axis2_dep_engine_is_hot_update;
-    engine_impl->dep_engine.ops->set_phases_info = 
+    dep_engine_impl->dep_engine.ops->do_deploy = axis2_dep_engine_do_deploy;
+    dep_engine_impl->dep_engine.ops->undeploy = axis2_dep_engine_undeploy;
+    dep_engine_impl->dep_engine.ops->is_hot_update = axis2_dep_engine_is_hot_update;
+    dep_engine_impl->dep_engine.ops->set_phases_info = 
             axis2_dep_engine_set_phases_info;
-    engine_impl->dep_engine.ops->build_svc = axis2_dep_engine_build_svc;
-    engine_impl->dep_engine.ops->build_module = axis2_dep_engine_build_module;
-    engine_impl->dep_engine.ops->get_repos_path = axis2_dep_engine_get_repos_path;
-    engine_impl->dep_engine.ops->set_current_file_item = 
+    dep_engine_impl->dep_engine.ops->build_svc = axis2_dep_engine_build_svc;
+    dep_engine_impl->dep_engine.ops->build_module = axis2_dep_engine_build_module;
+    dep_engine_impl->dep_engine.ops->get_repos_path = axis2_dep_engine_get_repos_path;
+    dep_engine_impl->dep_engine.ops->set_current_file_item = 
             axis2_dep_engine_set_current_file_item;
-    engine_impl->dep_engine.ops->set_arch_reader = 
+    dep_engine_impl->dep_engine.ops->set_arch_reader = 
 	    axis2_dep_engine_set_arch_reader;
     
-    return &(engine_impl->dep_engine);
+    return &(dep_engine_impl->dep_engine);
 }
 axis2_dep_engine_t *AXIS2_CALL 
 axis2_dep_engine_create_with_repos_name (
                                         axis2_env_t **env, 
                                         axis2_char_t *repos_path)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     
-	engine_impl = (axis2_dep_engine_impl_t *)
+	dep_engine_impl = (axis2_dep_engine_impl_t *)
         axis2_dep_engine_create_with_repos_name_and_svr_xml_file(env, 
             repos_path, AXIS2_SERVER_XML_FILE);
-    if(!engine_impl)
+    if(!dep_engine_impl)
     {
         return NULL;
     }
 					
-	return &(engine_impl->dep_engine);
+	return &(dep_engine_impl->dep_engine);
 }
 
 axis2_dep_engine_t *AXIS2_CALL
@@ -401,7 +401,7 @@
                                                     axis2_char_t *repos_path,
                                                     axis2_char_t *svr_xml_file)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_char_t *conf_file_l = NULL;
     axis2_status_t status = AXIS2_FAILURE;
     
@@ -415,9 +415,9 @@
         return NULL;
     }
     
-    engine_impl = (axis2_dep_engine_impl_t *) axis2_dep_engine_create(env);
+    dep_engine_impl = (axis2_dep_engine_impl_t *) axis2_dep_engine_create(env);
     
-	if(NULL == engine_impl)
+	if(NULL == dep_engine_impl)
     {
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
@@ -426,52 +426,52 @@
     status = axis2_file_handler_access(repos_path, AXIS2_F_OK);
     if(AXIS2_SUCCESS != status)
     {
-        axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+        axis2_dep_engine_free(&(dep_engine_impl->dep_engine), env);
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_REPOSITORY_NOT_EXIST, 
             AXIS2_FAILURE);
         return NULL;
     }
     
-    engine_impl->folder_name = AXIS2_STRDUP(repos_path, env);
-    if(NULL == engine_impl->folder_name)
+    dep_engine_impl->folder_name = AXIS2_STRDUP(repos_path, env);
+    if(NULL == dep_engine_impl->folder_name)
 	{
-        axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+        axis2_dep_engine_free(&(dep_engine_impl->dep_engine), env);
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
 	}
     
-    engine_impl->axis2_repos = AXIS2_STRDUP(repos_path, env);
-    if(NULL == engine_impl->axis2_repos)
+    dep_engine_impl->axis2_repos = AXIS2_STRDUP(repos_path, env);
+    if(NULL == dep_engine_impl->axis2_repos)
 	{
-        axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+        axis2_dep_engine_free(&(dep_engine_impl->dep_engine), env);
         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);
-    engine_impl->conf_name = AXIS2_STRACAT(conf_file_l, svr_xml_file, env);
+    dep_engine_impl->conf_name = AXIS2_STRACAT(conf_file_l, svr_xml_file, env);
     AXIS2_FREE((*env)->allocator, conf_file_l);
-    if(!engine_impl->conf_name)
+    if(!dep_engine_impl->conf_name)
     {
-        engine_impl->conf_name = 
+        dep_engine_impl->conf_name = 
             AXIS2_STRDUP(AXIS2_CONFIGURATION_RESOURCE, env);
-        if(!engine_impl->conf_name)
+        if(!dep_engine_impl->conf_name)
         {
-            axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+            axis2_dep_engine_free(&(dep_engine_impl->dep_engine), env);
             AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
             return NULL;
         }
     }
-    status = axis2_file_handler_access(engine_impl->conf_name, AXIS2_F_OK);
+    status = axis2_file_handler_access(dep_engine_impl->conf_name, AXIS2_F_OK);
     if(AXIS2_SUCCESS != status)
     {
-        axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+        axis2_dep_engine_free(&(dep_engine_impl->dep_engine), env);
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_CONFIG_NOT_FOUND, 
             AXIS2_FAILURE);
         return NULL;
     }
     
-    return &(engine_impl->dep_engine); 
+    return &(dep_engine_impl->dep_engine); 
 }
 
 /******************************************************************************/
@@ -480,112 +480,112 @@
 axis2_dep_engine_free (axis2_dep_engine_t *dep_engine,
                         axis2_env_t **env)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
-    if(engine_impl->curr_file)
+    if(dep_engine_impl->curr_file)
     {
-        AXIS2_ARCH_FILE_DATA_FREE(engine_impl->curr_file, env);
-        engine_impl->curr_file = NULL;
+        AXIS2_ARCH_FILE_DATA_FREE(dep_engine_impl->curr_file, env);
+        dep_engine_impl->curr_file = NULL;
     }
     
-    if(engine_impl->phases_info)
+    if(dep_engine_impl->phases_info)
     {
-        AXIS2_PHASES_INFO_FREE(engine_impl->phases_info, env);
-        engine_impl->phases_info = NULL;
+        AXIS2_PHASES_INFO_FREE(dep_engine_impl->phases_info, env);
+        dep_engine_impl->phases_info = NULL;
     }
     
-    if(engine_impl->conf_builder)
+    if(dep_engine_impl->conf_builder)
     {
-        AXIS2_CONF_BUILDER_FREE(engine_impl->conf_builder, env);
-        engine_impl->conf_builder = NULL;
+        AXIS2_CONF_BUILDER_FREE(dep_engine_impl->conf_builder, env);
+        dep_engine_impl->conf_builder = NULL;
     }
     
-    if(engine_impl->arch_reader)
+    if(dep_engine_impl->arch_reader)
     {
-        AXIS2_ARCH_READER_FREE(engine_impl->arch_reader, env);
-        engine_impl->arch_reader = NULL;
+        AXIS2_ARCH_READER_FREE(dep_engine_impl->arch_reader, env);
+        dep_engine_impl->arch_reader = NULL;
     }
     
-    if(engine_impl->svc_builder)
+    if(dep_engine_impl->svc_builder)
     {
-        AXIS2_SVC_BUILDER_FREE(engine_impl->svc_builder, env);
-        engine_impl->svc_builder = NULL;
+        AXIS2_SVC_BUILDER_FREE(dep_engine_impl->svc_builder, env);
+        dep_engine_impl->svc_builder = NULL;
     }
     
-    if(engine_impl->ws_to_deploy)
+    if(dep_engine_impl->ws_to_deploy)
     {
         int i = 0;
         int size = 0;
 
-        size = AXIS2_ARRAY_LIST_SIZE(engine_impl->ws_to_deploy, env);
+        size = AXIS2_ARRAY_LIST_SIZE(dep_engine_impl->ws_to_deploy, env);
         for(i = 0; i < size; i++)
         {
             axis2_arch_file_data_t *file_data = NULL;
             
             file_data = (axis2_arch_file_data_t *) 
-                AXIS2_ARRAY_LIST_GET(engine_impl->ws_to_deploy, env, i);
+                AXIS2_ARRAY_LIST_GET(dep_engine_impl->ws_to_deploy, env, i);
             AXIS2_ARCH_FILE_DATA_FREE(file_data, env);
         }
-        AXIS2_ARRAY_LIST_FREE(engine_impl->ws_to_deploy, env);
-        engine_impl->ws_to_deploy = NULL;
+        AXIS2_ARRAY_LIST_FREE(dep_engine_impl->ws_to_deploy, env);
+        dep_engine_impl->ws_to_deploy = NULL;
     }
-    if(engine_impl->ws_to_undeploy)
+    if(dep_engine_impl->ws_to_undeploy)
     {
         int i = 0;
         int size = 0;
 
-        size = AXIS2_ARRAY_LIST_SIZE(engine_impl->ws_to_undeploy, env);
+        size = AXIS2_ARRAY_LIST_SIZE(dep_engine_impl->ws_to_undeploy, env);
         for(i = 0; i < size; i++)
         {
             axis2_arch_file_data_t *file_data = NULL;
             
             file_data = (axis2_arch_file_data_t *) 
-                AXIS2_ARRAY_LIST_GET(engine_impl->ws_to_undeploy, env, i);
+                AXIS2_ARRAY_LIST_GET(dep_engine_impl->ws_to_undeploy, env, i);
             AXIS2_ARCH_FILE_DATA_FREE(file_data, env);
         }
-        AXIS2_ARRAY_LIST_FREE(engine_impl->ws_to_undeploy, env);
-        engine_impl->ws_to_undeploy = NULL;
+        AXIS2_ARRAY_LIST_FREE(dep_engine_impl->ws_to_undeploy, env);
+        dep_engine_impl->ws_to_undeploy = NULL;
     }
-    if(engine_impl->module_list)
+    if(dep_engine_impl->module_list)
     {
         int size = 0;
         int i = 0;
         
-        size = AXIS2_ARRAY_LIST_SIZE(engine_impl->module_list, env);
+        size = AXIS2_ARRAY_LIST_SIZE(dep_engine_impl->module_list, env);
         for(i = 0; i < size; i++)
         {
             axis2_qname_t *qname = NULL;
-            qname = AXIS2_ARRAY_LIST_GET(engine_impl->module_list, env, i);
+            qname = AXIS2_ARRAY_LIST_GET(dep_engine_impl->module_list, env, i);
             AXIS2_QNAME_FREE(qname, env);
             qname = NULL;
         }
-        AXIS2_ARRAY_LIST_FREE(engine_impl->module_list, env);
-        engine_impl->module_list = NULL;
+        AXIS2_ARRAY_LIST_FREE(dep_engine_impl->module_list, env);
+        dep_engine_impl->module_list = NULL;
     }
-    if(engine_impl->folder_name)
+    if(dep_engine_impl->folder_name)
     {
-        AXIS2_FREE((*env)->allocator, engine_impl->folder_name);
-        engine_impl->folder_name = NULL;
+        AXIS2_FREE((*env)->allocator, dep_engine_impl->folder_name);
+        dep_engine_impl->folder_name = NULL;
     }
-    if(engine_impl->conf_name)
+    if(dep_engine_impl->conf_name)
     {
-        AXIS2_FREE((*env)->allocator, engine_impl->conf_name);
-        engine_impl->conf_name = NULL;
+        AXIS2_FREE((*env)->allocator, dep_engine_impl->conf_name);
+        dep_engine_impl->conf_name = NULL;
     }
-    if(engine_impl->axis2_repos)
+    if(dep_engine_impl->axis2_repos)
     {
-        AXIS2_FREE((*env)->allocator, engine_impl->axis2_repos);
-        engine_impl->axis2_repos = NULL;
+        AXIS2_FREE((*env)->allocator, dep_engine_impl->axis2_repos);
+        dep_engine_impl->axis2_repos = NULL;
     }
     
-    if(engine_impl->repos_listener)
+    if(dep_engine_impl->repos_listener)
     {
-        AXIS2_REPOS_LISTENER_FREE(engine_impl->repos_listener, env);
-        engine_impl->repos_listener = NULL;
+        AXIS2_REPOS_LISTENER_FREE(dep_engine_impl->repos_listener, env);
+        dep_engine_impl->repos_listener = NULL;
     }
 
 	if(NULL != dep_engine->ops)
@@ -594,10 +594,10 @@
         dep_engine->ops = NULL;
     }
     
-    if(engine_impl)
+    if(dep_engine_impl)
     {
-        AXIS2_FREE((*env)->allocator, engine_impl);
-        engine_impl = NULL;
+        AXIS2_FREE((*env)->allocator, dep_engine_impl);
+        dep_engine_impl = NULL;
     }
     
 	return AXIS2_SUCCESS;
@@ -610,20 +610,20 @@
                                 axis2_qname_t *module_qname) 
 {
     axis2_qname_t *qname = NULL;
-    axis2_dep_engine_impl_t *engine_impl = 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);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
     qname = AXIS2_QNAME_CLONE(module_qname, env);
-    if(!engine_impl->module_list)
+    if(!dep_engine_impl->module_list)
     {
-        engine_impl->module_list = axis2_array_list_create(env, 0);
-        if(!engine_impl->module_list)
+        dep_engine_impl->module_list = axis2_array_list_create(env, 0);
+        if(!dep_engine_impl->module_list)
             return AXIS2_FAILURE;
     }
-    return AXIS2_ARRAY_LIST_ADD(engine_impl->module_list, env, qname);
+    return AXIS2_ARRAY_LIST_ADD(dep_engine_impl->module_list, env, qname);
 }
     
 struct axis2_module_desc *AXIS2_CALL
@@ -713,18 +713,18 @@
 axis2_dep_engine_set_dep_features(axis2_dep_engine_t *dep_engine,
                                     axis2_env_t **env) 
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_char_t *value = NULL;
     axis2_param_t *para_hot_dep = NULL;
     axis2_param_t *para_hot_update = NULL;
     
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
-    para_hot_dep = AXIS2_CONF_GET_PARAM(engine_impl->conf, env, 
+    para_hot_dep = AXIS2_CONF_GET_PARAM(dep_engine_impl->conf, env, 
         AXIS2_HOTDEPLOYMENT);
-    para_hot_update = AXIS2_CONF_GET_PARAM(engine_impl->conf, env, 
+    para_hot_update = AXIS2_CONF_GET_PARAM(dep_engine_impl->conf, env, 
         AXIS2_HOTUPDATE); 
     
     if(NULL != para_hot_dep)
@@ -732,7 +732,7 @@
         value = (axis2_char_t *) AXIS2_PARAM_GET_VALUE(para_hot_dep, env);
         if(0 == AXIS2_STRCASECMP("false", value))
         {
-            engine_impl->hot_dep = AXIS2_FALSE;
+            dep_engine_impl->hot_dep = AXIS2_FALSE;
         }
     }
     if(NULL != para_hot_update)
@@ -740,7 +740,7 @@
         value = (axis2_char_t *) AXIS2_PARAM_GET_VALUE(para_hot_update, env);
         if(0 == AXIS2_STRCASECMP("false", value))
         {
-            engine_impl->hot_update = AXIS2_FALSE;
+            dep_engine_impl->hot_update = AXIS2_FALSE;
         }
     }
     return AXIS2_SUCCESS;
@@ -750,37 +750,37 @@
 axis2_dep_engine_load(axis2_dep_engine_t *dep_engine,
                         axis2_env_t **env) 
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_status_t status = AXIS2_FAILURE;
     AXIS2_ENV_CHECK(env, NULL);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
-    if(NULL == engine_impl->conf_name)
+    if(NULL == dep_engine_impl->conf_name)
     {
         AXIS2_ERROR_SET((*env)->error, AXIS2_PATH_TO_CONFIG_CAN_NOT_BE_NULL,
             AXIS2_FAILURE);
         return NULL;        
     }
     
-    engine_impl->conf = axis2_conf_create(env);
+    dep_engine_impl->conf = axis2_conf_create(env);
     
-    if(!engine_impl->conf)
+    if(!dep_engine_impl->conf)
     {
         return NULL;
     }
     
-    engine_impl->conf_builder = axis2_conf_builder_create_with_file_and_dep_engine_and_conf(env,
-        engine_impl->conf_name, dep_engine, engine_impl->conf);
-    if(!(engine_impl->conf_builder))
+    dep_engine_impl->conf_builder = axis2_conf_builder_create_with_file_and_dep_engine_and_conf(env,
+        dep_engine_impl->conf_name, dep_engine, dep_engine_impl->conf);
+    if(!(dep_engine_impl->conf_builder))
     {
-        AXIS2_CONF_FREE(engine_impl->conf, env);
-        engine_impl->conf = NULL;
+        AXIS2_CONF_FREE(dep_engine_impl->conf, env);
+        dep_engine_impl->conf = NULL;
     }
-    status = AXIS2_CONF_BUILDER_POPULATE_CONF(engine_impl->conf_builder, env);
+    status = AXIS2_CONF_BUILDER_POPULATE_CONF(dep_engine_impl->conf_builder, env);
     if(AXIS2_SUCCESS != status)
     {
-        AXIS2_CONF_FREE(engine_impl->conf, env);
-        engine_impl->conf = NULL;
+        AXIS2_CONF_FREE(dep_engine_impl->conf, env);
+        dep_engine_impl->conf = NULL;
         return NULL;
     }
     status = axis2_dep_engine_set_dep_features(dep_engine, env);
@@ -797,49 +797,49 @@
     else 
     {
     */
-    if (engine_impl->repos_listener)
+    if (dep_engine_impl->repos_listener)
     {
-        AXIS2_REPOS_LISTENER_FREE(engine_impl->repos_listener, env);
+        AXIS2_REPOS_LISTENER_FREE(dep_engine_impl->repos_listener, env);
     }
-    engine_impl->repos_listener = 
+    dep_engine_impl->repos_listener = 
         axis2_repos_listener_create_with_folder_name_and_dep_engine(env,
-            engine_impl->folder_name, dep_engine);
-    if(!engine_impl->repos_listener)
+            dep_engine_impl->folder_name, dep_engine);
+    if(!dep_engine_impl->repos_listener)
     {
-        AXIS2_CONF_FREE(engine_impl->conf, env);
+        AXIS2_CONF_FREE(dep_engine_impl->conf, env);
         return NULL;
     }
-    AXIS2_CONF_SET_REPOS(engine_impl->conf, env, engine_impl->axis2_repos);
+    AXIS2_CONF_SET_REPOS(dep_engine_impl->conf, env, dep_engine_impl->axis2_repos);
     status = axis2_dep_engine_validate_system_predefined_phases(dep_engine, env);
     if(AXIS2_SUCCESS != status)
     {
-        AXIS2_REPOS_LISTENER_FREE(engine_impl->repos_listener, env);
-        AXIS2_CONF_FREE(engine_impl->conf, env);
+        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_FAILURE);
         return NULL;
     }
     
-    status = AXIS2_CONF_SET_PHASESINFO(engine_impl->conf, env, engine_impl->phases_info);
+    status = AXIS2_CONF_SET_PHASESINFO(dep_engine_impl->conf, env, dep_engine_impl->phases_info);
     if(AXIS2_SUCCESS != status) 
     {
-        AXIS2_REPOS_LISTENER_FREE(engine_impl->repos_listener, env);
-        AXIS2_CONF_FREE(engine_impl->conf, env);
+        AXIS2_REPOS_LISTENER_FREE(dep_engine_impl->repos_listener, env);
+        AXIS2_CONF_FREE(dep_engine_impl->conf, env);
         return NULL;
     }
     
     status = axis2_dep_engine_engage_modules(dep_engine, env);
     if(AXIS2_SUCCESS != status)
     {
-        AXIS2_REPOS_LISTENER_FREE(engine_impl->repos_listener, env);
-        AXIS2_CONF_FREE(engine_impl->conf, env);
+        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_FAILURE);
         return NULL;
     }
     /*}*/
     
-    return engine_impl->conf;
+    return dep_engine_impl->conf;
 }
 
 
@@ -848,16 +848,16 @@
                                 axis2_env_t **env,
                                 axis2_char_t *client_home) 
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_bool_t is_repos_exist = AXIS2_FALSE;
     axis2_status_t status = AXIS2_FAILURE;
     
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK((*env)->error, client_home, NULL);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
-    engine_impl->axis2_repos = AXIS2_STRDUP(client_home, env);
-    if(!engine_impl->axis2_repos)
+    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);
         return NULL;
@@ -872,60 +872,60 @@
     }
     else
     {
-        engine_impl->conf_name = AXIS2_STRDUP(AXIS2_CONFIGURATION_RESOURCE,
+        dep_engine_impl->conf_name = AXIS2_STRDUP(AXIS2_CONFIGURATION_RESOURCE,
                 env);
-        if(!engine_impl->conf_name)
+        if(!dep_engine_impl->conf_name)
         {
             AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
             return NULL;
         }
     }
-    engine_impl->conf = axis2_conf_create(env);
-    if(!engine_impl->conf)
+    dep_engine_impl->conf = axis2_conf_create(env);
+    if(!dep_engine_impl->conf)
     {
         return NULL;
     }
-    engine_impl->conf_builder = axis2_conf_builder_create_with_file_and_dep_engine_and_conf(env,
-        engine_impl->conf_name, dep_engine, engine_impl->conf);
-    if(!(engine_impl->conf_builder))
+    dep_engine_impl->conf_builder = axis2_conf_builder_create_with_file_and_dep_engine_and_conf(env,
+        dep_engine_impl->conf_name, dep_engine, dep_engine_impl->conf);
+    if(!(dep_engine_impl->conf_builder))
     {
-        AXIS2_CONF_FREE(engine_impl->conf, env);
-        engine_impl->conf = NULL;
+        AXIS2_CONF_FREE(dep_engine_impl->conf, env);
+        dep_engine_impl->conf = NULL;
     }
-    status = AXIS2_CONF_BUILDER_POPULATE_CONF(engine_impl->conf_builder, env);
+    status = AXIS2_CONF_BUILDER_POPULATE_CONF(dep_engine_impl->conf_builder, env);
     if(AXIS2_SUCCESS != status)
     {
-        AXIS2_CONF_FREE(engine_impl->conf, env);
-        engine_impl->conf = NULL;
+        AXIS2_CONF_FREE(dep_engine_impl->conf, env);
+        dep_engine_impl->conf = NULL;
         return NULL;
     }
  
     if (AXIS2_TRUE == is_repos_exist) 
     {
-        engine_impl->hot_dep = AXIS2_FALSE;
-        engine_impl->hot_update = AXIS2_FALSE;
-        if (engine_impl->repos_listener)
+        dep_engine_impl->hot_dep = AXIS2_FALSE;
+        dep_engine_impl->hot_update = AXIS2_FALSE;
+        if (dep_engine_impl->repos_listener)
         {
-            AXIS2_REPOS_LISTENER_FREE(engine_impl->repos_listener, env);
+            AXIS2_REPOS_LISTENER_FREE(dep_engine_impl->repos_listener, env);
         }
-        engine_impl->repos_listener = 
+        dep_engine_impl->repos_listener = 
             axis2_repos_listener_create_with_folder_name_and_dep_engine(env,
-                engine_impl->folder_name, dep_engine);
+                dep_engine_impl->folder_name, dep_engine);
     }
     
-    AXIS2_CONF_SET_REPOS(engine_impl->conf, env, engine_impl->axis2_repos);
-    AXIS2_CONF_SET_PHASESINFO(engine_impl->conf, env, engine_impl->phases_info);
+    AXIS2_CONF_SET_REPOS(dep_engine_impl->conf, env, dep_engine_impl->axis2_repos);
+    AXIS2_CONF_SET_PHASESINFO(dep_engine_impl->conf, env, dep_engine_impl->phases_info);
     status = axis2_dep_engine_engage_modules(dep_engine, env);
     if(AXIS2_FAILURE == status)
     {
-        AXIS2_REPOS_LISTENER_FREE(engine_impl->repos_listener, env);
-        AXIS2_CONF_FREE(engine_impl->conf, env);
+        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_FAILURE);
         return NULL;
     }
     
-    return engine_impl->conf;
+    return dep_engine_impl->conf;
 }
 
 
@@ -934,32 +934,32 @@
                                     axis2_env_t **env,
                                     axis2_char_t *client_home)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_char_t *path_l = NULL;
     axis2_status_t status = AXIS2_FAILURE;
     
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
 
-    engine_impl->folder_name = AXIS2_STRDUP(client_home, env);
-    if(!engine_impl->folder_name)
+    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);
         return AXIS2_FAILURE;
     }
     path_l = AXIS2_STRACAT(client_home, AXIS2_PATH_SEP_STR, env);
-    engine_impl->conf_name = AXIS2_STRACAT(path_l,AXIS2_SERVER_XML_FILE, env);
+    dep_engine_impl->conf_name = AXIS2_STRACAT(path_l,AXIS2_SERVER_XML_FILE, env);
     AXIS2_FREE((*env)->allocator, path_l);
-    if(!engine_impl->conf_name)
+    if(!dep_engine_impl->conf_name)
     {
-        engine_impl->conf_name = AXIS2_STRDUP(AXIS2_CONFIGURATION_RESOURCE, env);
-        if(!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_FAILURE)
             return AXIS2_FAILURE;
         }  
     }
-    status = axis2_file_handler_access(engine_impl->conf_name, AXIS2_F_OK);
+    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, 
@@ -974,27 +974,27 @@
 axis2_dep_engine_engage_modules(axis2_dep_engine_t *dep_engine,
                                     axis2_env_t **env)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     int size = 0;
     int i = 0;
     axis2_status_t status = AXIS2_FAILURE;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
-    if(!engine_impl->module_list)
+    if(!dep_engine_impl->module_list)
     {
         /* there are no modules */
         return AXIS2_SUCCESS;
     }
-    size = AXIS2_ARRAY_LIST_SIZE(engine_impl->module_list, env);
+    size = AXIS2_ARRAY_LIST_SIZE(dep_engine_impl->module_list, env);
     for(i = 0; i < size; i++)
     {
         axis2_qname_t *qname = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(
-            engine_impl->module_list, env, i);
-        if (qname && engine_impl->conf)
+            dep_engine_impl->module_list, env, i);
+        if (qname && dep_engine_impl->conf)
         {
-            status = AXIS2_CONF_ENGAGE_MODULE(engine_impl->conf, env, qname);
+            status = AXIS2_CONF_ENGAGE_MODULE(dep_engine_impl->conf, env, qname);
             if(AXIS2_SUCCESS != status)
             {
                 return AXIS2_FAILURE;
@@ -1008,7 +1008,7 @@
 axis2_dep_engine_validate_system_predefined_phases(axis2_dep_engine_t *dep_engine,
                                                     axis2_env_t **env) 
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_array_list_t *in_phases = NULL;
     axis2_char_t *phase0 = NULL;
     axis2_char_t *phase1 = NULL;
@@ -1016,9 +1016,9 @@
     axis2_char_t *phase3 = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
-    in_phases = AXIS2_PHASES_INFO_GET_IN_PHASES(engine_impl->phases_info, env);
+    in_phases = AXIS2_PHASES_INFO_GET_IN_PHASES(dep_engine_impl->phases_info, env);
     /* TODO condition checking should be otherway since null value can occur */
     if(in_phases)
     {
@@ -1058,18 +1058,18 @@
                                 axis2_env_t **env,
                                 axis2_svc_grp_t *svc_metadata)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_array_list_t *svcs = NULL;
     int sizei = 0;
     int i = 0;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, svc_metadata, AXIS2_FAILURE);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
 /*  Iterator services = currentArchiveFile.getService().values().iterator(); */
     
-    svcs = AXIS2_ARCH_FILE_DATA_GET_DEPLOYABLE_SVCS(engine_impl->curr_file, env);
+    svcs = AXIS2_ARCH_FILE_DATA_GET_DEPLOYABLE_SVCS(dep_engine_impl->curr_file, env);
     
     sizei = AXIS2_ARRAY_LIST_SIZE(svcs, env);
     
@@ -1088,7 +1088,7 @@
         svc = (axis2_svc_t *) AXIS2_ARRAY_LIST_GET(svcs, env, i);
         
         axis2_dep_engine_load_svc_props(dep_engine, env, svc);
-        file = AXIS2_ARCH_FILE_DATA_GET_FILE(engine_impl->curr_file, env);
+        file = AXIS2_ARCH_FILE_DATA_GET_FILE(dep_engine_impl->curr_file, env);
         file_name = AXIS2_FILE_GET_NAME(file, env);
         AXIS2_SVC_SET_FILENAME(svc, env, file_name);
 
@@ -1102,11 +1102,11 @@
             
             qmodulename = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(grp_modules, 
                 env, j);
-            module_desc = AXIS2_CONF_GET_MODULE(engine_impl->conf, env,
+            module_desc = AXIS2_CONF_GET_MODULE(dep_engine_impl->conf, env,
                 qmodulename);
             if(NULL != module_desc)
             {
-                AXIS2_SVC_ENGAGE_MODULE(svc, env, module_desc, engine_impl->conf);
+                AXIS2_SVC_ENGAGE_MODULE(svc, env, module_desc, dep_engine_impl->conf);
                 
             } 
             else 
@@ -1127,11 +1127,11 @@
             
             qmodulename = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(grp_modules, 
                 env, j);
-            module_desc = AXIS2_CONF_GET_MODULE(engine_impl->conf, env,
+            module_desc = AXIS2_CONF_GET_MODULE(dep_engine_impl->conf, env,
                 qmodulename);
             if(NULL != module_desc)
             {
-                AXIS2_SVC_ENGAGE_MODULE(svc, env, module_desc, engine_impl->conf);
+                AXIS2_SVC_ENGAGE_MODULE(svc, env, module_desc, dep_engine_impl->conf);
                 
             } 
             else 
@@ -1167,7 +1167,7 @@
                 
                 module_qname = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(modules, 
                     env, k);
-                module = AXIS2_CONF_GET_MODULE(engine_impl->conf, env, 
+                module = AXIS2_CONF_GET_MODULE(dep_engine_impl->conf, env, 
                     module_qname);
                 
                 if (NULL != module) 
@@ -1184,7 +1184,7 @@
         }
         AXIS2_SVC_GRP_ADD_SVC(svc_metadata, env, svc);
     }
-    return AXIS2_CONF_ADD_SVC_GRP(engine_impl->conf, env, svc_metadata);
+    return AXIS2_CONF_ADD_SVC_GRP(dep_engine_impl->conf, env, svc_metadata);
 }
 
 static axis2_status_t
@@ -1192,7 +1192,7 @@
                                 axis2_env_t **env,
                                 axis2_svc_t *svc)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_flow_t *in_flow = NULL;
     axis2_flow_t *out_flow = NULL;
     axis2_flow_t *in_fault_flow = NULL;
@@ -1200,7 +1200,7 @@
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, svc, AXIS2_FAILURE);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
     in_flow = AXIS2_SVC_GET_INFLOW(svc, env);
     if(NULL != in_flow)
@@ -1235,7 +1235,7 @@
                                     axis2_env_t **env,
                                     axis2_module_desc_t *module_desc)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_char_t *read_in_dll = NULL;
     axis2_module_t *module = NULL;
     axis2_dll_desc_t *dll_desc = NULL;
@@ -1250,15 +1250,15 @@
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, module_desc, AXIS2_FAILURE);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
-    read_in_dll = AXIS2_ARCH_FILE_DATA_GET_MODULE_DLL_NAME(engine_impl->
+    read_in_dll = AXIS2_ARCH_FILE_DATA_GET_MODULE_DLL_NAME(dep_engine_impl->
         curr_file, env);
     dll_desc = axis2_dll_desc_create(env);
     dll_name = AXIS2_DLL_DESC_CREATE_PLATFORM_SPECIFIC_DLL_NAME(dll_desc, env, 
         read_in_dll);
 
-    module_folder = AXIS2_ARCH_FILE_DATA_GET_FILE(engine_impl->curr_file, env);
+    module_folder = AXIS2_ARCH_FILE_DATA_GET_FILE(dep_engine_impl->curr_file, env);
     timestamp = AXIS2_FILE_GET_TIMESTAMP(module_folder, env);
     AXIS2_DLL_DESC_SET_TIMESTAMP(dll_desc, env, timestamp);
     module_folder_path = AXIS2_FILE_GET_PATH(module_folder, env);
@@ -1464,14 +1464,14 @@
 axis2_dep_engine_do_deploy(axis2_dep_engine_t *dep_engine,
                             axis2_env_t **env)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     int size = 0;
     axis2_status_t status = AXIS2_FAILURE;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
-    size = AXIS2_ARRAY_LIST_SIZE(engine_impl->ws_to_deploy, env);
+    size = AXIS2_ARRAY_LIST_SIZE(dep_engine_impl->ws_to_deploy, env);
     if (size > 0) 
     {
         int i = 0;
@@ -1482,23 +1482,23 @@
             axis2_char_t *file_name = NULL;
             axis2_module_desc_t *meta_data = NULL;
             
-            engine_impl->curr_file = (axis2_arch_file_data_t *) 
-                AXIS2_ARRAY_LIST_GET(engine_impl->ws_to_deploy, env, i);
+            dep_engine_impl->curr_file = (axis2_arch_file_data_t *) 
+                AXIS2_ARRAY_LIST_GET(dep_engine_impl->ws_to_deploy, env, i);
             
-            type = AXIS2_ARCH_FILE_DATA_GET_TYPE(engine_impl->curr_file, env);
+            type = AXIS2_ARCH_FILE_DATA_GET_TYPE(dep_engine_impl->curr_file, env);
             switch (type) 
             {
                 case AXIS2_SVC:
-                    engine_impl->arch_reader = axis2_arch_reader_create(env);
+                    dep_engine_impl->arch_reader = axis2_arch_reader_create(env);
 		    
                     
                     /*archiveReader.processWSDLs(currentArchiveFile,this); */
                     /* AxisService service = archiveReader.createService(currentArchiveFile.getAbsolutePath()); */
                     svc_grp = axis2_svc_grp_create_with_conf(env, 
-                        engine_impl->conf);
-                    file_name = AXIS2_ARCH_FILE_DATA_GET_NAME(engine_impl->
+                        dep_engine_impl->conf);
+                    file_name = AXIS2_ARCH_FILE_DATA_GET_NAME(dep_engine_impl->
                         curr_file, env);
-                    status = AXIS2_ARCH_READER_PROCESS_SVC_GRP(engine_impl->arch_reader, env,
+                    status = AXIS2_ARCH_READER_PROCESS_SVC_GRP(dep_engine_impl->arch_reader, env,
                         file_name, dep_engine, svc_grp);
                     if(AXIS2_SUCCESS != status)
                     {
@@ -1516,16 +1516,16 @@
                     }
                     /* log.info(Messages.getMessage(
                             DeploymentErrorMsgs.DEPLOYING_WS, currentArchiveFile.getName())); */
-                    engine_impl->curr_file = NULL;
+                    dep_engine_impl->curr_file = NULL;
                     break;
                 case AXIS2_MODULE:
-                    engine_impl->arch_reader = axis2_arch_reader_create(env);
+                    dep_engine_impl->arch_reader = axis2_arch_reader_create(env);
                     meta_data = axis2_module_desc_create(env);
-                    file_name = AXIS2_ARCH_FILE_DATA_GET_NAME(engine_impl->
+                    file_name = AXIS2_ARCH_FILE_DATA_GET_NAME(dep_engine_impl->
                         curr_file, env);
                     status = AXIS2_ARCH_READER_READ_MODULE_ARCH(
-		        engine_impl->arch_reader, env, file_name, dep_engine, 
-			meta_data);
+		                dep_engine_impl->arch_reader, env, file_name, dep_engine, 
+			                meta_data);
                     if(AXIS2_SUCCESS != status)
                     {
                         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_MODULE, 
@@ -1543,7 +1543,7 @@
                         
                     /*log.info(Messages.getMessage(DeploymentErrorMsgs.DEPLOYING_MODULE,
                             metaData.getName().getLocalPart())); */
-                    engine_impl->curr_file = NULL;
+                    dep_engine_impl->curr_file = NULL;
                     break;
 
             }
@@ -1556,13 +1556,13 @@
 axis2_dep_engine_undeploy(axis2_dep_engine_t *dep_engine,
                             axis2_env_t **env)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     int size = 0;
     axis2_char_t *svc_name = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
-    size = AXIS2_ARRAY_LIST_SIZE (engine_impl->ws_to_undeploy, env);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    size = AXIS2_ARRAY_LIST_SIZE (dep_engine_impl->ws_to_undeploy, env);
     
     if (size > 0) 
     {
@@ -1573,7 +1573,7 @@
             axis2_ws_info_t *ws_info = NULL;
             axis2_hash_t *faulty_svcs = NULL;
             
-            ws_info = (axis2_ws_info_t *) AXIS2_ARRAY_LIST_GET(engine_impl->
+            ws_info = (axis2_ws_info_t *) AXIS2_ARRAY_LIST_GET(dep_engine_impl->
                 ws_to_undeploy, env, i);
             type = AXIS2_WS_INFO_GET_TYPE(ws_info, env);
             if (type == AXIS2_SVC) 
@@ -1584,16 +1584,16 @@
                 svc_name = axis2_dep_engine_get_axis_svc_name(dep_engine, env,
                     file_name);
                 
-                AXIS2_CONF_REMOVE_SVC(engine_impl->conf, env, svc_name);
+                AXIS2_CONF_REMOVE_SVC(dep_engine_impl->conf, env, svc_name);
                 /*log.info(Messages.getMessage(DeploymentErrorMsgs.SERVICE_REMOVED,
                         wsInfo.getFilename()));*/
             }
-            faulty_svcs = AXIS2_CONF_GET_FAULTY_SVCS(engine_impl->conf, env);
+            faulty_svcs = AXIS2_CONF_GET_FAULTY_SVCS(dep_engine_impl->conf, env);
             axis2_hash_set(faulty_svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL);
         }
 
     }
-    AXIS2_ARRAY_LIST_FREE(engine_impl->ws_to_undeploy, env);
+    AXIS2_ARRAY_LIST_FREE(dep_engine_impl->ws_to_undeploy, env);
     return AXIS2_SUCCESS;
 }
 
@@ -1658,23 +1658,23 @@
                             axis2_svc_t *svc,
                             axis2_char_t *file_name)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_om_node_t *node = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK((*env)->error, file_name, NULL);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
-    engine_impl->curr_file = axis2_arch_file_data_create_with_type_and_name(
+    dep_engine_impl->curr_file = axis2_arch_file_data_create_with_type_and_name(
         env, AXIS2_SVC, "");
 
-    engine_impl->svc_builder = 
+    dep_engine_impl->svc_builder = 
         axis2_svc_builder_create_with_file_and_dep_engine_and_svc(env, 
         file_name, dep_engine, svc);
     
-    node = AXIS2_DESC_BUILDER_BUILD_OM(engine_impl->svc_builder->desc_builder, 
+    node = AXIS2_DESC_BUILDER_BUILD_OM(dep_engine_impl->svc_builder->desc_builder, 
         env);
-    AXIS2_SVC_BUILDER_POPULATE_SVC(engine_impl->svc_builder, env, node);
+    AXIS2_SVC_BUILDER_POPULATE_SVC(dep_engine_impl->svc_builder, env, node);
     axis2_dep_engine_load_svc_props(dep_engine, env, svc);
     
     return svc;
@@ -1693,7 +1693,7 @@
                                 axis2_file_t *module_archive,
                                 axis2_conf_t *conf)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     axis2_module_desc_t *module_desc = NULL;
     axis2_module_t *module = NULL;
     axis2_phases_info_t *phases_info = NULL;
@@ -1708,11 +1708,11 @@
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK((*env)->error, module_archive, NULL);
     AXIS2_PARAM_CHECK((*env)->error, conf, NULL);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
     phases_info = AXIS2_CONF_GET_PHASESINFO(conf, env);
     axis2_dep_engine_set_phases_info(dep_engine, env, phases_info);
-    engine_impl->curr_file = axis2_arch_file_data_create_with_type_and_file(
+    dep_engine_impl->curr_file = axis2_arch_file_data_create_with_type_and_file(
         env, AXIS2_MODULE, module_archive);
     module_desc = axis2_module_desc_create(env);
     arch_reader = axis2_arch_reader_create(env);
@@ -1764,7 +1764,7 @@
             module->handler_create_func_map);
     }
     
-    engine_impl->curr_file = NULL;
+    dep_engine_impl->curr_file = NULL;
     AXIS2_ARCH_READER_FREE(arch_reader, env);            
    
     /*axismodule.setModuleClassLoader(currentArchiveFile.getClassLoader()); */
@@ -1783,17 +1783,17 @@
                                         axis2_env_t **env,
                                         axis2_arch_file_data_t *file_data)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
-    if(engine_impl->curr_file)
+    if(dep_engine_impl->curr_file)
     {
-        AXIS2_ARCH_FILE_DATA_FREE(engine_impl->curr_file, env);
-        engine_impl->curr_file = NULL;
+        AXIS2_ARCH_FILE_DATA_FREE(dep_engine_impl->curr_file, env);
+        dep_engine_impl->curr_file = NULL;
     }
-    engine_impl->curr_file = file_data;
+    dep_engine_impl->curr_file = file_data;
     return AXIS2_SUCCESS;
 }
 
@@ -1803,17 +1803,17 @@
                                         axis2_env_t **env,
                                         axis2_arch_reader_t *arch_reader)
 {
-    axis2_dep_engine_impl_t *engine_impl = NULL;
+    axis2_dep_engine_impl_t *dep_engine_impl = NULL;
     
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+    dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
     
-    if(engine_impl->arch_reader)
+    if(dep_engine_impl->arch_reader)
     {
-        AXIS2_ARCH_FILE_DATA_FREE(engine_impl->arch_reader, env);
-        engine_impl->arch_reader = NULL;
+        AXIS2_ARCH_FILE_DATA_FREE(dep_engine_impl->arch_reader, env);
+        dep_engine_impl->arch_reader = NULL;
     }
-    engine_impl->arch_reader = arch_reader;
+    dep_engine_impl->arch_reader = arch_reader;
     return AXIS2_SUCCESS;
 }
 

Modified: webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c?rev=380321&r1=380320&r2=380321&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c Thu Feb 23 19:32:06 2006
@@ -256,23 +256,23 @@
 axis2_build_OM(axis2_desc_builder_t *desc_builder,
                 axis2_env_t **env) 
 {
-    axis2_desc_builder_impl_t *builder_impl = NULL;
+    axis2_desc_builder_impl_t *desc_builder_impl = NULL;
     axis2_xml_reader_t *reader = NULL;
     axis2_om_document_t *document = NULL;
     axis2_om_node_t *root = NULL;
     
     AXIS2_ENV_CHECK(env, NULL);
     
-    builder_impl = AXIS2_INTF_TO_IMPL(desc_builder);
+    desc_builder_impl = AXIS2_INTF_TO_IMPL(desc_builder);
     
-    if(!builder_impl->file_name)
+    if(!desc_builder_impl->file_name)
     {
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_STATE_DESC_BUILDER,
             AXIS2_FAILURE);
         return NULL;
     }
     /** create pull parser using the file path to configuration file */
-    reader = axis2_xml_reader_create_for_file(env, builder_impl->file_name,
+    reader = axis2_xml_reader_create_for_file(env, desc_builder_impl->file_name,
         NULL);
 
     if(!reader)
@@ -283,9 +283,9 @@
     }
     
     /** create axis2_om_stax_builder by parsing pull_parser struct */
-    builder_impl->builder = axis2_om_stax_builder_create (env, reader);
+    desc_builder_impl->builder = axis2_om_stax_builder_create (env, reader);
 
-    if(!(builder_impl->builder))
+    if(!(desc_builder_impl->builder))
     {
         AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_CREATING_XML_STREAM_READER,
             AXIS2_FAILURE)
@@ -295,7 +295,7 @@
         create an om document
         document is the container of om model created using builder
     */
-    document = axis2_om_document_create (env, NULL, builder_impl->builder);
+    document = axis2_om_document_create (env, NULL, desc_builder_impl->builder);
     /** 
      * In description building we don't want defferred building. So build
      * the whole tree at once
@@ -831,7 +831,7 @@
     {
         return NULL;
     }
-    impl_info_param = AXIS2_CONF_GET_PARAM(conf, env, AXIS2_MSG_RECV_PARAM);
+    impl_info_param = AXIS2_CONF_GET_PARAM(conf, env, class_name);
     
     if(!impl_info_param)
     {
@@ -847,10 +847,11 @@
         AXIS2_DLL_DESC_SET_NAME(dll_desc, env, 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, AXIS2_MSG_RECV_PARAM, NULL);
+        impl_info_param = axis2_param_create(env, class_name, NULL);
         AXIS2_PARAM_SET_VALUE(impl_info_param, env, dll_desc);
+        impl_info_param->ops->value_free = axis2_dll_desc_free_void_arg;
         /* set the impl_info_param(which contain dll_desc as value) so that
-         * loaded msg_recv can be re-used in future
+         * loaded msg_recv loader lib can be re-used in future
          */
         AXIS2_CONF_ADD_PARAM(conf, env, impl_info_param);
     }

Modified: webservices/axis2/trunk/c/modules/core/deployment/module_builder.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/deployment/module_builder.c?rev=380321&r1=380320&r2=380321&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/module_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/module_builder.c Thu Feb 23 19:32:06 2006
@@ -124,18 +124,18 @@
     
     module_builder_impl = AXIS2_INTF_TO_IMPL(module_builder);
     
+    if(module_builder->desc_builder)
+    {
+        AXIS2_DESC_BUILDER_FREE(module_builder->desc_builder, env);
+        module_builder->desc_builder = NULL;
+    }
+
 	if(NULL != module_builder->ops)
     {
         AXIS2_FREE((*env)->allocator, module_builder->ops);
         module_builder->ops = NULL;
     }
     
-    if(module_builder_impl->module_builder.desc_builder)
-    {
-        AXIS2_DESC_BUILDER_FREE(module_builder_impl->module_builder.desc_builder, env);
-        module_builder_impl->module_builder.desc_builder = NULL;
-    }
-
     if(module_builder_impl)
     {
         AXIS2_FREE((*env)->allocator, module_builder_impl);

Modified: webservices/axis2/trunk/c/modules/core/description/op.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/description/op.c?rev=380321&r1=380320&r2=380321&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/op.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/op.c Thu Feb 23 19:32:06 2006
@@ -659,8 +659,11 @@
     }
     
     op_impl->parent = NULL;
-    
-    op_impl->msg_recv = NULL;
+    if(op_impl->msg_recv)
+    {
+        AXIS2_MSG_RECV_FREE(op_impl->msg_recv, env);
+        op_impl->msg_recv = NULL;
+    }
 
     if(NULL != op_impl->remaining_phases_inflow && 
         (0 != AXIS2_STRCMP(op_name, "TemplateOperation")))

Modified: webservices/axis2/trunk/c/modules/core/engine/conf.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/engine/conf.c?rev=380321&r1=380320&r2=380321&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/conf.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/conf.c Thu Feb 23 19:32:06 2006
@@ -764,6 +764,22 @@
     
     if(config_impl->msg_recvs)
     {
+        axis2_hash_index_t *hi = NULL;
+        void *val = NULL;
+        for (hi = axis2_hash_first (config_impl->msg_recvs, env); hi;
+                 hi = axis2_hash_next ( env, hi))
+        {
+            axis2_msg_recv_t *msg_recv = NULL;
+            axis2_hash_this (hi, NULL, NULL, &val);
+            msg_recv = (axis2_msg_recv_t *) val;
+            if (msg_recv)
+            {
+                AXIS2_MSG_RECV_FREE(msg_recv, env);
+                msg_recv = NULL;
+            }
+            
+            val = NULL;
+        }
         axis2_hash_free(config_impl->msg_recvs, env);
         config_impl->msg_recvs = NULL;
     }

Modified: webservices/axis2/trunk/c/modules/core/phaseresolver/Makefile.am
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/phaseresolver/Makefile.am?rev=380321&r1=380320&r2=380321&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/phaseresolver/Makefile.am (original)
+++ webservices/axis2/trunk/c/modules/core/phaseresolver/Makefile.am Thu Feb 23 19:32:06 2006
@@ -1 +1,14 @@
 TESTS =
+noinst_LTLIBRARIES = libaxis2_phaseresolver.la
+
+libaxis2_phaseresolver_la_SOURCES = \
+                                phase_holder.c \
+                                phase_resolver.c
+
+INCLUDES = -I$(top_builddir)/include \
+            -I$(top_builddir)/modules/util \
+            -I$(top_builddir)/modules/wsdl \
+            -I$(top_builddir)/modules/core/engine \
+            -I$(top_builddir)/modules/core/transport \
+            -I$(top_builddir)/modules/xml/parser \
+            -I$(top_builddir)/modules/platforms

Modified: webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c?rev=380321&r1=380320&r2=380321&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c (original)
+++ webservices/axis2/trunk/c/modules/core/phaseresolver/phase_resolver.c Thu Feb 23 19:32:06 2006
@@ -1551,9 +1551,16 @@
             case AXIS2_INFLOW:
             {
                 phases = AXIS2_OP_GET_REMAINING_PHASES_INFLOW(axis_op, env);
-             
-                resolver_impl->phase_holder = 
-                    axis2_phase_holder_create_with_phases(env, phases);
+                if(phases)
+                {
+                    if(resolver_impl->phase_holder)
+                    {
+                        AXIS2_PHASE_HOLDER_FREE(resolver_impl->phase_holder, env);
+                        resolver_impl->phase_holder = NULL;
+                    }
+                    resolver_impl->phase_holder = 
+                        axis2_phase_holder_create_with_phases(env, phases);
+                }
                 break;
             }
             case AXIS2_OUTFLOW:
@@ -1561,6 +1568,11 @@
                 phases = AXIS2_OP_GET_PHASES_OUTFLOW(axis_op, env);
                 if(phases)
                 {
+                    if(resolver_impl->phase_holder)
+                    {
+                        AXIS2_PHASE_HOLDER_FREE(resolver_impl->phase_holder, env);
+                        resolver_impl->phase_holder = NULL;
+                    }
                     resolver_impl->phase_holder = 
                         axis2_phase_holder_create_with_phases(env, phases);
                 }
@@ -1569,15 +1581,31 @@
             case AXIS2_FAULT_INFLOW:
             {
                 phases = AXIS2_OP_GET_PHASES_IN_FAULT_FLOW(axis_op, env);
-                resolver_impl->phase_holder = 
-                    axis2_phase_holder_create_with_phases(env, phases);
+                if(phases)
+                {
+                    if(resolver_impl->phase_holder)
+                    {
+                        AXIS2_PHASE_HOLDER_FREE(resolver_impl->phase_holder, env);
+                        resolver_impl->phase_holder = NULL;
+                    }
+                    resolver_impl->phase_holder = 
+                        axis2_phase_holder_create_with_phases(env, phases);
+                }
                 break;
             }
             case AXIS2_FAULT_OUTFLOW:
             {
                 phases = AXIS2_OP_GET_PHASES_OUT_FAULT_FLOW(axis_op, env);
-                resolver_impl->phase_holder = 
-                    axis2_phase_holder_create_with_phases(env, phases);
+                if(phases)
+                {
+                    if(resolver_impl->phase_holder)
+                    {
+                        AXIS2_PHASE_HOLDER_FREE(resolver_impl->phase_holder, env);
+                        resolver_impl->phase_holder = NULL;
+                    }
+                    resolver_impl->phase_holder = 
+                        axis2_phase_holder_create_with_phases(env, phases);
+                }
                 break;
             }
         }

Modified: webservices/axis2/trunk/c/modules/core/receivers/msg_recv.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/receivers/msg_recv.c?rev=380321&r1=380320&r2=380321&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/receivers/msg_recv.c (original)
+++ webservices/axis2/trunk/c/modules/core/receivers/msg_recv.c Thu Feb 23 19:32:06 2006
@@ -322,6 +322,7 @@
     axis2_param_t *impl_info_param = NULL;
     axis2_param_t *scope_param = NULL;
     axis2_char_t *param_value = NULL;
+    axis2_dll_desc_t *dll_desc = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE);
@@ -352,7 +353,8 @@
             AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
-    return axis2_class_loader_delete_dll(env, impl_info_param);
+    dll_desc = AXIS2_PARAM_GET_VALUE(impl_info_param, env);
+    return axis2_class_loader_delete_dll(env, dll_desc);
 }
 
 axis2_status_t AXIS2_CALL

Modified: webservices/axis2/trunk/c/modules/core/receivers/raw_xml_in_out_msg_recv.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/receivers/raw_xml_in_out_msg_recv.c?rev=380321&r1=380320&r2=380321&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/receivers/raw_xml_in_out_msg_recv.c (original)
+++ webservices/axis2/trunk/c/modules/core/receivers/raw_xml_in_out_msg_recv.c Thu Feb 23 19:32:06 2006
@@ -192,6 +192,7 @@
         {
             skel_invoked = AXIS2_TRUE;
             result_node = AXIS2_SVC_SKELETON_INVOKE(svc_obj, env, om_node);
+            AXIS2_SVC_SKELETON_FREE(svc_obj, env);
         }
        
         if (result_node)
@@ -337,7 +338,7 @@
     return AXIS2_SUCCESS;
 }
 
-AXIS2_EXPORT int axis2_remove_instance(axis2_svc_skeleton_t *inst,
+AXIS2_EXPORT int axis2_remove_instance(struct axis2_msg_recv *inst,
                             axis2_env_t **env)
 {
     axis2_status_t status = AXIS2_FAILURE;



Mime
View raw message