1 files changed, 123 insertions, 123 deletions

diff --git a/pcilib/py.c b/pcilib/py.c
index 3e1f38d..699cd59 100644
--- a/pcilib/py.c
+++ b/pcilib/py.c
@@ -48,37 +48,37 @@ void pcilib_log_python_error(const char *file, int line, pcilib_log_flags_t flag
 
     gstate = PyGILState_Ensure();
     if (PyErr_Occurred()) {
-	PyErr_Fetch(&pytype, &pyval, &pytraceback);
-	type = PyString_AsString(pytype);
-	val = PyString_AsString(pyval);
+      PyErr_Fetch(&pytype, &pyval, &pytraceback);
+      type = PyString_AsString(pytype);
+      val = PyString_AsString(pyval);
     }
     PyGILState_Release(gstate);
 #endif /* HAVE_PYTHON */
     
     va_start(va, msg);
     if (type) {
-	char *str;
-	size_t len = 32;
-
-	if (msg) len += strlen(msg);
-	if (type) len += strlen(type);
-	if (val) len += strlen(val);
-	    
-	str = alloca(len * sizeof(char));
-	if (str) {
-	    if (msg&&val)
-		sprintf(str, "%s <%s: %s>", msg, type, val);
-	    else if (msg)
-		sprintf(str, "%s <%s>", msg, type);
-	    else if (val)
-		sprintf(str, "Python error %s: %s", type, val);
-	    else
-		sprintf(str, "Python error %s", type);
-	    
-	    pcilib_log_vmessage(file, line, flags, prio, str, va);
-	}
+      char *str;
+      size_t len = 32;
+
+      if (msg) len += strlen(msg);
+      if (type) len += strlen(type);
+      if (val) len += strlen(val);
+          
+      str = alloca(len * sizeof(char));
+      if (str) {
+          if (msg&&val)
+         sprintf(str, "%s <%s: %s>", msg, type, val);
+          else if (msg)
+         sprintf(str, "%s <%s>", msg, type);
+          else if (val)
+         sprintf(str, "Python error %s: %s", type, val);
+          else
+         sprintf(str, "Python error %s", type);
+          
+          pcilib_log_vmessage(file, line, flags, prio, str, va);
+      }
     } else  {
-	pcilib_log_vmessage(file, line, flags, prio, msg, va);
+	   pcilib_log_vmessage(file, line, flags, prio, msg, va);
     }
     va_end(va);
 
@@ -104,36 +104,36 @@ int pcilib_init_py(pcilib_t *ctx) {
     	    // Since python is being initializing from c programm, it needs to initialize threads to work properly with c threads
         PyEval_InitThreads();
         PyEval_ReleaseLock();
-	ctx->py->finalyze = 1;
+        ctx->py->finalyze = 1;
     }
 		
     ctx->py->main_module = PyImport_AddModule("__parser__");
     if (!ctx->py->main_module) {
-	pcilib_python_error("Error importing python parser");
-        return PCILIB_ERROR_FAILED;
+      pcilib_python_error("Error importing python parser");
+           return PCILIB_ERROR_FAILED;
     }
 
     ctx->py->global_dict = PyModule_GetDict(ctx->py->main_module);
     if (!ctx->py->global_dict) {
-	pcilib_python_error("Error locating global python dictionary");
-        return PCILIB_ERROR_FAILED;
+      pcilib_python_error("Error locating global python dictionary");
+           return PCILIB_ERROR_FAILED;
     }
 
-    PyObject *pywrap = PyImport_ImportModule("pcipywrap");
+    PyObject *pywrap = PyImport_ImportModule("pcilib");
     if (!pywrap) {
-	pcilib_python_error("Error importing pcilib python wrapper");
-	return PCILIB_ERROR_FAILED;
+      pcilib_python_error("Error importing pcilib python wrapper");
+      return PCILIB_ERROR_FAILED;
     }
 	
-    PyObject *mod_name = PyString_FromString("Pcipywrap");
+    PyObject *mod_name = PyString_FromString("Pcilib");
     PyObject *pyctx = PyCObject_FromVoidPtr(ctx, NULL);
     ctx->py->pcilib_pywrap = PyObject_CallMethodObjArgs(pywrap, mod_name, pyctx, NULL);
     Py_XDECREF(pyctx);
     Py_XDECREF(mod_name);
 	
     if (!ctx->py->pcilib_pywrap) {
-	pcilib_python_error("Error initializing python wrapper");
-        return PCILIB_ERROR_FAILED;
+      pcilib_python_error("Error initializing python wrapper");
+      return PCILIB_ERROR_FAILED;
     }
 #endif /* HAVE_PYTHON */
 
@@ -153,53 +153,53 @@ int pcilib_py_add_script_dir(pcilib_t *ctx, const char *dir) {
     if (!dir) dir = ctx->model;
 
     if (*dir == '/') {
-	script_dir = (char*)dir;
+	   script_dir = (char*)dir;
     } else {
-	script_dir = alloca(strlen(model_dir) + strlen(dir) + 2);
-	if (!script_dir) return PCILIB_ERROR_MEMORY;
-	sprintf(script_dir, "%s/%s", model_dir, dir);
+      script_dir = alloca(strlen(model_dir) + strlen(dir) + 2);
+      if (!script_dir) return PCILIB_ERROR_MEMORY;
+      sprintf(script_dir, "%s/%s", model_dir, dir);
     }
 
     pypath = PySys_GetObject("path");
     if (!pypath) {
-	pcilib_python_error("Can't get python path");
-	return PCILIB_ERROR_FAILED;
+      pcilib_python_error("Can't get python path");
+      return PCILIB_ERROR_FAILED;
     }
 
     pynewdir = PyString_FromString(script_dir);
     if (!pynewdir) {
-	pcilib_python_error("Can't create python string");
-	return PCILIB_ERROR_MEMORY;
+      pcilib_python_error("Can't create python string");
+      return PCILIB_ERROR_MEMORY;
     }
     
-	// Checking if the directory already in the path?
+	// Checking if the directory already in the path
     pydict = PyDict_New();
     if (pydict) {
-	pystr = PyString_FromString("cur");
+	   pystr = PyString_FromString("cur");
         if (pystr) {
-	    PyDict_SetItem(pydict, pystr, pynewdir);
-	    Py_DECREF(pystr);
-	}
-
-	pystr = PyString_FromString("path");
-	if (pystr) {
-	    PyDict_SetItem(pydict, pystr, pypath);
-	    Py_DECREF(pystr);
-	}
-
-	pyret = PyRun_String("cur in path", Py_eval_input, ctx->py->global_dict, pydict);
-	Py_DECREF(pydict);
+          PyDict_SetItem(pydict, pystr, pynewdir);
+          Py_DECREF(pystr);
+      }
+
+      pystr = PyString_FromString("path");
+      if (pystr) {
+          PyDict_SetItem(pydict, pystr, pypath);
+          Py_DECREF(pystr);
+      }
+
+      pyret = PyRun_String("cur in path", Py_eval_input, ctx->py->global_dict, pydict);
+      Py_DECREF(pydict);
     } 
 
     if ((pyret == Py_False)&&(PyList_Append(pypath, pynewdir) == -1))
-	err = PCILIB_ERROR_FAILED;
+	   err = PCILIB_ERROR_FAILED;
 
     if (pyret) Py_DECREF(pyret);
     Py_DECREF(pynewdir);
 
     if (err) {
-	pcilib_python_error("Can't add directory (%s) to python path", script_dir);
-	return err;
+      pcilib_python_error("Can't add directory (%s) to python path", script_dir);
+      return err;
     }
 #endif /* HAVE_PYTHON */
 
@@ -211,24 +211,24 @@ void pcilib_free_py(pcilib_t *ctx) {
     int finalyze = 0;
 	
     if (ctx->py) {		
-	if (ctx->py->finalyze) finalyze = 1;
-
-	if (ctx->py->script_hash) {
-	    pcilib_script_t *script, *script_tmp;
-
-	    HASH_ITER(hh, ctx->py->script_hash, script, script_tmp) {
-		Py_DECREF(script->module);
-		HASH_DEL(ctx->py->script_hash, script);
-		free(script);
-	    }
-	    ctx->py->script_hash = NULL;
-	}
-
-	if (ctx->py->pcilib_pywrap)
-	    Py_DECREF(ctx->py->pcilib_pywrap);
-	
-        free(ctx->py);
-        ctx->py = NULL;
+      if (ctx->py->finalyze) finalyze = 1;
+
+      if (ctx->py->script_hash) {
+          pcilib_script_t *script, *script_tmp;
+
+          HASH_ITER(hh, ctx->py->script_hash, script, script_tmp) {
+         Py_DECREF(script->module);
+         HASH_DEL(ctx->py->script_hash, script);
+         free(script);
+          }
+          ctx->py->script_hash = NULL;
+      }
+
+      if (ctx->py->pcilib_pywrap)
+          Py_DECREF(ctx->py->pcilib_pywrap);
+      
+           free(ctx->py);
+           ctx->py = NULL;
     }
     
     if (finalyze)
@@ -247,8 +247,8 @@ int pcilib_py_load_script(pcilib_t *ctx, const char *script_name) {
 
     char *py = strrchr(module_name, '.');
     if ((!py)||(strcasecmp(py, ".py"))) {
-	pcilib_error("Invalid script name (%s) is specified", script_name);
-	return PCILIB_ERROR_INVALID_ARGUMENT;
+      pcilib_error("Invalid script name (%s) is specified", script_name);
+      return PCILIB_ERROR_INVALID_ARGUMENT;
     }
     *py = 0;
 
@@ -257,8 +257,8 @@ int pcilib_py_load_script(pcilib_t *ctx, const char *script_name) {
 
     pymodule = PyImport_ImportModule(module_name);
     if (!pymodule) {
-	pcilib_python_error("Error importing script (%s)", script_name);
-	return PCILIB_ERROR_FAILED;
+      pcilib_python_error("Error importing script (%s)", script_name);
+      return PCILIB_ERROR_FAILED;
     }
 
     module = (pcilib_script_t*)malloc(sizeof(pcilib_script_t));
@@ -282,26 +282,26 @@ int pcilib_py_get_transform_script_properties(pcilib_t *ctx, const char *script_
     HASH_FIND_STR(ctx->py->script_hash, script_name, module);
 
     if(!module) {
-	pcilib_error("Script (%s) is not loaded yet", script_name);
-	return PCILIB_ERROR_NOTFOUND;
+      pcilib_error("Script (%s) is not loaded yet", script_name);
+      return PCILIB_ERROR_NOTFOUND;
     }
 	
     dict = PyModule_GetDict(module->module);
     if (!dict) {
-	pcilib_python_error("Error getting dictionary for script (%s)", script_name);
-	return PCILIB_ERROR_FAILED;
+      pcilib_python_error("Error getting dictionary for script (%s)", script_name);
+      return PCILIB_ERROR_FAILED;
     }
     
     pystr = PyString_FromString("read_from_register");
     if (pystr) {
-	if (PyDict_Contains(dict, pystr)) mode |= PCILIB_ACCESS_R;
-	Py_DECREF(pystr);
+      if (PyDict_Contains(dict, pystr)) mode |= PCILIB_ACCESS_R;
+      Py_DECREF(pystr);
     }
 
     pystr = PyString_FromString("write_to_register");
     if (pystr) {
-	if (PyDict_Contains(dict, pystr)) mode |= PCILIB_ACCESS_W;
-	Py_DECREF(pystr);
+      if (PyDict_Contains(dict, pystr)) mode |= PCILIB_ACCESS_W;
+      Py_DECREF(pystr);
     }
 #endif /* HAVE_PYTHON */
 
@@ -320,28 +320,28 @@ pcilib_py_object *pcilib_get_value_as_pyobject(pcilib_t* ctx, pcilib_value_t *va
 	
     gstate = PyGILState_Ensure();
     switch(val->type) {
-     case PCILIB_TYPE_LONG:
-	ival = pcilib_get_value_as_int(ctx, val, &err);
-	if (!err) res = (PyObject*)PyInt_FromLong(ival);
-	break;
-     case PCILIB_TYPE_DOUBLE:
-	fval = pcilib_get_value_as_float(ctx, val, &err);
-	if (!err) res = (PyObject*)PyFloat_FromDouble(fval);
-	break;	
-     default:
-	PyGILState_Release(gstate);
-	pcilib_error("Can't convert pcilib value of type (%lu) to PyObject", val->type);
-	if (ret) *ret = PCILIB_ERROR_NOTSUPPORTED;
-	return NULL;
+        case PCILIB_TYPE_LONG:
+      ival = pcilib_get_value_as_int(ctx, val, &err);
+      if (!err) res = (PyObject*)PyInt_FromLong(ival);
+      break;
+        case PCILIB_TYPE_DOUBLE:
+      fval = pcilib_get_value_as_float(ctx, val, &err);
+      if (!err) res = (PyObject*)PyFloat_FromDouble(fval);
+      break;	
+        default:
+      PyGILState_Release(gstate);
+      pcilib_error("Can't convert pcilib value of type (%lu) to PyObject", val->type);
+      if (ret) *ret = PCILIB_ERROR_NOTSUPPORTED;
+      return NULL;
     }
     PyGILState_Release(gstate);
 
     if (err) {
-	if (ret) *ret = err;
-	return NULL;
+      if (ret) *ret = err;
+      return NULL;
     } else if (!res) {
-	if (ret) *ret = PCILIB_ERROR_MEMORY;
-	return res;
+      if (ret) *ret = PCILIB_ERROR_MEMORY;
+      return res;
     } 
 
     if (ret) *ret = 0;
@@ -425,7 +425,7 @@ static char *pcilib_py_parse_string(pcilib_t *ctx, const char *codestr, pcilib_v
         strcpy(dst + offset, cur);
         offset += reg - cur;
 
-            // find the end of the register name
+        // find the end of the register name
         reg++;
         if (*reg == '{') {
             reg++;
@@ -441,7 +441,7 @@ static char *pcilib_py_parse_string(pcilib_t *ctx, const char *codestr, pcilib_v
         save = reg[i];
         reg[i] = 0;
 
-            // determine replacement value
+        // determine replacement value
         if (!strcasecmp(reg, "value")) {
             if (!value) {
                 pcilib_error("Python formula (%s) relies on the value of register, but it is not provided", codestr);
@@ -469,7 +469,7 @@ static char *pcilib_py_parse_string(pcilib_t *ctx, const char *codestr, pcilib_v
         if (save == '}') i++;
         else reg[i] = save;
 
-            // Advance to the next register if any
+        // Advance to the next register if any
         cur = reg + i;
         reg = strchr(cur, '$');
     }
@@ -479,8 +479,8 @@ static char *pcilib_py_parse_string(pcilib_t *ctx, const char *codestr, pcilib_v
     free(src);
 
     if (err) {
-        free(dst);
-        return NULL;
+     free(dst);
+     return NULL;
     }
 
     return dst;
@@ -534,22 +534,22 @@ int pcilib_py_eval_func(pcilib_t *ctx, const char *script_name, const char *func
     HASH_FIND_STR(ctx->py->script_hash, script_name, module);
 
     if (!module) {
-	pcilib_error("Script (%s) is not loaded", script_name);
-	return PCILIB_ERROR_NOTFOUND;
+      pcilib_error("Script (%s) is not loaded", script_name);
+      return PCILIB_ERROR_NOTFOUND;
     }
 
     if (val) {
-	pyval = pcilib_get_value_as_pyobject(ctx, val, &err);
-	if (err) return err;
+      pyval = pcilib_get_value_as_pyobject(ctx, val, &err);
+      if (err) return err;
     }
 
     PyGILState_STATE gstate = PyGILState_Ensure();
 
     pyfunc = PyUnicode_FromString(func_name);
     if (!pyfunc) {
-	if (pyval) Py_DECREF(pyval);
-	PyGILState_Release(gstate);
-	return PCILIB_ERROR_MEMORY;
+      if (pyval) Py_DECREF(pyval);
+      PyGILState_Release(gstate);
+      return PCILIB_ERROR_MEMORY;
     }
 
     pyret = PyObject_CallMethodObjArgs(module->module, pyfunc, ctx->py->pcilib_pywrap, pyval, NULL);
@@ -558,13 +558,13 @@ int pcilib_py_eval_func(pcilib_t *ctx, const char *script_name, const char *func
     Py_DECREF(pyval);
 	
     if (!pyret) {
-	PyGILState_Release(gstate);
-	pcilib_python_error("Error executing function (%s) of python script (%s)", func_name, script_name);
-	return PCILIB_ERROR_FAILED;
+      PyGILState_Release(gstate);
+      pcilib_python_error("Error executing function (%s) of python script (%s)", func_name, script_name);
+      return PCILIB_ERROR_FAILED;
     }
 
     if ((val)&&(pyret != Py_None))
-	err = pcilib_set_value_from_pyobject(ctx, val, pyret);
+	   err = pcilib_set_value_from_pyobject(ctx, val, pyret);
 
     Py_DECREF(pyret);
     PyGILState_Release(gstate);