scilab: coding style: remove "_" from parameter names

12 files changed, 82 insertions, 82 deletions

diff --git a/Lib/scilab/scibool.swg b/Lib/scilab/scibool.swg
index 26dc00d31..3dc16f55a 100644
--- a/Lib/scilab/scibool.swg
+++ b/Lib/scilab/scibool.swg
@@ -53,7 +53,7 @@ SWIG_From_dec(bool)(bool _bValue) {
  */
 %fragment("SWIG_SciBoolean_AsBoolArrayAndSize", "header") {
 SWIGINTERN int
-SWIG_SciBoolean_AsBoolArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, bool **pbValue, char *_fname) {
+SWIG_SciBoolean_AsBoolArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, bool **pbValue, char *fname) {
   SciErr sciErr;
   int *piAddrVar = NULL;
   int *piValue = NULL;
@@ -77,7 +77,7 @@ SWIG_SciBoolean_AsBoolArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *i
       (*pbValue)[i] = piValue[i] != 0;
   }
   else {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A boolean matrix expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A boolean matrix expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
 
@@ -114,7 +114,7 @@ SWIG_SciBoolean_FromBoolArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, in
  */
 %fragment("SWIG_SciBoolean_AsIntArrayAndSize", "header") {
 SWIGINTERN int
-SWIG_SciBoolean_AsIntArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, int **piValue, char *_fname) {
+SWIG_SciBoolean_AsIntArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, int **piValue, char *fname) {
   SciErr sciErr;
   int *piAddrVar = NULL;
 
@@ -133,7 +133,7 @@ SWIG_SciBoolean_AsIntArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iC
     }
   }
   else {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A boolean matrix expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A boolean matrix expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
 
diff --git a/Lib/scilab/scidouble.swg b/Lib/scilab/scidouble.swg
index 4125fa3f7..cacd67d48 100644
--- a/Lib/scilab/scidouble.swg
+++ b/Lib/scilab/scidouble.swg
@@ -6,7 +6,7 @@
 }
 %fragment("SWIG_SciDouble_AsDouble", "header") {
 SWIGINTERN int
-SWIG_SciDouble_AsDouble(void *_pvApiCtx, SwigSciObject iVar, double *pdblValue, char *_fname) {
+SWIG_SciDouble_AsDouble(void *_pvApiCtx, SwigSciObject iVar, double *pdblValue, char *fname) {
   SciErr sciErr;
   int iRet = 0;
   int *piAddrVar = NULL;
@@ -18,12 +18,12 @@ SWIG_SciDouble_AsDouble(void *_pvApiCtx, SwigSciObject iVar, double *pdblValue,
   }
 
   if (!isDoubleType(_pvApiCtx, piAddrVar) || isVarComplex(_pvApiCtx, piAddrVar)) {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
 
   if (!isScalar(_pvApiCtx, piAddrVar)) {
-    Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
 
@@ -41,7 +41,7 @@ SWIG_SciDouble_AsDouble(void *_pvApiCtx, SwigSciObject iVar, double *pdblValue,
 }
 %fragment("SWIG_SciDouble_FromDouble", "header") {
 SWIGINTERN int
-SWIG_SciDouble_FromDouble(void *_pvApiCtx, int iVarOut, double dblValue, char *_fname) {
+SWIG_SciDouble_FromDouble(void *_pvApiCtx, int iVarOut, double dblValue, char *fname) {
   if (createScalarDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, dblValue))
     return SWIG_ERROR;
   return SWIG_OK;
@@ -54,7 +54,7 @@ SWIG_SciDouble_FromDouble(void *_pvApiCtx, int iVarOut, double dblValue, char *_
 
 %fragment("SWIG_SciDouble_AsDoubleArrayAndSize", "header") {
 SWIGINTERN int
-SWIG_SciDouble_AsDoubleArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, double **pdValue, char *_fname) {
+SWIG_SciDouble_AsDoubleArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, double **pdValue, char *fname) {
   SciErr sciErr;
   int *piAddrVar = NULL;
 
@@ -72,7 +72,7 @@ SWIG_SciDouble_AsDoubleArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *
     }
   }
   else {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
 
diff --git a/Lib/scilab/scienum.swg b/Lib/scilab/scienum.swg
index af14cd6dc..6c9caf66b 100644
--- a/Lib/scilab/scienum.swg
+++ b/Lib/scilab/scienum.swg
@@ -8,7 +8,7 @@
 }
 %fragment("SWIG_Int_AsEnum", "header", fragment="SWIG_SciDoubleOrInt32_AsInt") {
 SWIGINTERN int
-SWIG_Int_AsEnum(void *_pvApiCtx, int iVar, int *enumValue, char *_fname) {
+SWIG_Int_AsEnum(void *_pvApiCtx, int iVar, int *enumValue, char *fname) {
   int iValue = 0;
   if (SWIG_SciDoubleOrInt32_AsInt(_pvApiCtx, iVar, &iValue, fname) != SWIG_OK)
     return SWIG_ERROR;
@@ -22,7 +22,7 @@ SWIG_Int_AsEnum(void *_pvApiCtx, int iVar, int *enumValue, char *_fname) {
 }
 %fragment("SWIG_Int_FromEnum", "header", fragment="SWIG_SciDouble_FromInt") {
 SWIGINTERN int
-SWIG_Int_FromEnum(void *_pvApiCtx, int iVarOut, int enumValue, char *_fname) {
+SWIG_Int_FromEnum(void *_pvApiCtx, int iVarOut, int enumValue, char *fname) {
   if (SWIG_SciDouble_FromInt(_pvApiCtx, iVarOut, enumValue, fname) != SWIG_OK)
     return SWIG_ERROR;
   SWIG_Scilab_SetOutput(_pvApiCtx, iVarOut);
diff --git a/Lib/scilab/scifloat.swg b/Lib/scilab/scifloat.swg
index 629c49b72..dd7fc624c 100644
--- a/Lib/scilab/scifloat.swg
+++ b/Lib/scilab/scifloat.swg
@@ -27,7 +27,7 @@ SWIG_From_dec(float)(float _flValue) {
 
 %fragment("SWIG_SciDouble_AsFloatArrayAndSize", "header") {
 SWIGINTERN int
-SWIG_SciDouble_AsFloatArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, float **pfValue, char *_fname) {
+SWIG_SciDouble_AsFloatArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, float **pfValue, char *fname) {
   SciErr sciErr;
   int *piAddrVar = NULL;
   double *pdValue = NULL;
@@ -54,7 +54,7 @@ SWIG_SciDouble_AsFloatArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *i
     return SWIG_OK;
   }
   else {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
 }
diff --git a/Lib/scilab/sciint.swg b/Lib/scilab/sciint.swg
index cfe7b7fd3..e5385dd70 100644
--- a/Lib/scilab/sciint.swg
+++ b/Lib/scilab/sciint.swg
@@ -8,7 +8,7 @@
 }
 %fragment("SWIG_SciDoubleOrInt32_AsInt", "header") {
 SWIGINTERN int
-SWIG_SciDoubleOrInt32_AsInt(void *_pvApiCtx, SwigSciObject iVar, int *piValue, char *_fname)
+SWIG_SciDoubleOrInt32_AsInt(void *_pvApiCtx, SwigSciObject iVar, int *piValue, char *fname)
 {
   SciErr sciErr;
   int iType = 0;
@@ -39,7 +39,7 @@ SWIG_SciDoubleOrInt32_AsInt(void *_pvApiCtx, SwigSciObject iVar, int *piValue, c
         return SWIG_ERROR;
       }
       if (iPrec != SCI_INT32) {
-        Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double expected.\n"), _fname, iVar);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
         return SWIG_TypeError;
       }
       sciErr = getMatrixOfInteger32(_pvApiCtx, piAddrVar, &iRows, &iCols, &piData);
@@ -48,7 +48,7 @@ SWIG_SciDoubleOrInt32_AsInt(void *_pvApiCtx, SwigSciObject iVar, int *piValue, c
         return SWIG_ERROR;
       }
       if (iRows * iCols != 1) {
-        Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit signed integer or a double expected.\n"), _fname, iVar);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
         return SWIG_TypeError;
       }
       *piValue = *piData;
@@ -64,23 +64,23 @@ SWIG_SciDoubleOrInt32_AsInt(void *_pvApiCtx, SwigSciObject iVar, int *piValue, c
         return SWIG_ERROR;
       }
       if (iRows * iCols != 1) {
-        Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit signed integer or a double expected.\n"), _fname, iVar);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
         return SWIG_TypeError;
       }
       dValue = *pdData;
       if (dValue != floor(dValue)) {
-        Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 32-bit signed integer.\n"), _fname, iVar);
+        Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 32-bit signed integer.\n"), fname, iVar);
         return SWIG_ValueError;
       }
       if ((dValue < INT_MIN) || (dValue > INT_MAX)) {
-        Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 32-bit signed integer.\n"), _fname, iVar);
+        Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 32-bit signed integer.\n"), fname, iVar);
         return SWIG_OverflowError;
       }
       *piValue = (int) dValue;
     }
   }
   else {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
     return SWIG_TypeError;
   }
 
@@ -93,7 +93,7 @@ SWIG_SciDoubleOrInt32_AsInt(void *_pvApiCtx, SwigSciObject iVar, int *piValue, c
 }
 %fragment("SWIG_SciDouble_FromInt", "header") {
 SWIGINTERN int
-SWIG_SciDouble_FromInt(void *_pvApiCtx, int iVarOut, int iValue, char *_fname){
+SWIG_SciDouble_FromInt(void *_pvApiCtx, int iVarOut, int iValue, char *fname){
   if (createScalarDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx)
     + iVarOut, (double) iValue))
     return SWIG_ERROR;
@@ -107,7 +107,7 @@ SWIG_SciDouble_FromInt(void *_pvApiCtx, int iVarOut, int iValue, char *_fname){
  */
 %fragment("SWIG_SciDoubleOrInt32_AsIntArrayAndSize", "header") {
 SWIGINTERN int
-SWIG_SciDoubleOrInt32_AsIntArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, int **piValue, char *_fname) {
+SWIG_SciDoubleOrInt32_AsIntArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, int **piValue, char *fname) {
   SciErr sciErr;
   int iType = 0;
   int *piAddrVar = NULL;
@@ -154,7 +154,7 @@ SWIG_SciDoubleOrInt32_AsIntArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, i
     }
     if (iPrec != SCI_INT32)
     {
-      Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double matrix expected.\n"), _fname, iVar);
+      Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double matrix expected.\n"), fname, iVar);
       return SWIG_ERROR;
     }
     sciErr = getMatrixOfInteger32(_pvApiCtx, piAddrVar, iRows, iCols, piValue);
@@ -166,7 +166,7 @@ SWIG_SciDoubleOrInt32_AsIntArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, i
   }
   else
   {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double matrix expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double matrix expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
   return SWIG_OK;
diff --git a/Lib/scilab/scilong.swg b/Lib/scilab/scilong.swg
index daa3902f4..0cdcdf66a 100644
--- a/Lib/scilab/scilong.swg
+++ b/Lib/scilab/scilong.swg
@@ -8,7 +8,7 @@
 }
 %fragment("SWIG_SciDoubleOrInt32_AsLong", "header") {
 SWIGINTERN int
-SWIG_SciDoubleOrInt32_AsLong(void *_pvApiCtx, SwigSciObject iVar, long *plValue, char *_fname) {
+SWIG_SciDoubleOrInt32_AsLong(void *_pvApiCtx, SwigSciObject iVar, long *plValue, char *fname) {
   SciErr sciErr;
   int iType = 0;
   int iRows = 0;
@@ -37,7 +37,7 @@ SWIG_SciDoubleOrInt32_AsLong(void *_pvApiCtx, SwigSciObject iVar, long *plValue,
       return SWIG_ERROR;
     }
     if (iPrec != SCI_INT32) {
-      Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double expected.\n"), _fname, iVar);
+      Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
       return SWIG_TypeError;
     }
     sciErr = getMatrixOfInteger32(_pvApiCtx, piAddrVar, &iRows, &iCols, &piData);
@@ -46,7 +46,7 @@ SWIG_SciDoubleOrInt32_AsLong(void *_pvApiCtx, SwigSciObject iVar, long *plValue,
       return SWIG_ERROR;
     }
     if (iRows * iCols != 1) {
-      Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit signed integer or a double expected.\n"), _fname, iVar);
+      Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
       return SWIG_TypeError;
     }
     *plValue = (long) *piData;
@@ -61,22 +61,22 @@ SWIG_SciDoubleOrInt32_AsLong(void *_pvApiCtx, SwigSciObject iVar, long *plValue,
       return SWIG_ERROR;
     }
     if (iRows * iCols != 1) {
-      Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit signed integer or a double expected.\n"), _fname, iVar);
+      Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
       return SWIG_TypeError;
     }
     dValue = *pdData;
     if (dValue != floor(dValue)) {
-      Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 32-bit signed integer.\n"), _fname, iVar);
+      Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 32-bit signed integer.\n"), fname, iVar);
       return SWIG_ValueError;
     }
     if ((dValue < LONG_MIN) || (dValue > LONG_MAX)) {
-      Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 32-bit signed integer.\n"), _fname, iVar);
+      Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 32-bit signed integer.\n"), fname, iVar);
       return SWIG_OverflowError;
     }
     *plValue = (long) dValue;
   }
   else {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
     return SWIG_TypeError;
   }
 
@@ -89,7 +89,7 @@ SWIG_SciDoubleOrInt32_AsLong(void *_pvApiCtx, SwigSciObject iVar, long *plValue,
 }
 %fragment("SWIG_SciDouble_FromLong", "header") {
 SWIGINTERN int
-SWIG_SciDouble_FromLong(void *_pvApiCtx, int iVarOut, long lValue, char *_fname) {
+SWIG_SciDouble_FromLong(void *_pvApiCtx, int iVarOut, long lValue, char *fname) {
   if (createScalarDouble(_pvApiCtx,
     SWIG_NbInputArgument(_pvApiCtx) + iVarOut, (double) lValue))
     return SWIG_ERROR;
diff --git a/Lib/scilab/scimisctypes.swg b/Lib/scilab/scimisctypes.swg
index 06a4099a4..52680da44 100644
--- a/Lib/scilab/scimisctypes.swg
+++ b/Lib/scilab/scimisctypes.swg
@@ -11,7 +11,7 @@
 %fragment("SWIG_Int_AsSize", "header", fragment=SWIG_AsVal_frag(int))
 {
 SWIGINTERN int
-SWIG_Int_AsSize(void *_pvApiCtx, SwigSciObject iVar, size_t *piValue, char *_fname) {
+SWIG_Int_AsSize(void *_pvApiCtx, SwigSciObject iVar, size_t *piValue, char *fname) {
   int iValue = 0;
   if (SWIG_AsVal_dec(int)(iVar, &iValue) != SWIG_OK)
     return SWIG_ERROR;
@@ -29,7 +29,7 @@ SWIG_Int_AsSize(void *_pvApiCtx, SwigSciObject iVar, size_t *piValue, char *_fna
 %fragment("SWIG_Int_FromSize", "header", fragment=SWIG_From_frag(int))
 {
 SWIGINTERN int
-SWIG_Int_FromSize(void *_pvApiCtx, int iVarOut, size_t iValue, char *_fname) {
+SWIG_Int_FromSize(void *_pvApiCtx, int iVarOut, size_t iValue, char *fname) {
   return SWIG_From_dec(int)((int)iValue);
 }
 }
@@ -45,7 +45,7 @@ SWIG_Int_FromSize(void *_pvApiCtx, int iVarOut, size_t iValue, char *_fname) {
 %fragment("SWIG_Int_AsPtrDiff", "header", fragment=SWIG_AsVal_frag(int))
 {
 SWIGINTERN int
-SWIG_Int_AsPtrDiff(void *_pvApiCtx, SwigSciObject iVar, ptrdiff_t *piValue, char *_fname) {
+SWIG_Int_AsPtrDiff(void *_pvApiCtx, SwigSciObject iVar, ptrdiff_t *piValue, char *fname) {
   int iValue = 0;
   if (SWIG_AsVal_dec(int)(iVar, &iValue) != SWIG_OK)
     return SWIG_ERROR;
@@ -62,7 +62,7 @@ SWIG_Int_AsPtrDiff(void *_pvApiCtx, SwigSciObject iVar, ptrdiff_t *piValue, char
 }
 %fragment("SWIG_Int_FromPtrDiff", "header", fragment=SWIG_From_frag(int)) {
 SWIGINTERN int
-SWIG_Int_FromPtrDiff(void *_pvApiCtx, int iVarOut, ptrdiff_t iValue, char *_fname) {
+SWIG_Int_FromPtrDiff(void *_pvApiCtx, int iVarOut, ptrdiff_t iValue, char *fname) {
   return SWIG_From_dec(int)((int)iValue);
 }
 }
diff --git a/Lib/scilab/scishort.swg b/Lib/scilab/scishort.swg
index 36f92f726..aefc97289 100644
--- a/Lib/scilab/scishort.swg
+++ b/Lib/scilab/scishort.swg
@@ -8,7 +8,7 @@
 }
 %fragment("SWIG_SciDoubleOrInt16_AsShort", "header") {
 SWIGINTERN int
-SWIG_SciDoubleOrInt16_AsShort(void *_pvApiCtx, int iVar, short *psValue, char *_fname) {
+SWIG_SciDoubleOrInt16_AsShort(void *_pvApiCtx, int iVar, short *psValue, char *fname) {
   SciErr sciErr;
   int iType = 0;
   int iRows = 0;
@@ -37,7 +37,7 @@ SWIG_SciDoubleOrInt16_AsShort(void *_pvApiCtx, int iVar, short *psValue, char *_
       return SWIG_ERROR;
     }
     if (iPrec != SCI_INT16) {
-      Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit signed integer or a double expected.\n"), _fname, iVar);
+      Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit signed integer or a double expected.\n"), fname, iVar);
       return SWIG_TypeError;
     }
     sciErr = getMatrixOfInteger16(_pvApiCtx, piAddrVar, &iRows, &iCols, &psData);
@@ -46,7 +46,7 @@ SWIG_SciDoubleOrInt16_AsShort(void *_pvApiCtx, int iVar, short *psValue, char *_
       return SWIG_ERROR;
     }
     if (iRows * iCols != 1) {
-      Scierror(999, _("%s: Wrong size for input argument #%d: A 16-bit signed integer or a double expected.\n"), _fname, iVar);
+      Scierror(999, _("%s: Wrong size for input argument #%d: A 16-bit signed integer or a double expected.\n"), fname, iVar);
       return SWIG_TypeError;
     }
     *psValue = *psData;
@@ -61,22 +61,22 @@ SWIG_SciDoubleOrInt16_AsShort(void *_pvApiCtx, int iVar, short *psValue, char *_
       return SWIG_ERROR;
     }
     if (iRows * iCols != 1) {
-      Scierror(999, _("%s: Wrong size for input argument #%d: A 16-bit signed integer or a double expected.\n"), _fname, iVar);
+      Scierror(999, _("%s: Wrong size for input argument #%d: A 16-bit signed integer or a double expected.\n"), fname, iVar);
       return SWIG_TypeError;
     }
     dValue = *pdData;
     if (dValue != floor(dValue)) {
-      Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 16-bit signed integer.\n"), _fname, iVar);
+      Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 16-bit signed integer.\n"), fname, iVar);
       return SWIG_ValueError;
     }
     if ((dValue < SHRT_MIN) || (dValue > SHRT_MAX)) {
-      Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 16-bit signed integer.\n"), _fname, iVar);
+      Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 16-bit signed integer.\n"), fname, iVar);
       return SWIG_OverflowError;
     }
     *psValue = (short) dValue;
   }
   else {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit signed integer or a double expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit signed integer or a double expected.\n"), fname, iVar);
     return SWIG_TypeError;
   }
 
@@ -89,7 +89,7 @@ SWIG_SciDoubleOrInt16_AsShort(void *_pvApiCtx, int iVar, short *psValue, char *_
 }
 %fragment("SWIG_SciDouble_FromShort", "header") {
 SWIGINTERN int
-SWIG_SciDouble_FromShort(void *_pvApiCtx, int iVarOut, short sValue, char *_fname) {
+SWIG_SciDouble_FromShort(void *_pvApiCtx, int iVarOut, short sValue, char *fname) {
   if (createScalarDouble(_pvApiCtx,
     SWIG_NbInputArgument(_pvApiCtx) + iVarOut, (double) sValue))
     return SWIG_ERROR;
@@ -103,7 +103,7 @@ SWIG_SciDouble_FromShort(void *_pvApiCtx, int iVarOut, short sValue, char *_fnam
  */
 %fragment("SWIG_SciDoubleOrInt16_AsShortArrayAndSize", "header") {
 SWIGINTERN int
-SWIG_SciDoubleOrInt16_AsShortArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, short **psValue, char *_fname) {
+SWIG_SciDoubleOrInt16_AsShortArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, short **psValue, char *fname) {
   SciErr sciErr;
   int iType = 0;
   int iPrec = 0;
@@ -149,7 +149,7 @@ SWIG_SciDoubleOrInt16_AsShortArrayAndSize(void *_pvApiCtx, int iVar, int *iRows,
       return SWIG_ERROR;
     }
     if (iPrec != SCI_INT16) {
-      Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit signed integer or a double matrix expected.\n"), _fname, iVar);
+      Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit signed integer or a double matrix expected.\n"), fname, iVar);
       return SWIG_ERROR;
     }
 
@@ -161,7 +161,7 @@ SWIG_SciDoubleOrInt16_AsShortArrayAndSize(void *_pvApiCtx, int iVar, int *iRows,
   }
   else
   {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit signed integer or a double matrix expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit signed integer or a double matrix expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
 
diff --git a/Lib/scilab/sciunsignedchar.swg b/Lib/scilab/sciunsignedchar.swg
index 6341ba5c1..a6931dc40 100644
--- a/Lib/scilab/sciunsignedchar.swg
+++ b/Lib/scilab/sciunsignedchar.swg
@@ -7,7 +7,7 @@
 }
 %fragment("SWIG_SciUint8_AsUnsignedChar", "header") {
 SWIGINTERN int
-SWIG_SciUint8_AsUnsignedChar(void *_pvApiCtx, int iVar, unsigned char *pucValue, char *_fname) {
+SWIG_SciUint8_AsUnsignedChar(void *_pvApiCtx, int iVar, unsigned char *pucValue, char *fname) {
   SciErr sciErr;
   int iType = 0;
   int iRows = 0;
@@ -36,7 +36,7 @@ SWIG_SciUint8_AsUnsignedChar(void *_pvApiCtx, int iVar, unsigned char *pucValue,
         return SWIG_ERROR;
       }
       if (iPrec != SCI_UINT8) {
-        Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), _fname, iVar);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), fname, iVar);
         return SWIG_ERROR;
       }
 
@@ -46,7 +46,7 @@ SWIG_SciUint8_AsUnsignedChar(void *_pvApiCtx, int iVar, unsigned char *pucValue,
         return SWIG_ERROR;
       }
       if (iRows * iCols != 1) {
-        Scierror(999, _("%s: Wrong size for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), _fname, iVar);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), fname, iVar);
         return SWIG_ERROR;
       }
       *pucValue = *pucData;
@@ -62,23 +62,23 @@ SWIG_SciUint8_AsUnsignedChar(void *_pvApiCtx, int iVar, unsigned char *pucValue,
         return SWIG_ERROR;
       }
       if (iRows * iCols != 1) {
-        Scierror(999, _("%s: Wrong size for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), _fname, iVar);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), fname, iVar);
         return SWIG_TypeError;
       }
       dValue = *pdData;
       if (dValue != floor(dValue)) {
-        Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 8-bit unsigned integer.\n"), _fname, iVar);
+        Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 8-bit unsigned integer.\n"), fname, iVar);
         return SWIG_ValueError;
       }
       if ((dValue < 0) || (dValue > UCHAR_MAX)) {
-        Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 8-bit unsigned integer.\n"), _fname, iVar);
+        Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 8-bit unsigned integer.\n"), fname, iVar);
         return SWIG_OverflowError;
       }
       *pucValue = (unsigned char) dValue;
     }
   }
   else {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
 
@@ -105,7 +105,7 @@ SWIG_SciUint8_FromUnsignedChar(void *_pvApiCtx, int iVarOut, unsigned char ucVal
  */
 %fragment("SWIG_SciUint8_AsUnsignedCharArrayAndSize", "header") {
 SWIGINTERN int
-SWIG_SciUint8_AsUnsignedCharArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, unsigned char **pucValue, char *_fname) {
+SWIG_SciUint8_AsUnsignedCharArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, unsigned char **pucValue, char *fname) {
   SciErr sciErr;
   int iType = 0;
   int iPrec = 0;
@@ -152,7 +152,7 @@ SWIG_SciUint8_AsUnsignedCharArrayAndSize(void *_pvApiCtx, int iVar, int *iRows,
 
     if (iPrec != SCI_UINT8)
     {
-      Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double vector expected.\n"), _fname, iVar);
+      Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double vector expected.\n"), fname, iVar);
       return SWIG_ERROR;
     }
 
@@ -165,7 +165,7 @@ SWIG_SciUint8_AsUnsignedCharArrayAndSize(void *_pvApiCtx, int iVar, int *iRows,
   }
   else
   {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double vector expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double vector expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
 
diff --git a/Lib/scilab/sciunsignedint.swg b/Lib/scilab/sciunsignedint.swg
index 03ca54e39..91e7ef103 100644
--- a/Lib/scilab/sciunsignedint.swg
+++ b/Lib/scilab/sciunsignedint.swg
@@ -7,7 +7,7 @@
 }
 %fragment("SWIG_SciUint32_AsUnsignedInt", "header") {
 SWIGINTERN int
-SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int iVar, unsigned int *puiValue, char *_fname) {
+SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int iVar, unsigned int *puiValue, char *fname) {
   SciErr sciErr;
   int iType = 0;
   int iRows = 0;
@@ -36,7 +36,7 @@ SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int iVar, unsigned int *puiValue,
         return SWIG_ERROR;
       }
       if (iPrec != SCI_UINT32) {
-        Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), _fname, iVar);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), fname, iVar);
         return SWIG_ERROR;
       }
 
@@ -46,7 +46,7 @@ SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int iVar, unsigned int *puiValue,
         return SWIG_ERROR;
       }
       if (iRows * iCols != 1) {
-        Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), _fname, iVar);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), fname, iVar);
         return SWIG_ERROR;
       }
       *puiValue = *puiData;
@@ -62,23 +62,23 @@ SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int iVar, unsigned int *puiValue,
         return SWIG_ERROR;
       }
       if (iRows * iCols != 1) {
-        Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), _fname, iVar);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), fname, iVar);
         return SWIG_TypeError;
       }
       dValue = *pdData;
       if (dValue != floor(dValue)) {
-        Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 32-bit unsigned integer.\n"), _fname, iVar);
+        Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 32-bit unsigned integer.\n"), fname, iVar);
         return SWIG_ValueError;
       }
       if ((dValue < 0) || (dValue > UINT_MAX)) {
-        Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 32-bit unsigned integer.\n"), _fname, iVar);
+        Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 32-bit unsigned integer.\n"), fname, iVar);
         return SWIG_OverflowError;
       }
       *puiValue = (unsigned int) dValue;
     }
   }
   else {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
 
@@ -91,7 +91,7 @@ SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int iVar, unsigned int *puiValue,
 }
 %fragment("SWIG_SciUint32_FromUnsignedInt", "header") {
 SWIGINTERN int
-SWIG_SciUint32_FromUnsignedInt(void *_pvApiCtx, int iVarOut, unsigned int uiValue, char *_fname) {
+SWIG_SciUint32_FromUnsignedInt(void *_pvApiCtx, int iVarOut, unsigned int uiValue, char *fname) {
   if (createScalarDouble(_pvApiCtx,
     SWIG_NbInputArgument(_pvApiCtx) + iVarOut, (double) uiValue))
     return SWIG_ERROR;
@@ -105,7 +105,7 @@ SWIG_SciUint32_FromUnsignedInt(void *_pvApiCtx, int iVarOut, unsigned int uiValu
  */
 %fragment("SWIG_SciUint32_AsUnsignedIntArrayAndSize", "header") {
 SWIGINTERN int
-SWIG_SciUint32_AsUnsignedIntArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, unsigned int **puiValue, char *_fname) {
+SWIG_SciUint32_AsUnsignedIntArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, unsigned int **puiValue, char *fname) {
   SciErr sciErr;
   int iType = 0;
   int iPrec = 0;
@@ -152,7 +152,7 @@ SWIG_SciUint32_AsUnsignedIntArrayAndSize(void *_pvApiCtx, int iVar, int *iRows,
 
     if (iPrec != SCI_UINT32)
     {
-      Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double vector expected.\n"), _fname, iVar);
+      Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double vector expected.\n"), fname, iVar);
       return SWIG_ERROR;
     }
 
@@ -165,7 +165,7 @@ SWIG_SciUint32_AsUnsignedIntArrayAndSize(void *_pvApiCtx, int iVar, int *iRows,
   }
   else
   {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double vector expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double vector expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
 
diff --git a/Lib/scilab/sciunsignedlong.swg b/Lib/scilab/sciunsignedlong.swg
index bfa4678a0..4a08359ad 100644
--- a/Lib/scilab/sciunsignedlong.swg
+++ b/Lib/scilab/sciunsignedlong.swg
@@ -8,7 +8,7 @@
 }
 %fragment("SWIG_UnsignedInt_AsUnsignedLong", "header", fragment=SWIG_AsVal_frag(unsigned int)) {
 SWIGINTERN int
-SWIG_UnsignedInt_AsUnsignedLong(void *_pvApiCtx, SwigSciObject iVar, unsigned long *pulValue, char *_fname) {
+SWIG_UnsignedInt_AsUnsignedLong(void *_pvApiCtx, SwigSciObject iVar, unsigned long *pulValue, char *fname) {
   unsigned int uiValue = 0;
   if(SWIG_AsVal_unsigned_SS_int(iVar, &uiValue) != SWIG_OK) {
     return SWIG_ERROR;
@@ -23,7 +23,7 @@ SWIG_UnsignedInt_AsUnsignedLong(void *_pvApiCtx, SwigSciObject iVar, unsigned lo
 }
 %fragment("SWIG_UnsignedInt_FromUnsignedLong", "header", fragment=SWIG_From_frag(unsigned int)) {
 SWIGINTERN int
-SWIG_UnsignedInt_FromUnsignedLong(void *_pvApiCtx, int iVarOut, unsigned long ulValue, char *_fname) {
+SWIG_UnsignedInt_FromUnsignedLong(void *_pvApiCtx, int iVarOut, unsigned long ulValue, char *fname) {
   return SWIG_From_unsigned_SS_int((unsigned int)ulValue);
 }
 }
diff --git a/Lib/scilab/sciunsignedshort.swg b/Lib/scilab/sciunsignedshort.swg
index 197de3ee0..7793c9c28 100644
--- a/Lib/scilab/sciunsignedshort.swg
+++ b/Lib/scilab/sciunsignedshort.swg
@@ -7,7 +7,7 @@
 }
 %fragment("SWIG_SciUint16_AsUnsignedShort", "header") {
 SWIGINTERN int
-SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int iVar, unsigned short *pusValue, char *_fname) {
+SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int iVar, unsigned short *pusValue, char *fname) {
   SciErr sciErr;
   int iType = 0;
   int iRows = 0;
@@ -36,7 +36,7 @@ SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int iVar, unsigned short *pusVal
         return SWIG_ERROR;
       }
       if (iPrec != SCI_UINT16) {
-        Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), _fname, iVar);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), fname, iVar);
         return SWIG_ERROR;
       }
 
@@ -46,7 +46,7 @@ SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int iVar, unsigned short *pusVal
         return SWIG_ERROR;
       }
       if (iRows * iCols != 1) {
-        Scierror(999, _("%s: Wrong size for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), _fname, iVar);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), fname, iVar);
         return SWIG_ERROR;
       }
       *pusValue = *pusData;
@@ -62,23 +62,23 @@ SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int iVar, unsigned short *pusVal
         return SWIG_ERROR;
       }
       if (iRows * iCols != 1) {
-        Scierror(999, _("%s: Wrong size for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), _fname, iVar);
+        Scierror(999, _("%s: Wrong size for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), fname, iVar);
         return SWIG_TypeError;
       }
       dValue = *pdData;
       if (dValue != floor(dValue)) {
-        Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 16-bit unsigned integer.\n"), _fname, iVar);
+        Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 16-bit unsigned integer.\n"), fname, iVar);
         return SWIG_ValueError;
       }
       if ((dValue < 0) || (dValue > USHRT_MAX)) {
-        Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 16-bit unsigned integer.\n"), _fname, iVar);
+        Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 16-bit unsigned integer.\n"), fname, iVar);
         return SWIG_OverflowError;
       }
       *pusValue = (unsigned short) dValue;
     }
   }
   else {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }
 
@@ -91,7 +91,7 @@ SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int iVar, unsigned short *pusVal
 }
 %fragment("SWIG_SciUint16_FromUnsignedShort", "header") {
 SWIGINTERN int
-SWIG_SciUint16_FromUnsignedShort(void *_pvApiCtx, int iVarOut, unsigned short usValue, char *_fname) {
+SWIG_SciUint16_FromUnsignedShort(void *_pvApiCtx, int iVarOut, unsigned short usValue, char *fname) {
   if (createScalarDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, (double) usValue))
     return SWIG_ERROR;
   return SWIG_OK;
@@ -104,7 +104,7 @@ SWIG_SciUint16_FromUnsignedShort(void *_pvApiCtx, int iVarOut, unsigned short us
  */
 %fragment("SWIG_SciUint16_AsUnsignedShortArrayAndSize", "header") {
 SWIGINTERN int
-SWIG_SciUint16_AsUnsignedShortArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, unsigned short **pusValue, char *_fname) {
+SWIG_SciUint16_AsUnsignedShortArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, unsigned short **pusValue, char *fname) {
   SciErr sciErr;
   int iType = 0;
   int iPrec = 0;
@@ -151,7 +151,7 @@ SWIG_SciUint16_AsUnsignedShortArrayAndSize(void *_pvApiCtx, int iVar, int *iRows
 
     if (iPrec != SCI_UINT16)
     {
-      Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double vector expected.\n"), _fname, iVar);
+      Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double vector expected.\n"), fname, iVar);
       return SWIG_ERROR;
     }
 
@@ -164,7 +164,7 @@ SWIG_SciUint16_AsUnsignedShortArrayAndSize(void *_pvApiCtx, int iVar, int *iRows
   }
   else
   {
-    Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double vector expected.\n"), _fname, iVar);
+    Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double vector expected.\n"), fname, iVar);
     return SWIG_ERROR;
   }