Code cleanup: PIL_dynlib, renamed to BLI_dynlib, and other tweaks.
authorBrecht Van Lommel <brechtvanlommel@pandora.be>
Fri, 6 May 2011 15:17:42 +0000 (15:17 +0000)
committerBrecht Van Lommel <brechtvanlommel@pandora.be>
Fri, 6 May 2011 15:17:42 +0000 (15:17 +0000)
source/blender/blenkernel/intern/seqeffects.c
source/blender/blenkernel/intern/texture.c
source/blender/blenlib/BLI_dynlib.h [moved from source/blender/blenlib/PIL_dynlib.h with 72% similarity]
source/blender/blenlib/CMakeLists.txt
source/blender/blenlib/intern/dynlib.c

index aa91cff..6f49155 100644 (file)
@@ -37,7 +37,7 @@
 #include <stdlib.h>
 
 #include "MEM_guardedalloc.h"
-#include "PIL_dynlib.h"
+#include "BLI_dynlib.h"
 
 #include "BLI_math.h" /* windows needs for M_PI */
 #include "BLI_utildefines.h"
@@ -138,18 +138,18 @@ static void open_plugin_seq(PluginSeq *pis, const char *seqname)
        pis->instance_private_data = NULL;
 
        /* clear the error list */
-       PIL_dynlib_get_error_as_string(NULL);
+       BLI_dynlib_get_error_as_string(NULL);
 
-       /* if(pis->handle) PIL_dynlib_close(pis->handle); */
+       /* if(pis->handle) BLI_dynlib_close(pis->handle); */
        /* pis->handle= 0; */
 
        /* open the needed object */
-       pis->handle= PIL_dynlib_open(pis->name);
+       pis->handle= BLI_dynlib_open(pis->name);
        if(test_dlerr(pis->name, pis->name)) return;
 
        if (pis->handle != NULL) {
                /* find the address of the version function */
-               version= (int (*)(void))PIL_dynlib_find_symbol(pis->handle, "plugin_seq_getversion");
+               version= (int (*)(void))BLI_dynlib_find_symbol(pis->handle, "plugin_seq_getversion");
                if (test_dlerr(pis->name, "plugin_seq_getversion")) return;
 
                if (version != NULL) {
@@ -158,7 +158,7 @@ static void open_plugin_seq(PluginSeq *pis, const char *seqname)
                                int (*info_func)(PluginInfo *);
                                PluginInfo *info= (PluginInfo*) MEM_mallocN(sizeof(PluginInfo), "plugin_info");
 
-                               info_func= (int (*)(PluginInfo *))PIL_dynlib_find_symbol(pis->handle, "plugin_getinfo");
+                               info_func= (int (*)(PluginInfo *))BLI_dynlib_find_symbol(pis->handle, "plugin_getinfo");
 
                                if(info_func == NULL) error("No info func");
                                else {
@@ -176,21 +176,21 @@ static void open_plugin_seq(PluginSeq *pis, const char *seqname)
                                }
                                MEM_freeN(info);
 
-                               cp= PIL_dynlib_find_symbol(pis->handle, "seqname");
+                               cp= BLI_dynlib_find_symbol(pis->handle, "seqname");
                                if(cp) strncpy(cp, seqname, 21);
                        } else {
                                printf ("Plugin returned unrecognized version number\n");
                                return;
                        }
                }
-               alloc_private = (void* (*)(void))PIL_dynlib_find_symbol(
+               alloc_private = (void* (*)(void))BLI_dynlib_find_symbol(
                        pis->handle, "plugin_seq_alloc_private_data");
                if (alloc_private) {
                        pis->instance_private_data = alloc_private();
                }
                
                pis->current_private_data = (void**) 
-                       PIL_dynlib_find_symbol(
+                       BLI_dynlib_find_symbol(
                                pis->handle, "plugin_private_data");
        }
 }
