diff --git a/Lib/scilab/scitypemaps.swg b/Lib/scilab/scitypemaps.swg
index dd6a25c17..b73884160 100644
--- a/Lib/scilab/scitypemaps.swg
+++ b/Lib/scilab/scitypemaps.swg
@@ -16,28 +16,32 @@
              long long (int iRows, int iCols),
              unsigned long long (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   double *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_matrix || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_matrix || iRows != 1 || iCols != 1 || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
+  getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, (double **)&_piData);
   $1 = ($1_ltype)*_piData;
 }
 
 %typemap(in) char (int iRows, int iCols) {   
   int *piAddrVar;
+  int typearg;
   char *_pstStrings;
   int _piLength;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
     
-  if (getVarType(piAddrVar) != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, (char **)&_pstStrings);
+  getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols,&_piLength, (char **)&_pstStrings);
   $1 = ($1_ltype)*_pstStrings;
 }
 
@@ -55,44 +59,50 @@
              long long *,
              unsigned long long * {
   int *piAddrVar;
+  int typearg;
   void *_piData = NULL;
-  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
   
-  if (getVarType(piAddrVar) != sci_pointer) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
-  getPointer(piAddrVar, (void **)&_piData);
+  getPointer(pvApiCtx, piAddrVar, (void **)&_piData);
   $1 = ($1_ltype)_piData;
 }
 
 %typemap(in) char * (int iRows, int iCols){
   int *piAddrVar;
+  int typearg;
   char *_pstStrings;
   int _piLength;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
-  
-  if (getVarType(piAddrVar) != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
+
+  getVarType(pvApiCtx, piAddrVar, &typearg);  
+  if (typearg != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, NULL);
+  getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols, &_piLength, NULL);
   _pstStrings = (char *)malloc(sizeof(char) * _piLength + 1);
-  getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, (char **)&_pstStrings);
+  getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols, &_piLength, (char **)&_pstStrings);
   $1 = ($1_ltype)strdup(_pstStrings);
   free(_pstStrings);
 }
 
 %typemap(in) signed char [ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   char *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if ( typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger8(piAddrVar, &iRows, &iCols, (char **)&_piData);
+  getMatrixOfInteger8(pvApiCtx, piAddrVar, &iRows, &iCols, (char **)&_piData);
   for(; ii < (size_t)iCols; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -100,15 +110,17 @@
 
 %typemap(in) unsigned char [ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   unsigned char *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
-  
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
+
+  getVarType(pvApiCtx, piAddrVar, &typearg);  
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger8(piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
+  getMatrixOfUnsignedInteger8(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
   for(; ii < (size_t)iCols; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -116,15 +128,17 @@
 
 %typemap(in) short [ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   short *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger16(piAddrVar, &iRows, &iCols, (short **)&_piData);
+  getMatrixOfInteger16(pvApiCtx, piAddrVar, &iRows, &iCols, (short **)&_piData);
   for(; ii < (size_t)iCols; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -132,15 +146,17 @@
 
 %typemap(in) unsigned short [ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   unsigned short *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger16(piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
+  getMatrixOfUnsignedInteger16(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
   for(; ii < (size_t)iCols; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -149,15 +165,17 @@
 %typemap(in) int [ANY] (int iRows, int iCols),
 	     long [ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   int *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
+  getMatrixOfInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, (int **)&_piData);
   for(; ii < (size_t)iCols; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -166,15 +184,17 @@
 %typemap(in) unsigned int [ANY] (int iRows, int iCols),
 	     unsigned long [ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   unsigned int *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger32(piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
+  getMatrixOfUnsignedInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
   for(; ii < (size_t)iCols; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -183,15 +203,17 @@
 %typemap(in) double [ANY] (int iRows, int iCols),
              float [ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   double *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_matrix || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_matrix || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
+  getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, (double **)&_piData);
   for(; ii < (size_t)iCols; ii++){
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -199,15 +221,17 @@
 
 %typemap(in) long long [ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   long long *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger64(piAddrVar, &iRows, &iCols, (long long **)&_piData);
+  getMatrixOfInteger64(pvApiCtx, piAddrVar, &iRows, &iCols, (long long **)&_piData);
   for(; ii < (size_t)iCols; ii++){
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -215,15 +239,17 @@
 
 %typemap(in) unsigned long long [ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   unsigned long long *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger64(piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
+  getMatrixOfUnsignedInteger64(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
   for(; ii < (size_t)iCols; ii++){
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -231,29 +257,33 @@
 
 %typemap(in) char [ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   char *_pstStrings;
   int _piLength;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, (char **)&_pstStrings);
+  getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols,&_piLength, (char **)&_pstStrings);
   $1 = ($1_ltype)strdup(_pstStrings);
 }
 
 %typemap(in) signed char [] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   char *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger8(piAddrVar, &iRows, &iCols, (char **)&_piData);
+  getMatrixOfInteger8(pvApiCtx, piAddrVar, &iRows, &iCols, (char **)&_piData);
   $1 = ($1_ltype)malloc(sizeof($*1_ltype) * iCols);
   for(; ii < (size_t)iCols; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
@@ -262,15 +292,17 @@
 
 %typemap(in) unsigned char [] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   unsigned char *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger8(piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
+  getMatrixOfUnsignedInteger8(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
   $1 = ($1_ltype)malloc(sizeof($*1_ltype) * iCols);
   for(; ii < (size_t)iCols; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
@@ -279,15 +311,17 @@
 
 %typemap(in) short [] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   short *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger16(piAddrVar, &iRows, &iCols, (short **)&_piData);
+  getMatrixOfInteger16(pvApiCtx, piAddrVar, &iRows, &iCols, (short **)&_piData);
   $1 = ($1_ltype)malloc(sizeof($*1_ltype) * iCols);
   for(; ii < (size_t)iCols; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
@@ -296,15 +330,17 @@
 
 %typemap(in) unsigned short [] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   unsigned short *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger16(piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
+  getMatrixOfUnsignedInteger16(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
   $1 = ($1_ltype)malloc(sizeof($*1_ltype) * iCols);
   for(; ii < (size_t)iCols; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
@@ -314,16 +350,18 @@
 %typemap(in) int [] (int iRows, int iCols),
 	     long [] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   int *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   $1 = ($1_ltype)malloc(sizeof($*1_ltype) * iCols);
-  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
+  getMatrixOfInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, (int **)&_piData);
   for(; ii < (size_t)iCols; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -332,15 +370,17 @@
 %typemap(in) unsigned int [] (int iRows, int iCols),
 	     unsigned long [] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   unsigned int *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger32(piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
+  getMatrixOfUnsignedInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
   $1 = ($1_ltype)malloc(sizeof($*1_ltype) * iCols);
   for(; ii < (size_t)iCols; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
@@ -350,15 +390,17 @@
 %typemap(in) double [] (int iRows, int iCols),
              float [] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   double *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_matrix || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_matrix || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
+  getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, (double **)&_piData);
   $1 = ($1_ltype)malloc(sizeof($*1_ltype) * iCols);
   for(; ii < (size_t)iCols; ii++){
     $1[ii] = ($*1_ltype)_piData[ii];
@@ -367,15 +409,17 @@
 
 %typemap(in) long long [] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   long long *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger64(piAddrVar, &iRows, &iCols, (long long **)&_piData);
+  getMatrixOfInteger64(pvApiCtx, piAddrVar, &iRows, &iCols, (long long **)&_piData);
   $1 = ($1_ltype)malloc(sizeof($*1_ltype) * iCols);
   for(; ii < (size_t)iCols; ii++){
     $1[ii] = ($*1_ltype)_piData[ii];
@@ -384,15 +428,16 @@
 
 %typemap(in) unsigned long long [] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   unsigned long long *_piData;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger64(piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
+  getMatrixOfUnsignedInteger64(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
   $1 = ($1_ltype)malloc(sizeof($*1_ltype) * iCols);
   for(; ii < (size_t)iCols; ii++){
     $1[ii] = ($*1_ltype)_piData[ii];
@@ -402,14 +447,16 @@
 /* Arrays */
 %typemap(in) signed char [ANY][ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   char *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger8(piAddrVar, &iRows, &iCols, (char **)&_piData);
+  getMatrixOfInteger8(pvApiCtx, piAddrVar, &iRows, &iCols, (char **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)iRows; ii++){
@@ -421,14 +468,16 @@
 
 %typemap(in) unsigned char [ANY][ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   unsigned char *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger8(piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
+  getMatrixOfUnsignedInteger8(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)iRows; ii++){
@@ -440,14 +489,16 @@
 
 %typemap(in) short [ANY][ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   short *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger16(piAddrVar, &iRows, &iCols, (short **)&_piData);
+  getMatrixOfInteger16(pvApiCtx, piAddrVar, &iRows, &iCols, (short **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)iRows; ii++){
@@ -459,14 +510,16 @@
 
 %typemap(in) unsigned short [ANY][ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   unsigned short *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger16(piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
+  getMatrixOfUnsignedInteger16(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
  
   size_t ii = 0;
   for(; ii < (size_t)iRows; ii++){
@@ -480,13 +533,15 @@
              long [ANY][ANY] (int iRows, int iCols) {
   int *piAddrVar;
   int *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
+  getMatrixOfInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, (int **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)iRows; ii++){
@@ -499,14 +554,16 @@
 %typemap(in) unsigned int [ANY][ANY] (int iRows, int iCols), 
              unsigned long [ANY][ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   unsigned int *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger32(piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
+  getMatrixOfUnsignedInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)iRows; ii++){
@@ -519,14 +576,16 @@
 %typemap(in) double [ANY][ANY] (int iRows, int iCols),
              float [ANY][ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   double *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_matrix || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_matrix || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
+  getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, (double **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)iRows; ii++){
@@ -538,14 +597,16 @@
 
 %typemap(in) long long [ANY][ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   long long *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger64(piAddrVar, &iRows, &iCols, (long long **)&_piData);
+  getMatrixOfInteger64(pvApiCtx, piAddrVar, &iRows, &iCols, (long long **)&_piData);
 
   size_t ii = 0;
   for(; ii < (size_t)iRows; ii++){
@@ -557,14 +618,16 @@
 
 %typemap(in) unsigned long long [ANY][ANY] (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   unsigned long long *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger64(piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
+  getMatrixOfUnsignedInteger64(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
 
   size_t ii = 0;
   for(; ii < (size_t)iRows; ii++){
@@ -576,39 +639,45 @@
 
 %typemap(in) enum SWIGTYPE (int iRows, int iCols) {
   int *piAddrVar;
+  int typearg;
   int *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || iRows != 1 || iCols != 1 || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
+  getMatrixOfInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, (int **)&_piData);
   $1 = ($1_ltype)*_piData;
 }
 
 %typemap(in) SWIGTYPE *,
              SWIGTYPE [] {
   int *piAddrVar;
+  int typearg;
   void *_piData = NULL;
-  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
   
-  if (getVarType(piAddrVar) != sci_pointer) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
-  getPointer(piAddrVar, (void **)&_piData);
+  getPointer(pvApiCtx, piAddrVar, (void **)&_piData);
   $1 = ($1_ltype)_piData;
 }
 
 %typemap(in) SWIGTYPE {
   int *piAddrVar;
+  int typearg;
   void *_piData = NULL;
-  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
   
-  if (getVarType(piAddrVar) != sci_pointer) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
-  getPointer(piAddrVar, (void **)&_piData);
+  getPointer(pvApiCtx, piAddrVar, (void **)&_piData);
   $1 = *(($&1_ltype)_piData);
 }
 
@@ -620,28 +689,28 @@
 %typemap(out) signed char (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, (char *)&$result);
+  createMatrixOfInteger8(pvApiCtx, iVarOut, iRowsOut, iColsOut, (char *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) unsigned char (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfUnsignedInteger8(iVarOut, iRowsOut, iColsOut, (unsigned char *)&$result);
+  createMatrixOfUnsignedInteger8(pvApiCtx, iVarOut, iRowsOut, iColsOut, (unsigned char *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) short (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, (short *)&$result);
+  createMatrixOfInteger16(pvApiCtx, iVarOut, iRowsOut, iColsOut, (short *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) unsigned short (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfUnsignedInteger16(iVarOut, iRowsOut, iColsOut, (unsigned short *)&$result);
+  createMatrixOfUnsignedInteger16(pvApiCtx, iVarOut, iRowsOut, iColsOut, (unsigned short *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -649,7 +718,7 @@
               long (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, (int *)&$result);
+  createMatrixOfInteger32(pvApiCtx, iVarOut, iRowsOut, iColsOut, (int *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -657,7 +726,7 @@
               unsigned long (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfUnsignedInteger32(iVarOut, iRowsOut, iColsOut, (unsigned int *)&$result);
+  createMatrixOfUnsignedInteger32(pvApiCtx, iVarOut, iRowsOut, iColsOut, (unsigned int *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -665,21 +734,21 @@
               float (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, (double *)&$result);
+  createMatrixOfDouble(pvApiCtx, iVarOut, iRowsOut, iColsOut, (double *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) long long (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfInteger64(iVarOut, iRowsOut, iColsOut, (long long *)&$result);
+  createMatrixOfInteger64(pvApiCtx, iVarOut, iRowsOut, iColsOut, (long long *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) unsigned long long (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfUnsignedInteger64(iVarOut, iRowsOut, iColsOut, (unsigned long long *)&$result);
+  createMatrixOfUnsignedInteger64(pvApiCtx, iVarOut, iRowsOut, iColsOut, (unsigned long long *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -688,7 +757,7 @@
   temp = (char*)&($result);
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfString(iVarOut, iRowsOut, iColsOut, (char **)&temp);
+  createMatrixOfString(pvApiCtx, iVarOut, iRowsOut, iColsOut, (char **)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -709,31 +778,31 @@
               float *,
               long long,
               unsigned long long * {
-  createPointer(iVarOut, (void *)$result);
+  createPointer(pvApiCtx, iVarOut, (void *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) char * (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfString(iVarOut, iRowsOut, iColsOut, (char **)&($result));
+  createMatrixOfString(pvApiCtx, iVarOut, iRowsOut, iColsOut, (char **)&($result));
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) enum SWIGTYPE (int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, (int *)&$result);
+  createMatrixOfInteger32(pvApiCtx, iVarOut, iRowsOut, iColsOut, (int *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) SWIGTYPE * {
-  createPointer(iVarOut, (void *)$result);
+  createPointer(pvApiCtx, iVarOut, (void *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(out) SWIGTYPE {
-  createPointer(iVarOut, (void *)&$result);
+  createPointer(pvApiCtx, iVarOut, (void *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -754,72 +823,82 @@
                           long long,
                           unsigned long long {
   double *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_matrix || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_matrix || iRows != 1 || iCols != 1 || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
+  getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, (double **)&_piData);
   $1 = ($1_ltype)*_piData;
 }
 
 %typemap(varin,noblock=1) char {   
   char *_pstStrings;
+  int typearg;
   int _piLength;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
     
-  if (getVarType(piAddrVar) != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfString(piAddrVar, &iRows, &iCols,&_piLength, (char **)&_pstStrings);
+  getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols,&_piLength, (char **)&_pstStrings);
   $1 = ($1_ltype)*_pstStrings;
 }
 
 %typemap(varin,noblock=1) char * {
   char *_pstStrings;
+  int typearg;
   int _piLength;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+    if (typearg != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, NULL);
+  getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols, &_piLength, NULL);
   _pstStrings = (char *)malloc(sizeof(char) * _piLength + 1);
-  getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, (char **)&_pstStrings);
+  getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols, &_piLength, (char **)&_pstStrings);
   $1 = ($1_ltype)strdup(_pstStrings);
   free(_pstStrings);
 }
 
 %typemap(varin,noblock=1) char [ANY] {
   char *_pstStrings;
+  int typearg;
   int _piLength;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_strings || iRows != 1 || iCols != 1 || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   
-  getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, NULL);
+  getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols, &_piLength, NULL);
   _pstStrings = (char *)malloc(sizeof(char) * _piLength);
-  getMatrixOfString(piAddrVar, &iRows, &iCols, &_piLength, (char **)&_pstStrings);
+  getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols, &_piLength, (char **)&_pstStrings);
   strcpy($1, _pstStrings);
   free(_pstStrings);
 }
 
 %typemap(varin,noblock=1) signed char [ANY] {
   char *_piData;
+  int typearg;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger8(piAddrVar, &iRows, &iCols, (char **)&_piData);
+  getMatrixOfInteger8(pvApiCtx, piAddrVar, &iRows, &iCols, (char **)&_piData);
   for(; ii < (size_t)$1_dim0; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -827,14 +906,16 @@
 
 %typemap(varin,noblock=1) unsigned char [ANY] {
   unsigned char *_piData;
+  int typearg;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger8(piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
+  getMatrixOfUnsignedInteger8(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
   for(; ii < (size_t)$1_dim0; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -842,14 +923,16 @@
 
 %typemap(varin,noblock=1) short [ANY] {
   short *_piData;
+  int typearg;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger16(piAddrVar, &iRows, &iCols, (short **)&_piData);
+  getMatrixOfInteger16(pvApiCtx, piAddrVar, &iRows, &iCols, (short **)&_piData);
   for(; ii < (size_t)$1_dim0; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -857,14 +940,16 @@
 
 %typemap(varin,noblock=1) unsigned short [ANY] {
   unsigned short *_piData;
+  int typearg;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger16(piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
+  getMatrixOfUnsignedInteger16(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
   for(; ii < (size_t)$1_dim0; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -873,14 +958,16 @@
 %typemap(varin,noblock=1) int [ANY],
 	                  long [ANY] {
   int *_piData;
+  int typearg;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
+  getMatrixOfInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, (int **)&_piData);
   for(; ii < (size_t)$1_dim0; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -889,14 +976,16 @@
 %typemap(varin,noblock=1) unsigned int [ANY],
 	                  unsigned long [ANY] {
   unsigned int *_piData;
+  int typearg;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger32(piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
+  getMatrixOfUnsignedInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
   for(; ii < (size_t)$1_dim0; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -905,14 +994,16 @@
 %typemap(varin,noblock=1) double [ANY],
                           float [ANY] {
   double *_piData;
+  int typearg;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_matrix || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_matrix || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
+  getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, (double **)&_piData);
   for(; ii < (size_t)$1_dim0; ii++){
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -920,14 +1011,16 @@
 
 %typemap(varin,noblock=1) long long [ANY] {
   int *_piData;
+  int typearg;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger64(piAddrVar, &iRows, &iCols, (long long **)&_piData);
+  getMatrixOfInteger64(pvApiCtx, piAddrVar, &iRows, &iCols, (long long **)&_piData);
   for(; ii < (size_t)$1_dim0; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -935,14 +1028,16 @@
 
 %typemap(varin,noblock=1) unsigned long long [ANY] {
   int *_piData;
+  int typearg;
   size_t ii = 0;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger64(piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
+  getMatrixOfUnsignedInteger64(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
   for(; ii < (size_t)$1_dim0; ii++) {
     $1[ii] = ($*1_ltype)_piData[ii];
   }
@@ -962,34 +1057,38 @@
                           long long *,
                           unsigned long long * {
   void *_piData = NULL;
-  getVarAddressFromPosition($argnum, &piAddrVar);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
   
-  if (getVarType(piAddrVar) != sci_pointer) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
-  getPointer(piAddrVar, (void **)&_piData);
+  getPointer(pvApiCtx, piAddrVar, (void **)&_piData);
   $1 = ($1_ltype)_piData;
 }
 
 %typemap(varin,noblock=1) char ** {
   char **_pstStrings;
   int *_piLength;
+  int typearg;
   int i;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_strings || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_strings || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
   
   _piLength = (int*)malloc(sizeof(int) * iRows * iCols);
-  getMatrixOfString(piAddrVar, &iRows, &iCols, _piLength, NULL);
+  getMatrixOfString(pvApiCtxpiAddrVar, &iRows, &iCols, _piLength, NULL);
   
   _pstStrings = (char**)malloc(iRows * iCols * sizeof(char*));
   for(i = 0; i < iRows * iCols; i++) {
     _pstStrings[i] = (char*)malloc((_piLength[i] + 1) * sizeof(char));
   }
-  getMatrixOfString(piAddrVar, &iRows, &iCols, _piLength, (char **)_pstStrings);
+  getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols, _piLength, (char **)_pstStrings);
   
   $1 = _pstStrings;
 }
@@ -997,13 +1096,15 @@
 /* Arrays */
 %typemap(varin,noblock=1) signed char [ANY][ANY] {
   char *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger8(piAddrVar, &iRows, &iCols, (char **)&_piData);
+  getMatrixOfInteger8(pvApiCtx, piAddrVar, &iRows, &iCols, (char **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)$1_dim0; ii++){
@@ -1015,13 +1116,15 @@
 
 %typemap(varin,noblock=1) unsigned char [ANY][ANY] {
   unsigned char *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger8(piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
+  getMatrixOfUnsignedInteger8(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned char **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)$1_dim0; ii++){
@@ -1033,13 +1136,15 @@
 
 %typemap(varin,noblock=1) short [ANY][ANY] {
   short *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger16(piAddrVar, &iRows, &iCols, (short **)&_piData);
+  getMatrixOfInteger16(pvApiCtx, piAddrVar, &iRows, &iCols, (short **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)$1_dim0; ii++){
@@ -1051,13 +1156,15 @@
 
 %typemap(varin,noblock=1) unsigned short [ANY][ANY] {
   unsigned short *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger16(piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
+  getMatrixOfUnsignedInteger16(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned short **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)$1_dim0; ii++){
@@ -1070,13 +1177,15 @@
 %typemap(varin,noblock=1) int [ANY][ANY], 
                           long [ANY][ANY] {
   int *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
+  getMatrixOfInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, (int **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)$1_dim0; ii++){
@@ -1089,13 +1198,15 @@
 %typemap(varin,noblock=1) unsigned int [ANY][ANY],
                           unsigned long [ANY][ANY] {
   unsigned int *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger32(piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
+  getMatrixOfUnsignedInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned int **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)$1_dim0; ii++){
@@ -1108,13 +1219,15 @@
 %typemap(varin,noblock=1) double [ANY][ANY],
                           float [ANY][ANY] {
   double *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_matrix || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_matrix || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfDouble(piAddrVar, &iRows, &iCols, (double **)&_piData);
+  getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, (double **)&_piData);
  
   size_t ii = 0;
   for(; ii < (size_t)$1_dim0; ii++){
@@ -1126,13 +1239,15 @@
 
 %typemap(varin,noblock=1) long long [ANY][ANY] {
   long long *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger64(piAddrVar, &iRows, &iCols, (long long **)&_piData);
+  getMatrixOfInteger64(pvApiCtx, piAddrVar, &iRows, &iCols, (long long **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)$1_dim0; ii++){
@@ -1144,13 +1259,15 @@
 
 %typemap(varin,noblock=1) unsigned long long [ANY][ANY] {
   unsigned long long *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfUnsignedInteger64(piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
+  getMatrixOfUnsignedInteger64(pvApiCtx, piAddrVar, &iRows, &iCols, (unsigned long long **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)$1_dim0; ii++){
@@ -1162,36 +1279,42 @@
 
 %typemap(varin,noblock=1) enum SWIGTYPE {
   int *_piData;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  getVarDimension(piAddrVar, &iRows, &iCols);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarDimension(pvApiCtx, piAddrVar, &iRows, &iCols);
   
-  if (getVarType(piAddrVar) != sci_ints || iRows != 1 || iCols != 1 || isVarComplex(piAddrVar)) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_ints || iRows != 1 || iCols != 1 || isVarComplex(pvApiCtx, piAddrVar)) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), fname, $argnum);
   }
-  getMatrixOfInteger32(piAddrVar, &iRows, &iCols, (int **)&_piData);
+  getMatrixOfInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, (int **)&_piData);
   $1 = ($1_ltype)*_piData;
 }
 %typemap(varin,noblock=1) SWIGTYPE * {
   void *_piData = NULL;
-  getVarAddressFromPosition($argnum, &piAddrVar);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
   
-  if (getVarType(piAddrVar) != sci_pointer) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
-  getPointer(piAddrVar, (void **)&_piData);
+  getPointer(pvApiCtx, piAddrVar, (void **)&_piData);
   $1 = ($1_ltype)_piData;
 }
 
 %typemap(varin,noblock=1) SWIGTYPE [ANY] {
   void *_piData = NULL;
+  int typearg;
   size_t ii;
-  getVarAddressFromPosition($argnum, &piAddrVar);
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
   
-  if (getVarType(piAddrVar) != sci_pointer) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
 /* TODO: change for a getmatrixofXXXXXXxx */
-  getPointer(piAddrVar, (void **)&_piData);
+  getPointer(pvApiCtx, piAddrVar, (void **)&_piData);
   for(ii = 0; ii < $1_dim0; ii++){
     $1[ii] = (($1_ltype)_piData)[ii];
   }
@@ -1199,13 +1322,15 @@
 
 %typemap(varin,noblock=1) SWIGTYPE [ANY][ANY] {
   void *_piData = NULL;
-  getVarAddressFromPosition($argnum, &piAddrVar);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
   
-  if (getVarType(piAddrVar) != sci_pointer) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
 /* TODO: change for a getmatrixofXXXXXXxx */
-  getPointer(piAddrVar, (void **)&_piData);
+  getPointer(pvApiCtx, piAddrVar, (void **)&_piData);
   
   size_t ii = 0;
   for(; ii < (size_t)$1_dim0; ii++){
@@ -1218,13 +1343,15 @@
 
 %typemap(varin,nobloack=1) SWIGTYPE {
   void *_piData = NULL;
-  getVarAddressFromPosition($argnum, &piAddrVar);
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
   
-  if (getVarType(piAddrVar) != sci_pointer) {
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  if (typearg != sci_pointer) {
     Scierror(999, _("%s: Wrong type for input argument #%d: Pointer expected.\n"), fname, $argnum);
   }
 /* TODO: change for a getmatrixofXXXXXXxx */
-  getPointer(piAddrVar, (void **)&_piData);
+  getPointer(pvApiCtx, piAddrVar, (void **)&_piData);
   $1 = *(($&1_ltype)_piData);
 }
 
@@ -1234,59 +1361,59 @@
 /* Basic C types */
 %typemap(varout,noblock=1) signed char {
   char temp = $result;
-  createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, (char *)&temp);
+  createMatrixOfInteger8(pvApiCtx, iVarOut, iRowsOut, iColsOut, (char *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned char {
   unsigned char temp = $result;
-  createMatrixOfUnsignedInteger8(iVarOut, iRowsOut, iColsOut, (unsigned char *)&temp);
+  createMatrixOfUnsignedInteger8(pvApiCtx, iVarOut, iRowsOut, iColsOut, (unsigned char *)&temp);
   LhsVar(iOutNum) = iVarOut;
 
 }
 
 %typemap(varout,noblock=1) short {
   short temp = $result;
-  createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, (short *)&temp);
+  createMatrixOfInteger16(pvApiCtx, iVarOut, iRowsOut, iColsOut, (short *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned short {
   unsigned short temp = $result;
-  createMatrixOfUnsignedInteger16(iVarOut, iRowsOut, iColsOut, (unsigned short *)&temp);
+  createMatrixOfUnsignedInteger16(pvApiCtx, iVarOut, iRowsOut, iColsOut, (unsigned short *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) int,
                            long {
   int temp = $result;
-  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, (int *)&temp);
+  createMatrixOfInteger32(pvApiCtx, iVarOut, iRowsOut, iColsOut, (int *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned int,
                            unsigned long {
   unsigned int temp = $result;
-  createMatrixOfUnsignedInteger32(iVarOut, iRowsOut, iColsOut, (unsigned int *)&temp);
+  createMatrixOfUnsignedInteger32(pvApiCtx, iVarOut, iRowsOut, iColsOut, (unsigned int *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) double,
                            float {
   double temp = $result;
-  createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, (double *)&temp);
+  createMatrixOfDouble(pvApiCtx, iVarOut, iRowsOut, iColsOut, (double *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) long long {
   long long temp = $result;
-  createMatrixOfInteger64(iVarOut, iRowsOut, iColsOut, (long long *)&temp);
+  createMatrixOfInteger64(pvApiCtx, iVarOut, iRowsOut, iColsOut, (long long *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned long long {
   unsigned long long temp = $result;
-  createMatrixOfUnsignedInteger64(iVarOut, iRowsOut, iColsOut, (unsigned long long *)&temp);
+  createMatrixOfUnsignedInteger64(pvApiCtx, iVarOut, iRowsOut, iColsOut, (unsigned long long *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -1294,14 +1421,14 @@
   char *temp = (char *)malloc(sizeof($result) + 1);
   *temp = $result;
   *(temp+1) = '\0';
-  createMatrixOfString(iVarOut, iRowsOut, iColsOut, (char **)&temp);
+  createMatrixOfString(pvApiCtx, iVarOut, iRowsOut, iColsOut, (char **)&temp);
   LhsVar(iOutNum) = iVarOut;
   free(temp);
 }
 
 %typemap(varout,noblock=1) char * {
   char *temp = $result;
-  createMatrixOfString(iVarOut, iRowsOut, iColsOut, (char **)&temp);
+  createMatrixOfString(pvApiCtx, iVarOut, iRowsOut, iColsOut, (char **)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -1318,7 +1445,7 @@
                            float *,
                            long long *,
                            unsigned long long * {
-  createPointer(iVarOut, (void *)$result);
+  createPointer(pvApiCtx, iVarOut, (void *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -1327,60 +1454,60 @@
   char **pstData = NULL;
   pstData = (char **)malloc(sizeof(char *));
   pstData[0] = $result;
-  createMatrixOfString(iVarOut, iRowsOut, iColsOut, (char **)pstData);
+  createMatrixOfString(pvApiCtx, iVarOut, iRowsOut, iColsOut, (char **)pstData);
   LhsVar(iOutNum) = iVarOut;
    
 }
 
 %typemap(varout,noblock=1) signed char [ANY] {
-  createMatrixOfInteger8(iVarOut, 1, $1_dim0, (char *)$result);
+  createMatrixOfInteger8(pvApiCtx, iVarOut, 1, $1_dim0, (char *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned char [ANY] {
-  createMatrixOfUnsignedInteger8(iVarOut, 1, $1_dim0, (unsigned char *)$result);
+  createMatrixOfUnsignedInteger8(pvApiCtx, iVarOut, 1, $1_dim0, (unsigned char *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) short [ANY] {
-  createMatrixOfInteger16(iVarOut, 1, $1_dim0, (short *)$result);
+  createMatrixOfInteger16(pvApiCtx, iVarOut, 1, $1_dim0, (short *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned short [ANY] {
-  createMatrixOfUnsignedInteger16(iVarOut, 1, $1_dim0, (unsigned short *)$result);
+  createMatrixOfUnsignedInteger16(pvApiCtx, iVarOut, 1, $1_dim0, (unsigned short *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) int [ANY],
                            long [ANY] {
-  createMatrixOfInteger32(iVarOut, 1, $1_dim0, (int *)$result);
+  createMatrixOfInteger32(pvApiCtx, iVarOut, 1, $1_dim0, (int *)$result); // Celu ci
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned int [ANY],
                            unsigned long [ANY] {
-  createMatrixOfUnsignedInteger32(iVarOut, 1, $1_dim0, (unsigned int *)$result);
+  createMatrixOfUnsignedInteger32(pvApiCtx, iVarOut, 1, $1_dim0, (unsigned int *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) double [ANY] {
-  createMatrixOfDouble(iVarOut, 1, $1_dim0, (double *)$result);
+  createMatrixOfDouble(pvApiCtx, iVarOut, 1, $1_dim0, (double *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) float [ANY] {
-  createMatrixOfDouble(iVarOut, 1, $1_dim0, (double *)$result);
+  createMatrixOfDouble(pvApiCtx, iVarOut, 1, $1_dim0, (double *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) long long [ANY] {
-  createMatrixOfInteger64(iVarOut, 1, $1_dim0, (long long *)$result);
+  createMatrixOfInteger64(pvApiCtx, iVarOut, 1, $1_dim0, (long long *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned long long [ANY] {
-  createMatrixOfUnsignedInteger64(iVarOut, 1, $1_dim0, (unsigned long long *)$result);
+  createMatrixOfUnsignedInteger64(pvApiCtx, iVarOut, 1, $1_dim0, (unsigned long long *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -1388,79 +1515,79 @@
   char **pstData = NULL;
   pstData = (char **)malloc(iRowsOut * iColsOut * sizeof(char*));
   pstData = $result;
-  createMatrixOfString(iVarOut, iRowsOut, iColsOut, (char **)pstData);
+  createMatrixOfString(pvApiCtx, iVarOut, iRowsOut, iColsOut, (char **)pstData);
   LhsVar(iOutNum) = iVarOut;
 }
 
 
 %typemap(varout,noblock=1) signed char [ANY][ANY],
                            char [ANY][ANY]{
-  createMatrixOfInteger8(iVarOut, $1_dim0, $1_dim1, (char *)$result);
+  createMatrixOfInteger8(pvApiCtx, iVarOut, $1_dim0, $1_dim1, (char *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned char [ANY][ANY] {
-  createMatrixOfUnsignedInteger8(iVarOut, $1_dim0, $1_dim1, (unsigned char *)$result);
+  createMatrixOfUnsignedInteger8(pvApiCtx, iVarOut, $1_dim0, $1_dim1, (unsigned char *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) short [ANY][ANY] {
-  createMatrixOfInteger16(iVarOut, $1_dim0, $1_dim1, (short *)$result);
+  createMatrixOfInteger16(pvApiCtx, iVarOut, $1_dim0, $1_dim1, (short *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned short [ANY][ANY] {
-  createMatrixOfUnsignedInteger16(iVarOut, $1_dim0, $1_dim1, (unsigned short *)$result);
+  createMatrixOfUnsignedInteger16(pvApiCtx, iVarOut, $1_dim0, $1_dim1, (unsigned short *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) int [ANY][ANY],
                            long [ANY][ANY] {
-  createMatrixOfInteger32(iVarOut, $1_dim0, $1_dim1, (int *)$result);
+  createMatrixOfInteger32(pvApiCtx, iVarOut, $1_dim0, $1_dim1, (int *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned int [ANY][ANY],
                            unsigned long [ANY][ANY] {
-  createMatrixOfUnsignedInteger32(iVarOut, $1_dim0, $1_dim1, (unsigned int *)$result);
+  createMatrixOfUnsignedInteger32(pvApiCtx, iVarOut, $1_dim0, $1_dim1, (unsigned int *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) double [ANY][ANY] {
-  createMatrixOfDouble(iVarOut, $1_dim0, $1_dim1, (double *)$result);
+  createMatrixOfDouble(pvApiCtx, iVarOut, $1_dim0, $1_dim1, (double *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) float [ANY][ANY] {
-  createMatrixOfDouble(iVarOut, $1_dim0, $1_dim1, (double *)$result);
+  createMatrixOfDouble(pvApiCtx, iVarOut, $1_dim0, $1_dim1, (double *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) long long [ANY][ANY] {
-  createMatrixOfInteger64(iVarOut, $1_dim0, $1_dim1, (long long *)$result);
+  createMatrixOfInteger64(pvApiCtx, iVarOut, $1_dim0, $1_dim1, (long long *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) unsigned long long [ANY][ANY] {
-  createMatrixOfUnsignedInteger64(iVarOut, $1_dim0, $1_dim1, (unsigned long long *)$result);
+  createMatrixOfUnsignedInteger64(pvApiCtx, iVarOut, $1_dim0, $1_dim1, (unsigned long long *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 
 /* Enums */
 %typemap(varout,noblock=1) enum SWIGTYPE {
-  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, (int *)&temp);
+  createMatrixOfInteger32(pvApiCtx, iVarOut, iRowsOut, iColsOut, (int *)&temp);
   LhsVar(iOutNum) = iVarOut;
 }
 
 /* Other types */
 %typemap(varout,noblock=1) SWIGTYPE * {
-  createPointer(iVarOut, (void *)$result);
+  createPointer(pvApiCtx, iVarOut, (void *)$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
 %typemap(varout,noblock=1) SWIGTYPE {
-  createPointer(iVarOut, (void *)&$result);
+  createPointer(pvApiCtx, iVarOut, (void *)&$result);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -1470,124 +1597,162 @@
 /* Basic C types */
 %typecheck(SWIG_TYPECHECK_CHAR) char {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_strings) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_strings) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_INT8) signed char {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_UINT8) unsigned char {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_INT16) short {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_UINT16) unsigned short {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_INT32) int, 
                                  long {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_UINT32) unsigned int,
                                   unsigned long {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 
 %typecheck(SWIG_TYPECHECK_DOUBLE) double {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_FLOAT) float {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_STRING) char * {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_strings) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_strings) ? 1 : 0;
 }
 
 /* Arrays */
 %typecheck(SWIG_TYPECHECK_CHAR_ARRAY) char [ANY] {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_strings) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_strings) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_INT8_ARRAY) signed char [ANY] {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_INT16_ARRAY) unsigned char [ANY],
                                        short [ANY] {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_INT32_ARRAY) unsigned short [ANY],
                                        int [ANY],
                                        long [ANY] {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_INT64_ARRAY) unsigned int [ANY],
                                         unsigned long [ANY] {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY) double [ANY]{
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_FLOAT_ARRAY) float [ANY]{
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_matrix) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_matrix) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_STRING_ARRAY) char ** {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_strings) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_strings) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE * {
   int *piAddrVar;
-  getVarAddressFromPosition($argnum, &piAddrVar);
-  $1 = (getVarType(piAddrVar) == sci_pointer) ? 1 : 0;
+  int typearg;
+  getVarAddressFromPosition(pvApiCtx, $argnum, &piAddrVar);
+  getVarType(pvApiCtx, piAddrVar, &typearg);
+  $1 = (typearg == sci_pointer) ? 1 : 0;
 }
 
 /* ------------------------------------------------------------
diff --git a/Lib/scilab/typemaps.i b/Lib/scilab/typemaps.i
index df523a720..9dc7a8d93 100644
--- a/Lib/scilab/typemaps.i
+++ b/Lib/scilab/typemaps.i
@@ -139,7 +139,7 @@ output values.
 %typemap(argout) signed char *OUTPUT(int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfInteger8(iVarOut, iRowsOut, iColsOut, &temp$argnum);
+  createMatrixOfInteger8(pvApiCtx, iVarOut, iRowsOut, iColsOut, &temp$argnum);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -147,7 +147,7 @@ output values.
               unsigned char *OUTPUT(int iRowsOut, int iColsOut) {
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfInteger16(iVarOut, iRowsOut, iColsOut, &temp$argnum);
+  createMatrixOfInteger16(pvApiCtx, iVarOut, iRowsOut, iColsOut, &temp$argnum);
   LhsVar(iOutNum) = iVarOut;
 }
 
@@ -158,7 +158,7 @@ output values.
               long *OUTPUT(int iRowsOut,int iColsOut) {
   iRowsOut=1; 
   iColsOut=1;
-  createMatrixOfInteger32(iVarOut, iRowsOut, iColsOut, &temp$argnum);
+  createMatrixOfInteger32(pvApiCtx, iVarOut, iRowsOut, iColsOut, &temp$argnum);
   LhsVar(iOutNum)=iVarOut;
 }
 
@@ -169,7 +169,7 @@ output values.
   temp = (double)(*$result);
   iRowsOut = 1; 
   iColsOut = 1;
-  createMatrixOfDouble(iVarOut, iRowsOut, iColsOut, &temp$argnum);
+  createMatrixOfDouble(pvApiCtx, iVarOut, iRowsOut, iColsOut, &temp$argnum);
   LhsVar(iOutNum) = iVarOut;
 }