@@ -229,12 +229,12 @@ static void free_plugin_seq(PluginSeq *pis)
 {
        if(pis==NULL) return;
 
-       /* no PIL_dynlib_close: same plugin can be opened multiple times with 1 handle */
+       /* no BLI_dynlib_close: same plugin can be opened multiple times with 1 handle */
 
        if (pis->instance_private_data) {
                void (*free_private)(void *);
 
-               free_private = (void (*)(void *))PIL_dynlib_find_symbol(
+               free_private = (void (*)(void *))BLI_dynlib_find_symbol(
                        pis->handle, "plugin_seq_free_private_data");
                if (free_private) {
                        free_private(pis->instance_private_data);
@@ -301,7 +301,7 @@ static struct ImBuf * do_plugin_effect(
                if(seq->plugin->cfra) 
                        *(seq->plugin->cfra)= cfra;
                
-               cp = PIL_dynlib_find_symbol(
+               cp = BLI_dynlib_find_symbol(
                        seq->plugin->handle, "seqname");
 
                if(cp) strncpy(cp, seq->name+2, 22);
index 866874e..9cd07de 100644 (file)
@@ -41,9 +41,8 @@
 
 #include "MEM_guardedalloc.h"
 
-#include "PIL_dynlib.h"
-
 #include "BLI_blenlib.h"
+#include "BLI_dynlib.h"
 #include "BLI_math.h"
 #include "BLI_kdopbvh.h"
 #include "BLI_utildefines.h"
@@ -82,7 +81,7 @@ int test_dlerr(const char *name, const char *symbol)
 {
        char *err;
        
-       err= PIL_dynlib_get_error_as_string(NULL);
+       err= BLI_dynlib_get_error_as_string(NULL);
        if(err) {
                printf("var1: %s, var2: %s, var3: %s\n", name, symbol, err);
                return 1;
@@ -108,19 +107,19 @@ void open_plugin_tex(PluginTex *pit)
        pit->instance_init= NULL;
        
        /* clear the error list */
-       PIL_dynlib_get_error_as_string(NULL);
+       BLI_dynlib_get_error_as_string(NULL);
 
-       /* no PIL_dynlib_close! multiple opened plugins... */
-       /* if(pit->handle) PIL_dynlib_close(pit->handle); */
+       /* no BLI_dynlib_close! multiple opened plugins... */
+       /* if(pit->handle) BLI_dynlib_close(pit->handle); */
        /* pit->handle= 0; */
 
        /* open the needed object */
-       pit->handle= PIL_dynlib_open(pit->name);
+       pit->handle= BLI_dynlib_open(pit->name);
        if(test_dlerr(pit->name, pit->name)) return;
 
        if (pit->handle != NULL) {
                /* find the address of the version function */
-               version= (int (*)(void)) PIL_dynlib_find_symbol(pit->handle, "plugin_tex_getversion");
+               version= (int (*)(void)) BLI_dynlib_find_symbol(pit->handle, "plugin_tex_getversion");
                if (test_dlerr(pit->name, "plugin_tex_getversion")) return;
                
                if (version != NULL) {
@@ -129,7 +128,7 @@ void open_plugin_tex(PluginTex *pit)
                                int (*info_func)(PluginInfo *);
                                PluginInfo *info= (PluginInfo*) MEM_mallocN(sizeof(PluginInfo), "plugin_info"); 
 
-                               info_func= (int (*)(PluginInfo *))PIL_dynlib_find_symbol(pit->handle, "plugin_getinfo");
+                               info_func= (int (*)(PluginInfo *))BLI_dynlib_find_symbol(pit->handle, "plugin_getinfo");
                                if (!test_dlerr(pit->name, "plugin_getinfo")) {
                                        info->instance_init = NULL;
 
@@ -200,7 +199,7 @@ void free_plugin_tex(PluginTex *pit)
 {
        if(pit==NULL) return;
                
-       /* no PIL_dynlib_close: same plugin can be opened multiple times, 1 handle */
+       /* no BLI_dynlib_close: same plugin can be opened multiple times, 1 handle */
        MEM_freeN(pit); 
 }
 
similarity index 72%
rename from source/blender/blenlib/PIL_dynlib.h
rename to source/blender/blenlib/BLI_dynlib.h
index 5569954..f269bed 100644 (file)
  * ***** END GPL LICENSE BLOCK *****
  */
 
-/** \file blender/blenlib/PIL_dynlib.h
+/** \file blender/blenlib/BLI_dynlib.h
  *  \ingroup bli
  */
 
-#ifndef __PIL_DYNLIB_H__
-#define __PIL_DYNLIB_H__
+#ifndef __BLI_DYNLIB_H__
+#define __BLI_DYNLIB_H__
 
-typedef struct PILdynlib PILdynlib;
+typedef struct DynamicLibrary DynamicLibrary;
 
-       PILdynlib*
-PIL_dynlib_open(
-       char *name);
+DynamicLibrary *BLI_dynlib_open(char *name);
+void *BLI_dynlib_find_symbol(DynamicLibrary* lib, const char *symname);
+char *BLI_dynlib_get_error_as_string(DynamicLibrary* lib);
+void BLI_dynlib_close(DynamicLibrary* lib);
 
-       void*
-PIL_dynlib_find_symbol(
-       PILdynlib* lib, 
-       const char *symname);
-
-       char*
-PIL_dynlib_get_error_as_string(
-       PILdynlib* lib);
-       
-       void
-PIL_dynlib_close(
-       PILdynlib* lib);
-
-#endif /* __PIL_DYNLIB_H__ */
+#endif /* __BLI_DYNLIB_H__ */
 
index d5ed895..b7827d6 100644 (file)
@@ -88,6 +88,7 @@ set(SRC
        BLI_bpath.h
        BLI_cpu.h
        BLI_dlrbTree.h
+       BLI_dynlib.h
        BLI_dynstr.h
        BLI_edgehash.h
        BLI_editVert.h
@@ -127,7 +128,6 @@ set(SRC
        BLI_vfontdata.h
        BLI_voxel.h
        BLI_winstuff.h
-       PIL_dynlib.h
        PIL_time.h
        intern/BLI_callbacks.h
        intern/dynamiclist.h
index 855fa2d..ae6589b 100644 (file)
  *  \ingroup bli
  */
 
-
+#include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
-#include "../PIL_dynlib.h"
+#include "MEM_guardedalloc.h"
 
-#if !defined(CHAR_MAX)
-#define CHAR_MAX 255
-#endif
+#include "BLI_dynlib.h"
+
+struct DynamicLibrary {
+       void *handle;
+};
 
-/*
- * XXX, should use mallocN so we can see
- * handle's not being released. fixme zr
- */
 #ifdef WIN32
-#include <string.h>
-#include <stdio.h>
 
 #include <windows.h>
 
-struct PILdynlib {
-       void *handle;
-};
-
-PILdynlib *PIL_dynlib_open(char *name) {
+DynamicLibrary *BLI_dynlib_open(char *name)
+{
+       DynamicLibrary *lib;
        void *handle= LoadLibrary(name);
 
-       if (handle) {   
-               PILdynlib *lib= malloc(sizeof(*lib));
-               lib->handle= handle;
-               
-               return lib;
-       } else {
+       if(!handle)
                return NULL;
-       }
+
+       lib= MEM_callocN(sizeof(*lib), "Dynamic Library");
+       lib->handle= handle;
+               
+       return lib;
 }
 
-void *PIL_dynlib_find_symbol(PILdynlib* lib, const char *symname) {
+void *BLI_dynlib_find_symbol(DynamicLibrary *lib, const char *symname)
+{
        return GetProcAddress(lib->handle, symname);
 }
 
-char *PIL_dynlib_get_error_as_string(PILdynlib* lib) {
+char *BLI_dynlib_get_error_as_string(DynamicLibrary *lib)
+{
        int err;
 
        /* if lib is NULL reset the last error code */
        err= GetLastError();
-       if (!lib) SetLastError(ERROR_SUCCESS);
+       if(!lib)
+               SetLastError(ERROR_SUCCESS);
 
-       if (err) {
+       if(err) {
                static char buf[1024];
 
-               if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, 
-                                       NULL, 
-                                       err, 
-                                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), 
-                                       buf, 
-                                       sizeof(buf), 
-                                       NULL))
+               if(FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, 
+                       NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                       buf, sizeof(buf), NULL))
                        return buf;
        }
        
        return NULL;
 }
 
-void PIL_dynlib_close(PILdynlib *lib) {
+void BLI_dynlib_close(DynamicLibrary *lib)
+{
        FreeLibrary(lib->handle);
-       
-       free(lib);
+       MEM_freeN(lib);
 }
 
-#else  /* Unix */
+#else /* Unix */
 
 #include <dlfcn.h>
 
-struct PILdynlib {
-       void *handle;
-};
-
-PILdynlib *PIL_dynlib_open(char *name) {
+DynamicLibrary *BLI_dynlib_open(char *name)
+{
+       DynamicLibrary *lib;
        void *handle= dlopen(name, RTLD_LAZY);
 
-       if (handle) {   
-               PILdynlib *lib= malloc(sizeof(*lib));
-               lib->handle= handle;
-               
-               return lib;
-       } else {
+       if(!handle)
                return NULL;
-       }
+
+       lib= MEM_callocN(sizeof(*lib), "Dynamic Library");
+       lib->handle= handle;
+               
+       return lib;
 }
 
-void *PIL_dynlib_find_symbol(PILdynlib* lib, const char *symname) {
+void *BLI_dynlib_find_symbol(DynamicLibrary *lib, const char *symname)
+{
        return dlsym(lib->handle, symname);
 }
 
-char *PIL_dynlib_get_error_as_string(PILdynlib* lib) {
+char *BLI_dynlib_get_error_as_string(DynamicLibrary *lib)
+{
        (void)lib; /* unused */
        return dlerror();
 }
        
-void PIL_dynlib_close(PILdynlib *lib) {
+void BLI_dynlib_close(DynamicLibrary *lib)
+{
        dlclose(lib->handle);
-       
-       free(lib);
+       MEM_freeN(lib);
 }
 
 #endif