jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

scilab: code style: remove underscore in parameters (first part)

Browse source
This commit is contained in:
Simon Marchetto 2014-07-09 18:32:52 +02:00
commit 540973ee1d
25 changed files with 465 additions and 468 deletions
Download patch file Download diff file Expand all files Collapse all files

46
Lib/scilab/scibool.swg
View file

@ -4,25 +4,25 @@
*/ */
%fragment(SWIG_AsVal_frag(bool), "header") { %fragment(SWIG_AsVal_frag(bool), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_AsVal_dec(bool)(SwigSciObject _iVar, bool *_pbValue) { SWIG_AsVal_dec(bool)(SwigSciObject iVar, bool *pbValue) {
SciErr sciErr; SciErr sciErr;
int iRet = 0; int iRet = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
int iTempValue = 0; int iTempValue = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
if (!isBooleanType(pvApiCtx, piAddrVar)) { if (!isBooleanType(pvApiCtx, piAddrVar)) {
Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), SWIG_Scilab_GetFname(), _iVar); Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), SWIG_Scilab_GetFname(), iVar);
return SWIG_ERROR; return SWIG_ERROR;
} }
if (!isScalar(pvApiCtx, piAddrVar)) { if (!isScalar(pvApiCtx, piAddrVar)) {
Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), SWIG_Scilab_GetFname(), _iVar); Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), SWIG_Scilab_GetFname(), iVar);
return SWIG_ERROR; return SWIG_ERROR;
} }
@ -31,7 +31,7 @@ SWIG_AsVal_dec(bool)(SwigSciObject _iVar, bool *_pbValue) {
return SWIG_ERROR; return SWIG_ERROR;
} }
*_pbValue = iTempValue; *pbValue = iTempValue;
return SWIG_OK; return SWIG_OK;
} }
@ -53,12 +53,12 @@ SWIG_From_dec(bool)(bool _bValue) {
*/ */
%fragment("SWIG_SciBoolean_AsBoolArrayAndSize", "header") { %fragment("SWIG_SciBoolean_AsBoolArrayAndSize", "header") {
SWIGINTERN int 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; SciErr sciErr;
int *piAddrVar = NULL; int *piAddrVar = NULL;
int *piValue = NULL; int *piValue = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -66,18 +66,18 @@ SWIG_SciBoolean_AsBoolArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows, int
if (isBooleanType(_pvApiCtx, piAddrVar)) { if (isBooleanType(_pvApiCtx, piAddrVar)) {
int i; int i;
sciErr = getMatrixOfBoolean(_pvApiCtx, piAddrVar, _iRows, _iCols, &piValue); sciErr = getMatrixOfBoolean(_pvApiCtx, piAddrVar, iRows, iCols, &piValue);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
*_pbValue = (bool*) malloc((*_iRows) * (*_iCols) * sizeof(bool)); *pbValue = (bool*) malloc((*iRows) * (*iCols) * sizeof(bool));
for (i = 0; i < (*_iRows) * (*_iCols); i++) for (i = 0; i < (*iRows) * (*iCols); i++)
(*_pbValue)[i] = piValue[i] != 0; (*pbValue)[i] = piValue[i] != 0;
} }
else { 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; return SWIG_ERROR;
} }
@ -87,16 +87,16 @@ SWIG_SciBoolean_AsBoolArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows, int
%fragment("SWIG_SciBoolean_FromBoolArrayAndSize", "header") { %fragment("SWIG_SciBoolean_FromBoolArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciBoolean_FromBoolArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, bool *_pbValue) { SWIG_SciBoolean_FromBoolArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, bool *pbValue) {
SciErr sciErr; SciErr sciErr;
int *piValue = NULL; int *piValue = NULL;
int i; int i;
piValue = (int*) malloc(_iRows * _iCols * sizeof(int)); piValue = (int*) malloc(iRows * iCols * sizeof(int));
for (i = 0; i < _iRows * _iCols; i++) for (i = 0; i < iRows * iCols; i++)
piValue[i] = _pbValue[i]; piValue[i] = pbValue[i];
sciErr = createMatrixOfBoolean(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _iRows, _iCols, piValue); sciErr = createMatrixOfBoolean(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, iRows, iCols, piValue);
if(sciErr.iErr) { if(sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
free(piValue); free(piValue);
@ -114,11 +114,11 @@ SWIG_SciBoolean_FromBoolArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows,
*/ */
%fragment("SWIG_SciBoolean_AsIntArrayAndSize", "header") { %fragment("SWIG_SciBoolean_AsIntArrayAndSize", "header") {
SWIGINTERN int 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; SciErr sciErr;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -126,14 +126,14 @@ SWIG_SciBoolean_AsIntArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows, int *
if (isBooleanType(_pvApiCtx, piAddrVar)) { if (isBooleanType(_pvApiCtx, piAddrVar)) {
int i; int i;
sciErr = getMatrixOfBoolean(_pvApiCtx, piAddrVar, _iRows, _iCols, _piValue); sciErr = getMatrixOfBoolean(_pvApiCtx, piAddrVar, iRows, iCols, piValue);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
} }
else { 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; return SWIG_ERROR;
} }
@ -143,10 +143,10 @@ SWIG_SciBoolean_AsIntArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows, int *
%fragment("SWIG_SciBoolean_FromIntArrayAndSize", "header") { %fragment("SWIG_SciBoolean_FromIntArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciBoolean_FromIntArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, int *_piValue) { SWIG_SciBoolean_FromIntArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, int *piValue) {
SciErr sciErr; SciErr sciErr;
sciErr = createMatrixOfBoolean(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _iRows, _iCols, _piValue); sciErr = createMatrixOfBoolean(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, iRows, iCols, piValue);
if(sciErr.iErr) { if(sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;

92
Lib/scilab/scichar.swg
View file

@ -12,16 +12,16 @@
} }
%fragment("SWIG_SciString_AsChar", "header") { %fragment("SWIG_SciString_AsChar", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciString_AsChar(void *_pvApiCtx, int _iVar, char *_pcValue, char *_fname) { SWIG_SciString_AsChar(void *_pvApiCtx, int iVar, char *pcValue, char *_fname) {
SciErr sciErr; SciErr sciErr;
int iType = 0; int iType = 0;
int iRows = 0; int iRows = 0;
int iCols = 0; int iCols = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
char *_pstStrings = NULL; char *pstStrings = NULL;
int _piLength = 0; int piLength = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -33,23 +33,23 @@ SWIG_SciString_AsChar(void *_pvApiCtx, int _iVar, char *_pcValue, char *_fname)
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iType != sci_strings) { if (iType != sci_strings) {
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), _fname, _iVar); Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), _fname, iVar);
return SWIG_ERROR; return SWIG_ERROR;
} }
_pstStrings = (char *)malloc(sizeof(char)); pstStrings = (char *)malloc(sizeof(char));
sciErr = getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols, &_piLength, (char **)&_pstStrings); sciErr = getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols, &piLength, (char **)&pstStrings);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { if (iRows * iCols != 1) {
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), _fname, _iVar); Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), _fname, iVar);
return SWIG_ERROR; return SWIG_ERROR;
} }
*_pcValue = _pstStrings[0]; *pcValue = pstStrings[0];
free(_pstStrings); free(pstStrings);
return SWIG_OK; return SWIG_OK;
} }
@ -60,12 +60,12 @@ SWIG_SciString_AsChar(void *_pvApiCtx, int _iVar, char *_pcValue, char *_fname)
} }
%fragment("SWIG_SciString_FromChar", "header") { %fragment("SWIG_SciString_FromChar", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciString_FromChar(void *_pvApiCtx, int _iVarOut, char _chValue) { SWIG_SciString_FromChar(void *_pvApiCtx, int iVarOut, char chValue) {
char *pchValue = (char*)malloc(sizeof(char) * 2); char *pchValue = (char*)malloc(sizeof(char) * 2);
pchValue[0] = _chValue; pchValue[0] = chValue;
pchValue[1] = '\0'; pchValue[1] = '\0';
if (createSingleString(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, pchValue)) if (createSingleString(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, pchValue))
return SWIG_ERROR; return SWIG_ERROR;
free(pchValue); free(pchValue);
@ -82,13 +82,13 @@ SWIG_SciString_FromChar(void *_pvApiCtx, int _iVarOut, char _chValue) {
} }
%fragment("SWIG_SciString_AsCharPtr", "header") { %fragment("SWIG_SciString_AsCharPtr", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciString_AsCharPtr(void *_pvApiCtx, int _iVar, char *_pcValue, int _iLength, char *_fname) { SWIG_SciString_AsCharPtr(void *_pvApiCtx, int iVar, char *pcValue, int iLength, char *_fname) {
SciErr sciErr; SciErr sciErr;
int *piAddrVar = NULL; int *piAddrVar = NULL;
char* pcTmpValue = NULL; char* pcTmpValue = NULL;
int iRet; int iRet;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -99,8 +99,8 @@ SWIG_SciString_AsCharPtr(void *_pvApiCtx, int _iVar, char *_pcValue, int _iLengt
return SWIG_ERROR; return SWIG_ERROR;
} }
if (_pcValue != NULL) { if (pcValue != NULL) {
strncpy(_pcValue, pcTmpValue, _iLength); strncpy(pcValue, pcTmpValue, iLength);
} }
free(pcTmpValue); free(pcTmpValue);
@ -114,13 +114,13 @@ SWIG_SciString_AsCharPtr(void *_pvApiCtx, int _iVar, char *_pcValue, int _iLengt
} }
%fragment("SWIG_SciString_AsCharPtrAndSize", "header") { %fragment("SWIG_SciString_AsCharPtrAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciString_AsCharPtrAndSize(void *_pvApiCtx, int _iVar, char **_pcValue, size_t *_piLength, int *alloc, char *_fname) { SWIG_SciString_AsCharPtrAndSize(void *_pvApiCtx, int iVar, char **pcValue, size_t *piLength, int *alloc, char *_fname) {
SciErr sciErr; SciErr sciErr;
int *piAddrVar = NULL; int *piAddrVar = NULL;
int iRet; int iRet;
char *pstStrings = NULL; char *pstStrings = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -131,18 +131,18 @@ SWIG_SciString_AsCharPtrAndSize(void *_pvApiCtx, int _iVar, char **_pcValue, siz
return SWIG_ERROR; return SWIG_ERROR;
} }
// TODO: return SWIG_ERROR if _pcValue NULL (now returning SWIG_ERROR fails some typechecks) // TODO: return SWIG_ERROR if pcValue NULL (now returning SWIG_ERROR fails some typechecks)
if (_pcValue) if (pcValue)
{ {
*_pcValue = pstStrings; *pcValue = pstStrings;
} }
if (alloc != NULL) { if (alloc != NULL) {
*alloc = SWIG_NEWOBJ; *alloc = SWIG_NEWOBJ;
} }
if (_piLength != NULL) { if (piLength != NULL) {
*_piLength = strlen(*_pcValue) + 1; *piLength = strlen(*pcValue) + 1;
} }
return SWIG_OK; return SWIG_OK;
@ -154,15 +154,15 @@ SWIG_SciString_AsCharPtrAndSize(void *_pvApiCtx, int _iVar, char **_pcValue, siz
} }
%fragment("SWIG_SciString_FromCharPtr", "header") { %fragment("SWIG_SciString_FromCharPtr", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciString_FromCharPtr(void *_pvApiCtx, int _iVarOut, const char *_pchValue) { SWIG_SciString_FromCharPtr(void *_pvApiCtx, int iVarOut, const char *pchValue) {
if (_pchValue) { if (pchValue) {
SciErr sciErr; SciErr sciErr;
char **pstData = NULL; char **pstData = NULL;
pstData = (char **)malloc(sizeof(char *)); pstData = (char **)malloc(sizeof(char *));
pstData[0] = strdup(_pchValue); pstData[0] = strdup(pchValue);
sciErr = createMatrixOfString(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, 1, 1, (char **)pstData); sciErr = createMatrixOfString(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, 1, 1, (char **)pstData);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -171,7 +171,7 @@ SWIG_SciString_FromCharPtr(void *_pvApiCtx, int _iVarOut, const char *_pchValue)
free(pstData[0]); free(pstData[0]);
} }
else { else {
int iRet = createEmptyMatrix(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut); int iRet = createEmptyMatrix(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut);
if (iRet) { if (iRet) {
return SWIG_ERROR; return SWIG_ERROR;
} }
@ -187,39 +187,39 @@ SWIG_SciString_FromCharPtr(void *_pvApiCtx, int _iVarOut, const char *_pchValue)
%fragment("SWIG_SciString_AsCharPtrArrayAndSize", "header") { %fragment("SWIG_SciString_AsCharPtrArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciString_AsCharPtrArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows, int *_iCols, char ***_charPtrArray, char *_fname) { SWIG_SciString_AsCharPtrArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, char ***charPtrArray, char *_fname) {
SciErr sciErr; SciErr sciErr;
int i = 0; int i = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
int* piLength = NULL; int* piLength = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
sciErr = getMatrixOfString(_pvApiCtx, piAddrVar, _iRows, _iCols, NULL, NULL); sciErr = getMatrixOfString(_pvApiCtx, piAddrVar, iRows, iCols, NULL, NULL);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
piLength = (int*) malloc((*_iRows) * (*_iCols) * sizeof(int)); piLength = (int*) malloc((*iRows) * (*iCols) * sizeof(int));
sciErr = getMatrixOfString(_pvApiCtx, piAddrVar, _iRows, _iCols, piLength, NULL); sciErr = getMatrixOfString(_pvApiCtx, piAddrVar, iRows, iCols, piLength, NULL);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
*_charPtrArray = (char**) malloc((*_iRows) * (*_iCols) * sizeof(char*)); *charPtrArray = (char**) malloc((*iRows) * (*iCols) * sizeof(char*));
for(i = 0 ; i < (*_iRows) * (*_iCols); i++) for(i = 0 ; i < (*iRows) * (*iCols); i++)
{ {
(*_charPtrArray)[i] = (char*) malloc(sizeof(char) * (piLength[i] + 1)); (*charPtrArray)[i] = (char*) malloc(sizeof(char) * (piLength[i] + 1));
} }
sciErr = getMatrixOfString(_pvApiCtx, piAddrVar, _iRows, _iCols, piLength, *_charPtrArray); sciErr = getMatrixOfString(_pvApiCtx, piAddrVar, iRows, iCols, piLength, *charPtrArray);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -232,10 +232,10 @@ SWIG_SciString_AsCharPtrArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows, in
%fragment("SWIG_SciString_FromCharPtrArrayAndSize", "header") { %fragment("SWIG_SciString_FromCharPtrArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciString_FromCharPtrArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, char **_charPtrArray) { SWIG_SciString_FromCharPtrArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, char **charPtrArray) {
SciErr sciErr; SciErr sciErr;
sciErr = createMatrixOfString(_pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + _iVarOut, _iRows, _iCols, _charPtrArray); sciErr = createMatrixOfString(_pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, charPtrArray);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -256,16 +256,16 @@ SWIG_SciString_FromCharPtrArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows
%fragment(SWIG_CreateScilabVariable_frag(char), "wrapper") { %fragment(SWIG_CreateScilabVariable_frag(char), "wrapper") {
SWIGINTERN int SWIGINTERN int
SWIG_CreateScilabVariable_dec(char)(void *_pvApiCtx, const char* _psVariableName, const char _cVariableValue) { SWIG_CreateScilabVariable_dec(char)(void *_pvApiCtx, const char* psVariableName, const char cVariableValue) {
SciErr sciErr; SciErr sciErr;
char sValue[2]; char sValue[2];
const char* psStrings[1]; const char* psStrings[1];
sValue[0] = _cVariableValue; sValue[0] = cVariableValue;
sValue[1] = '\0'; sValue[1] = '\0';
psStrings[0] = sValue; psStrings[0] = sValue;
sciErr = createNamedMatrixOfString(_pvApiCtx, _psVariableName, 1, 1, psStrings); sciErr = createNamedMatrixOfString(_pvApiCtx, psVariableName, 1, 1, psStrings);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -276,12 +276,12 @@ SWIG_CreateScilabVariable_dec(char)(void *_pvApiCtx, const char* _psVariableName
%fragment(SWIG_CreateScilabVariable_frag(charptr), "wrapper") { %fragment(SWIG_CreateScilabVariable_frag(charptr), "wrapper") {
SWIGINTERN int SWIGINTERN int
SWIG_CreateScilabVariable_dec(charptr)(void *_pvApiCtx, const char* _psVariableName, const char* _psVariableValue) { SWIG_CreateScilabVariable_dec(charptr)(void *_pvApiCtx, const char* psVariableName, const char* psVariableValue) {
SciErr sciErr; SciErr sciErr;
const char* psStrings[1]; const char* psStrings[1];
psStrings[0] = _psVariableValue; psStrings[0] = psVariableValue;
sciErr = createNamedMatrixOfString(_pvApiCtx, _psVariableName, 1, 1, psStrings); sciErr = createNamedMatrixOfString(_pvApiCtx, psVariableName, 1, 1, psStrings);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;

6
Lib/scilab/scicontainer.swg
View file

@ -52,7 +52,7 @@ namespace swig
SciSequence_Ref(const SwigSciObject& seq, int index) SciSequence_Ref(const SwigSciObject& seq, int index)
: _seq(seq), _index(index) : _seq(seq), _index(index)
{ {
if (traits_as_sequence<T>::get(_seq, &_piSeqAddr) != SWIG_OK) if (traits_as_sequence<T>::get(_seq, &piSeqAddr) != SWIG_OK)
{ {
throw std::invalid_argument("Cannot get sequence data."); throw std::invalid_argument("Cannot get sequence data.");
} }
@ -62,7 +62,7 @@ namespace swig
{ {
try try
{ {
return traits_asval_sequenceitem<T>::asval(_seq, _piSeqAddr, _index); return traits_asval_sequenceitem<T>::asval(_seq, piSeqAddr, _index);
} }
catch (std::exception& e) catch (std::exception& e)
{ {
@ -79,7 +79,7 @@ namespace swig
private: private:
SwigSciObject _seq; SwigSciObject _seq;
int _index; int _index;
void *_piSeqAddr; void *piSeqAddr;
}; };

30
Lib/scilab/scidouble.swg
View file

@ -6,28 +6,28 @@
} }
%fragment("SWIG_SciDouble_AsDouble", "header") { %fragment("SWIG_SciDouble_AsDouble", "header") {
SWIGINTERN int 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; SciErr sciErr;
int iRet = 0; int iRet = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
if (!isDoubleType(_pvApiCtx, piAddrVar) || isVarComplex(_pvApiCtx, piAddrVar)) { 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; return SWIG_ERROR;
} }
if (!isScalar(_pvApiCtx, piAddrVar)) { 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; return SWIG_ERROR;
} }
iRet = getScalarDouble(_pvApiCtx, piAddrVar, _pdblValue); iRet = getScalarDouble(_pvApiCtx, piAddrVar, pdblValue);
if (iRet) { if (iRet) {
return SWIG_ERROR; return SWIG_ERROR;
} }
@ -41,8 +41,8 @@ SWIG_SciDouble_AsDouble(void *_pvApiCtx, SwigSciObject _iVar, double *_pdblValue
} }
%fragment("SWIG_SciDouble_FromDouble", "header") { %fragment("SWIG_SciDouble_FromDouble", "header") {
SWIGINTERN int 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)) if (createScalarDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, dblValue))
return SWIG_ERROR; return SWIG_ERROR;
return SWIG_OK; return SWIG_OK;
} }
@ -54,25 +54,25 @@ SWIG_SciDouble_FromDouble(void *_pvApiCtx, int _iVarOut, double _dblValue, char
%fragment("SWIG_SciDouble_AsDoubleArrayAndSize", "header") { %fragment("SWIG_SciDouble_AsDoubleArrayAndSize", "header") {
SWIGINTERN int 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; SciErr sciErr;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
if (isDoubleType(_pvApiCtx, piAddrVar) && !isVarComplex(_pvApiCtx, piAddrVar)) { if (isDoubleType(_pvApiCtx, piAddrVar) && !isVarComplex(_pvApiCtx, piAddrVar)) {
sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, _iRows, _iCols, _pdValue); sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, iRows, iCols, pdValue);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
} }
else { 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; return SWIG_ERROR;
} }
@ -82,9 +82,9 @@ SWIG_SciDouble_AsDoubleArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows, int
%fragment("SWIG_SciDouble_FromDoubleArrayAndSize", "header") { %fragment("SWIG_SciDouble_FromDoubleArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciDouble_FromDoubleArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, double *_pdblValue) { SWIG_SciDouble_FromDoubleArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, double *pdblValue) {
SciErr sciErr; SciErr sciErr;
sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _iRows, _iCols, _pdblValue); sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, iRows, iCols, pdblValue);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -96,9 +96,9 @@ SWIG_SciDouble_FromDoubleArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows,
%fragment(SWIG_CreateScilabVariable_frag(double), "wrapper") { %fragment(SWIG_CreateScilabVariable_frag(double), "wrapper") {
SWIGINTERN int SWIGINTERN int
SWIG_CreateScilabVariable_dec(double)(void *_pvApiCtx, const char* _psVariableName, const double _dVariableValue) { SWIG_CreateScilabVariable_dec(double)(void *_pvApiCtx, const char* psVariableName, const double dVariableValue) {
SciErr sciErr; SciErr sciErr;
sciErr = createNamedMatrixOfDouble(_pvApiCtx, _psVariableName, 1, 1, &_dVariableValue); sciErr = createNamedMatrixOfDouble(_pvApiCtx, psVariableName, 1, 1, &dVariableValue);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;

12
Lib/scilab/scienum.swg
View file

@ -8,11 +8,11 @@
} }
%fragment("SWIG_Int_AsEnum", "header", fragment="SWIG_SciDoubleOrInt32_AsInt") { %fragment("SWIG_Int_AsEnum", "header", fragment="SWIG_SciDoubleOrInt32_AsInt") {
SWIGINTERN int 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; int iValue = 0;
if (SWIG_SciDoubleOrInt32_AsInt(_pvApiCtx, _iVar, &iValue, fname) != SWIG_OK) if (SWIG_SciDoubleOrInt32_AsInt(_pvApiCtx, iVar, &iValue, fname) != SWIG_OK)
return SWIG_ERROR; return SWIG_ERROR;
*_enumValue = iValue; *enumValue = iValue;
return SWIG_OK; return SWIG_OK;
} }
} }
@ -22,10 +22,10 @@ SWIG_Int_AsEnum(void *_pvApiCtx, int _iVar, int *_enumValue, char *_fname) {
} }
%fragment("SWIG_Int_FromEnum", "header", fragment="SWIG_SciDouble_FromInt") { %fragment("SWIG_Int_FromEnum", "header", fragment="SWIG_SciDouble_FromInt") {
SWIGINTERN int 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) if (SWIG_SciDouble_FromInt(_pvApiCtx, iVarOut, enumValue, fname) != SWIG_OK)
return SWIG_ERROR; return SWIG_ERROR;
SWIG_Scilab_SetOutput(_pvApiCtx, _iVarOut); SWIG_Scilab_SetOutput(_pvApiCtx, iVarOut);
return SWIG_OK; return SWIG_OK;
} }
} }

32
Lib/scilab/scifloat.swg
View file

@ -4,13 +4,13 @@
%fragment(SWIG_AsVal_frag(float), "header", fragment=SWIG_AsVal_frag(double)) { %fragment(SWIG_AsVal_frag(float), "header", fragment=SWIG_AsVal_frag(double)) {
SWIGINTERN int SWIGINTERN int
SWIG_AsVal_dec(float)(SwigSciObject _iVar, float *_pfValue) { SWIG_AsVal_dec(float)(SwigSciObject iVar, float *pfValue) {
double dblValue = 0.0; double dblValue = 0.0;
if(SWIG_AsVal_dec(double)(_iVar, &dblValue) != SWIG_OK) { if(SWIG_AsVal_dec(double)(iVar, &dblValue) != SWIG_OK) {
return SWIG_ERROR; return SWIG_ERROR;
} }
if (_pfValue) if (pfValue)
*_pfValue = (float) dblValue; *pfValue = (float) dblValue;
return SWIG_OK; return SWIG_OK;
} }
} }
@ -27,12 +27,12 @@ SWIG_From_dec(float)(float _flValue) {
%fragment("SWIG_SciDouble_AsFloatArrayAndSize", "header") { %fragment("SWIG_SciDouble_AsFloatArrayAndSize", "header") {
SWIGINTERN int 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; SciErr sciErr;
int *piAddrVar = NULL; int *piAddrVar = NULL;
double *pdValue = NULL; double *pdValue = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -41,20 +41,20 @@ SWIG_SciDouble_AsFloatArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows, int
if (isDoubleType(_pvApiCtx, piAddrVar) && !isVarComplex(_pvApiCtx, piAddrVar)) { if (isDoubleType(_pvApiCtx, piAddrVar) && !isVarComplex(_pvApiCtx, piAddrVar)) {
int i; int i;
sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, _iRows, _iCols, &pdValue); sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, iRows, iCols, &pdValue);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
*_pfValue = (float *) malloc((*_iRows) * (*_iCols) * sizeof(float)); *pfValue = (float *) malloc((*iRows) * (*iCols) * sizeof(float));
for (i=0; i < (*_iRows) * (*_iCols); i++) for (i=0; i < (*iRows) * (*iCols); i++)
(*_pfValue)[i] = (float) pdValue[i]; (*pfValue)[i] = (float) pdValue[i];
return SWIG_OK; return SWIG_OK;
} }
else { 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; return SWIG_ERROR;
} }
} }
@ -62,16 +62,16 @@ SWIG_SciDouble_AsFloatArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows, int
%fragment("SWIG_SciDouble_FromFloatArrayAndSize", "header") { %fragment("SWIG_SciDouble_FromFloatArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciDouble_FromFloatArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, float *_pfValue) { SWIG_SciDouble_FromFloatArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, float *pfValue) {
SciErr sciErr; SciErr sciErr;
double *pdValue; double *pdValue;
int i; int i;
pdValue = (double *) malloc(_iRows * _iCols * sizeof(double)); pdValue = (double *) malloc(iRows * iCols * sizeof(double));
for (i = 0; i < _iRows * _iCols; i++) for (i = 0; i < iRows * iCols; i++)
pdValue[i] = _pfValue[i]; pdValue[i] = pfValue[i];
sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _iRows, _iCols, pdValue); sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, iRows, iCols, pdValue);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;

60
Lib/scilab/sciint.swg
View file

@ -8,7 +8,7 @@
} }
%fragment("SWIG_SciDoubleOrInt32_AsInt", "header") { %fragment("SWIG_SciDoubleOrInt32_AsInt", "header") {
SWIGINTERN int 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; SciErr sciErr;
int iType = 0; int iType = 0;
@ -16,7 +16,7 @@ SWIG_SciDoubleOrInt32_AsInt(void *_pvApiCtx, SwigSciObject _iVar, int *_piValue,
int iCols = 0; int iCols = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -29,7 +29,7 @@ SWIG_SciDoubleOrInt32_AsInt(void *_pvApiCtx, SwigSciObject _iVar, int *_piValue,
} }
if (iType == sci_ints) { if (iType == sci_ints) {
if (_piValue) { if (piValue) {
int iPrec = 0; int iPrec = 0;
int *piData = NULL; int *piData = NULL;
@ -39,7 +39,7 @@ SWIG_SciDoubleOrInt32_AsInt(void *_pvApiCtx, SwigSciObject _iVar, int *_piValue,
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iPrec != SCI_INT32) { 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; return SWIG_TypeError;
} }
sciErr = getMatrixOfInteger32(_pvApiCtx, piAddrVar, &iRows, &iCols, &piData); sciErr = getMatrixOfInteger32(_pvApiCtx, piAddrVar, &iRows, &iCols, &piData);
@ -48,14 +48,14 @@ SWIG_SciDoubleOrInt32_AsInt(void *_pvApiCtx, SwigSciObject _iVar, int *_piValue,
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { 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; return SWIG_TypeError;
} }
*_piValue = *piData; *piValue = *piData;
} }
} }
else if (iType == sci_matrix) { else if (iType == sci_matrix) {
if (_piValue) { if (piValue) {
double *pdData = NULL; double *pdData = NULL;
double dValue = 0.0f; double dValue = 0.0f;
sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, &iRows, &iCols, &pdData); sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, &iRows, &iCols, &pdData);
@ -64,23 +64,23 @@ SWIG_SciDoubleOrInt32_AsInt(void *_pvApiCtx, SwigSciObject _iVar, int *_piValue,
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { 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; return SWIG_TypeError;
} }
dValue = *pdData; dValue = *pdData;
if (dValue != floor(dValue)) { 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; return SWIG_ValueError;
} }
if ((dValue < INT_MIN) || (dValue > INT_MAX)) { 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; return SWIG_OverflowError;
} }
*_piValue = (int) dValue; *piValue = (int) dValue;
} }
} }
else { 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; return SWIG_TypeError;
} }
@ -93,9 +93,9 @@ SWIG_SciDoubleOrInt32_AsInt(void *_pvApiCtx, SwigSciObject _iVar, int *_piValue,
} }
%fragment("SWIG_SciDouble_FromInt", "header") { %fragment("SWIG_SciDouble_FromInt", "header") {
SWIGINTERN int 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) if (createScalarDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx)
+ _iVarOut, (double) _iValue)) + iVarOut, (double) iValue))
return SWIG_ERROR; return SWIG_ERROR;
return SWIG_OK; return SWIG_OK;
} }
@ -107,12 +107,12 @@ SWIG_SciDouble_FromInt(void *_pvApiCtx, int _iVarOut, int _iValue, char *_fname)
*/ */
%fragment("SWIG_SciDoubleOrInt32_AsIntArrayAndSize", "header") { %fragment("SWIG_SciDoubleOrInt32_AsIntArrayAndSize", "header") {
SWIGINTERN int 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; SciErr sciErr;
int iType = 0; int iType = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
@ -131,17 +131,17 @@ SWIG_SciDoubleOrInt32_AsIntArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows,
int size = 0; int size = 0;
int i; int i;
sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, _iRows, _iCols, &pdData); sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, iRows, iCols, &pdData);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
size = (*_iRows) * (*_iCols); size = (*iRows) * (*iCols);
*_piValue = (int*) malloc(size * sizeof(int*)); *piValue = (int*) malloc(size * sizeof(int*));
for (i = 0; i < size; i++) for (i = 0; i < size; i++)
(*_piValue)[i] = (int) pdData[i]; (*piValue)[i] = (int) pdData[i];
} }
else if (iType == sci_ints) else if (iType == sci_ints)
{ {
@ -154,10 +154,10 @@ SWIG_SciDoubleOrInt32_AsIntArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows,
} }
if (iPrec != SCI_INT32) 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; return SWIG_ERROR;
} }
sciErr = getMatrixOfInteger32(_pvApiCtx, piAddrVar, _iRows, _iCols, _piValue); sciErr = getMatrixOfInteger32(_pvApiCtx, piAddrVar, iRows, iCols, piValue);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
@ -166,7 +166,7 @@ SWIG_SciDoubleOrInt32_AsIntArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows,
} }
else 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_ERROR;
} }
return SWIG_OK; return SWIG_OK;
@ -175,16 +175,16 @@ SWIG_SciDoubleOrInt32_AsIntArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows,
%fragment("SWIG_SciDouble_FromIntArrayAndSize", "header") { %fragment("SWIG_SciDouble_FromIntArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciDouble_FromIntArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, const int *_piData) { SWIG_SciDouble_FromIntArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, const int *piData) {
SciErr sciErr; SciErr sciErr;
double *pdValues = NULL; double *pdValues = NULL;
int i; int i;
pdValues = (double*) malloc(_iRows * _iCols * sizeof(double)); pdValues = (double*) malloc(iRows * iCols * sizeof(double));
for (i=0; i<_iRows * _iCols; i++) for (i=0; i<iRows * iCols; i++)
pdValues[i] = _piData[i]; pdValues[i] = piData[i];
sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _iRows, _iCols, pdValues); sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, iRows, iCols, pdValues);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
free(pdValues); free(pdValues);
@ -198,9 +198,9 @@ SWIG_SciDouble_FromIntArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, in
%fragment(SWIG_CreateScilabVariable_frag(int), "wrapper") { %fragment(SWIG_CreateScilabVariable_frag(int), "wrapper") {
SWIGINTERN int SWIGINTERN int
SWIG_CreateScilabVariable_dec(int)(void *_pvApiCtx, const char* _psVariableName, const int _iVariableValue) { SWIG_CreateScilabVariable_dec(int)(void *_pvApiCtx, const char* psVariableName, const int iVariableValue) {
SciErr sciErr; SciErr sciErr;
sciErr = createNamedMatrixOfInteger32(_pvApiCtx, _psVariableName, 1, 1, &_iVariableValue); sciErr = createNamedMatrixOfInteger32(_pvApiCtx, psVariableName, 1, 1, &iVariableValue);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;

22
Lib/scilab/scilist.swg
View file

@ -6,11 +6,11 @@
%fragment("SWIG_ScilabList", "header") %fragment("SWIG_ScilabList", "header")
{ {
SWIGINTERN int SWIGINTERN int
SWIG_GetScilabList(SwigSciObject _obj, int **_piListAddr) SWIG_GetScilabList(SwigSciObject obj, int **piListAddr)
{ {
SciErr sciErr; SciErr sciErr;
sciErr = getVarAddressFromPosition(pvApiCtx, _obj, _piListAddr); sciErr = getVarAddressFromPosition(pvApiCtx, obj, piListAddr);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
@ -21,19 +21,19 @@ SWIG_GetScilabList(SwigSciObject _obj, int **_piListAddr)
} }
SWIGINTERN int SWIGINTERN int
SWIG_GetScilabListSize(SwigSciObject _obj, int *_piListSize) SWIG_GetScilabListSize(SwigSciObject obj, int *piListSize)
{ {
SciErr sciErr; SciErr sciErr;
int *piListAddr; int *piListAddr;
sciErr = getVarAddressFromPosition(pvApiCtx, _obj, &piListAddr); sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piListAddr);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
sciErr = getListItemNumber(pvApiCtx, piListAddr, _piListSize); sciErr = getListItemNumber(pvApiCtx, piListAddr, piListSize);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
@ -44,18 +44,18 @@ SWIG_GetScilabListSize(SwigSciObject _obj, int *_piListSize)
} }
SWIGINTERN int SWIGINTERN int
SWIG_GetScilabListAndSize(SwigSciObject _obj, int **_piListAddr, int *_piListSize) SWIG_GetScilabListAndSize(SwigSciObject obj, int **piListAddr, int *piListSize)
{ {
SciErr sciErr; SciErr sciErr;
sciErr = getVarAddressFromPosition(pvApiCtx, _obj, _piListAddr); sciErr = getVarAddressFromPosition(pvApiCtx, obj, piListAddr);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
sciErr = getListItemNumber(pvApiCtx, *_piListAddr, _piListSize); sciErr = getListItemNumber(pvApiCtx, *piListAddr, piListSize);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
@ -66,13 +66,13 @@ SWIG_GetScilabListAndSize(SwigSciObject _obj, int **_piListAddr, int *_piListSiz
} }
SWIGINTERN int SWIGINTERN int
SWIG_CheckScilabList(SwigSciObject _obj) SWIG_CheckScilabList(SwigSciObject obj)
{ {
SciErr sciErr; SciErr sciErr;
int *piListAddr; int *piListAddr;
int iType; int iType;
sciErr = getVarAddressFromPosition(pvApiCtx, _obj, &piListAddr); sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piListAddr);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
@ -88,7 +88,7 @@ SWIG_CheckScilabList(SwigSciObject _obj)
if ((iType != sci_list) && (iType != sci_tlist) && (iType != sci_mlist)) if ((iType != sci_list) && (iType != sci_tlist) && (iType != sci_mlist))
{ {
Scierror(999, _("%s: Wrong type for input argument #%d: A list is expected.\n"), fname, _obj); Scierror(999, _("%s: Wrong type for input argument #%d: A list is expected.\n"), fname, obj);
return SWIG_ERROR; return SWIG_ERROR;
} }

34
Lib/scilab/scilong.swg
View file

@ -8,14 +8,14 @@
} }
%fragment("SWIG_SciDoubleOrInt32_AsLong", "header") { %fragment("SWIG_SciDoubleOrInt32_AsLong", "header") {
SWIGINTERN int 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; SciErr sciErr;
int iType = 0; int iType = 0;
int iRows = 0; int iRows = 0;
int iCols = 0; int iCols = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -37,7 +37,7 @@ SWIG_SciDoubleOrInt32_AsLong(void *_pvApiCtx, SwigSciObject _iVar, long *_plValu
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iPrec != SCI_INT32) { 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; return SWIG_TypeError;
} }
sciErr = getMatrixOfInteger32(_pvApiCtx, piAddrVar, &iRows, &iCols, &piData); sciErr = getMatrixOfInteger32(_pvApiCtx, piAddrVar, &iRows, &iCols, &piData);
@ -46,10 +46,10 @@ SWIG_SciDoubleOrInt32_AsLong(void *_pvApiCtx, SwigSciObject _iVar, long *_plValu
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { 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; return SWIG_TypeError;
} }
*_plValue = (long) *piData; *plValue = (long) *piData;
} }
else if (iType == sci_matrix) { else if (iType == sci_matrix) {
double *pdData = NULL; double *pdData = NULL;
@ -61,22 +61,22 @@ SWIG_SciDoubleOrInt32_AsLong(void *_pvApiCtx, SwigSciObject _iVar, long *_plValu
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { 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; return SWIG_TypeError;
} }
dValue = *pdData; dValue = *pdData;
if (dValue != floor(dValue)) { 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; return SWIG_ValueError;
} }
if ((dValue < LONG_MIN) || (dValue > LONG_MAX)) { 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; return SWIG_OverflowError;
} }
*_plValue = (long) dValue; *plValue = (long) dValue;
} }
else { 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; return SWIG_TypeError;
} }
@ -89,9 +89,9 @@ SWIG_SciDoubleOrInt32_AsLong(void *_pvApiCtx, SwigSciObject _iVar, long *_plValu
} }
%fragment("SWIG_SciDouble_FromLong", "header") { %fragment("SWIG_SciDouble_FromLong", "header") {
SWIGINTERN int 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, if (createScalarDouble(_pvApiCtx,
SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, (double) _lValue)) SWIG_NbInputArgument(_pvApiCtx) + iVarOut, (double) lValue))
return SWIG_ERROR; return SWIG_ERROR;
return SWIG_OK; return SWIG_OK;
} }
@ -100,17 +100,17 @@ SWIG_SciDouble_FromLong(void *_pvApiCtx, int _iVarOut, long _lValue, char *_fnam
%fragment("SWIG_SciDouble_FromLongArrayAndSize", "header") { %fragment("SWIG_SciDouble_FromLongArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciDouble_FromLongArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, const long *_plData) { SWIG_SciDouble_FromLongArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, const long *plData) {
SciErr sciErr; SciErr sciErr;
int i; int i;
double *pdValues = NULL; double *pdValues = NULL;
pdValues = (double*) malloc(_iRows * _iCols * sizeof(double)); pdValues = (double*) malloc(iRows * iCols * sizeof(double));
for (i=0; i<_iRows * _iCols; i++) { for (i=0; i<iRows * iCols; i++) {
pdValues[i] = _plData[i]; pdValues[i] = plData[i];
} }
sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _iRows, _iCols, pdValues); sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, iRows, iCols, pdValues);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
free(pdValues); free(pdValues);

8
Lib/scilab/scilonglong.swg
View file

@ -8,7 +8,7 @@
} }
%fragment("SWIG_SciInt64_ToLongLong", "header") { %fragment("SWIG_SciInt64_ToLongLong", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciInt64_ToLongLong(void *_pvApiCtx, int _iVar, long long *_pllValue, char *_fname) { SWIG_SciInt64_ToLongLong(void *_pvApiCtx, int iVar, long long *pllValue, char *_fname) {
Scierror(999, _("%s: Scilab 5.X does not manage '%s' data type.\n"), "SWIG_SciInt64_ToLongLong", "int64"); Scierror(999, _("%s: Scilab 5.X does not manage '%s' data type.\n"), "SWIG_SciInt64_ToLongLong", "int64");
return SWIG_ERROR; return SWIG_ERROR;
} }
@ -19,7 +19,7 @@ SWIG_SciInt64_ToLongLong(void *_pvApiCtx, int _iVar, long long *_pllValue, char
} }
%fragment("SWIG_SciInt64_FromLongLong", "header") { %fragment("SWIG_SciInt64_FromLongLong", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciInt64_FromLongLong(void *_pvApiCtx, int _iVarOut, long long _llValue) { SWIG_SciInt64_FromLongLong(void *_pvApiCtx, int iVarOut, long long llValue) {
Scierror(999, _("%s: Scilab 5.X does not manage '%s' data type.\n"), "SWIG_SciInt64_ToLongLong", "int64"); Scierror(999, _("%s: Scilab 5.X does not manage '%s' data type.\n"), "SWIG_SciInt64_ToLongLong", "int64");
return SWIG_ERROR; return SWIG_ERROR;
} }
@ -35,7 +35,7 @@ SWIG_SciInt64_FromLongLong(void *_pvApiCtx, int _iVarOut, long long _llValue) {
} }
%fragment("SWIG_SciUint64_ToUnsignedLongLong", "header") { %fragment("SWIG_SciUint64_ToUnsignedLongLong", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciUint64_ToUnsignedLongLong(void *_pvApiCtx, int _iVar, unsigned long long *_pullValue, char *_fname) { SWIG_SciUint64_ToUnsignedLongLong(void *_pvApiCtx, int iVar, unsigned long long *pullValue, char *_fname) {
Scierror(999, _("%s: Scilab 5.X does not manage '%s' data type.\n"), "SWIG_SciUint64_ToLongLong", "uint64"); Scierror(999, _("%s: Scilab 5.X does not manage '%s' data type.\n"), "SWIG_SciUint64_ToLongLong", "uint64");
return SWIG_ERROR; return SWIG_ERROR;
} }
@ -46,7 +46,7 @@ SWIG_SciUint64_ToUnsignedLongLong(void *_pvApiCtx, int _iVar, unsigned long long
} }
%fragment("SWIG_SciUint64_FromUnsignedLongLong", "header") { %fragment("SWIG_SciUint64_FromUnsignedLongLong", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciUint64_FromUnsignedLongLong(void *_pvApiCtx, int _iVarOut, unsigned long long _llValue) { SWIG_SciUint64_FromUnsignedLongLong(void *_pvApiCtx, int iVarOut, unsigned long long llValue) {
Scierror(999, _("%s: Scilab 5.X does not manage '%s' data type.\n"), "SWIG_SciUint64_ToLongLong", "uint64"); Scierror(999, _("%s: Scilab 5.X does not manage '%s' data type.\n"), "SWIG_SciUint64_ToLongLong", "uint64");
return SWIG_ERROR; return SWIG_ERROR;
} }

24
Lib/scilab/scimisctypes.swg
View file

@ -11,13 +11,13 @@
%fragment("SWIG_Int_AsSize", "header", fragment=SWIG_AsVal_frag(int)) %fragment("SWIG_Int_AsSize", "header", fragment=SWIG_AsVal_frag(int))
{ {
SWIGINTERN 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; int iValue = 0;
if (SWIG_AsVal_dec(int)(_iVar, &iValue) != SWIG_OK) if (SWIG_AsVal_dec(int)(iVar, &iValue) != SWIG_OK)
return SWIG_ERROR; return SWIG_ERROR;
if (_piValue) if (piValue)
*_piValue = (size_t) iValue; *piValue = (size_t) iValue;
return SWIG_OK; return SWIG_OK;
} }
@ -29,8 +29,8 @@ SWIG_Int_AsSize(void *_pvApiCtx, SwigSciObject _iVar, size_t *_piValue, char *_f
%fragment("SWIG_Int_FromSize", "header", fragment=SWIG_From_frag(int)) %fragment("SWIG_Int_FromSize", "header", fragment=SWIG_From_frag(int))
{ {
SWIGINTERN 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); return SWIG_From_dec(int)((int)iValue);
} }
} }
@ -45,13 +45,13 @@ SWIG_Int_FromSize(void *_pvApiCtx, int _iVarOut, size_t _iValue, char *_fname) {
%fragment("SWIG_Int_AsPtrDiff", "header", fragment=SWIG_AsVal_frag(int)) %fragment("SWIG_Int_AsPtrDiff", "header", fragment=SWIG_AsVal_frag(int))
{ {
SWIGINTERN 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; int iValue = 0;
if (SWIG_AsVal_dec(int)(_iVar, &iValue) != SWIG_OK) if (SWIG_AsVal_dec(int)(iVar, &iValue) != SWIG_OK)
return SWIG_ERROR; return SWIG_ERROR;
if (_piValue) if (piValue)
*_piValue = (ptrdiff_t) iValue; *piValue = (ptrdiff_t) iValue;
return SWIG_OK; return SWIG_OK;
} }
@ -62,8 +62,8 @@ SWIG_Int_AsPtrDiff(void *_pvApiCtx, SwigSciObject _iVar, ptrdiff_t *_piValue, ch
} }
%fragment("SWIG_Int_FromPtrDiff", "header", fragment=SWIG_From_frag(int)) { %fragment("SWIG_Int_FromPtrDiff", "header", fragment=SWIG_From_frag(int)) {
SWIGINTERN 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); return SWIG_From_dec(int)((int)iValue);
} }
} }

16
Lib/scilab/scirun.swg
View file

@ -101,12 +101,12 @@ SWIG_Scilab_SetOutput(void *_pvApiCtx, SwigSciObject _output) {
/* Pointer conversion functions */ /* Pointer conversion functions */
SWIGINTERN int SWIGINTERN int
SwigScilabPtrToObject(void *_pvApiCtx, int _iVar, void **_pObjValue, swig_type_info *_descriptor, int _flags, char *_fname) { SwigScilabPtrToObject(void *_pvApiCtx, int iVar, void **_pObjValue, swig_type_info *_descriptor, int _flags, char *_fname) {
SciErr sciErr; SciErr sciErr;
int iType = 0; int iType = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -133,10 +133,10 @@ SwigScilabPtrToObject(void *_pvApiCtx, int _iVar, void **_pObjValue, swig_type_i
} }
SWIGRUNTIMEINLINE int SWIGRUNTIMEINLINE int
SwigScilabPtrFromObject(void *_pvApiCtx, int _iVarOut, void *_object, swig_type_info *_descriptor, int _flags) { SwigScilabPtrFromObject(void *_pvApiCtx, int iVarOut, void *obj, swig_type_info *_descriptor, int _flags) {
SciErr sciErr; SciErr sciErr;
sciErr = createPointer(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, (void *)_object); sciErr = createPointer(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, (void *)obj);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -146,13 +146,13 @@ SwigScilabPtrFromObject(void *_pvApiCtx, int _iVarOut, void *_object, swig_type_
} }
SWIGRUNTIME int SWIGRUNTIME int
SWIG_Scilab_ConvertPacked(void *_pvApiCtx, int _iVar, void *_ptr, int sz, swig_type_info *ty, char *_fname) { SWIG_Scilab_ConvertPacked(void *_pvApiCtx, int iVar, void *_ptr, int sz, swig_type_info *ty, char *_fname) {
swig_cast_info *tc; swig_cast_info *tc;
int *piAddrVar = NULL; int *piAddrVar = NULL;
char *pstStrings = NULL; char *pstStrings = NULL;
SciErr sciErr; SciErr sciErr;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -183,7 +183,7 @@ SWIG_Scilab_ConvertPacked(void *_pvApiCtx, int _iVar, void *_ptr, int sz, swig_t
} }
SWIGRUNTIME int SWIGRUNTIME int
SWIG_Scilab_NewMemberObj(void *_pvApiCtx, int _iVarOut, void *_ptr, int _sz, swig_type_info *_type) { SWIG_Scilab_NewMemberObj(void *_pvApiCtx, int iVarOut, void *_ptr, int _sz, swig_type_info *_type) {
char result[1024]; char result[1024];
char *r = result; char *r = result;
@ -194,7 +194,7 @@ SWIG_Scilab_NewMemberObj(void *_pvApiCtx, int _iVarOut, void *_ptr, int _sz, swi
r = SWIG_PackData(r, _ptr, _sz); r = SWIG_PackData(r, _ptr, _sz);
strcpy(r, _type->name); strcpy(r, _type->name);
if (createSingleString(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, &result[0])) if (createSingleString(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, &result[0]))
return SWIG_ERROR; return SWIG_ERROR;
return SWIG_OK; return SWIG_OK;

38
Lib/scilab/scisequencebool.swg
View file

@ -9,11 +9,11 @@
%fragment(SWIG_AsCheck_Sequence_frag(bool), "header") { %fragment(SWIG_AsCheck_Sequence_frag(bool), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_AsCheck_Sequence_dec(bool)(SwigSciObject _obj) { SWIG_AsCheck_Sequence_dec(bool)(SwigSciObject obj) {
SciErr sciErr; SciErr sciErr;
int *piAddrVar; int *piAddrVar;
sciErr = getVarAddressFromPosition(pvApiCtx, _obj, &piAddrVar); sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -25,7 +25,7 @@ SWIG_AsCheck_Sequence_dec(bool)(SwigSciObject _obj) {
} }
else else
{ {
Scierror(999, _("%s: Wrong type for input argument #%d: A boolean is expected.\n"), SWIG_Scilab_GetFname(), _obj); Scierror(999, _("%s: Wrong type for input argument #%d: A boolean is expected.\n"), SWIG_Scilab_GetFname(), obj);
return SWIG_ERROR; return SWIG_ERROR;
} }
} }
@ -35,10 +35,10 @@ SWIG_AsCheck_Sequence_dec(bool)(SwigSciObject _obj) {
fragment="SWIG_SciBoolean_AsIntArrayAndSize") { fragment="SWIG_SciBoolean_AsIntArrayAndSize") {
SWIGINTERN int SWIGINTERN int
SWIG_AsGet_Sequence_dec(bool)(SwigSciObject _obj, int **_pSequence) { SWIG_AsGet_Sequence_dec(bool)(SwigSciObject obj, int **pSequence) {
int iMatrixRowCount; int iMatrixRowCount;
int iMatrixColCount; int iMatrixColCount;
return (SWIG_SciBoolean_AsIntArrayAndSize(pvApiCtx, _obj, &iMatrixRowCount, &iMatrixColCount, _pSequence, SWIG_Scilab_GetFname())); return (SWIG_SciBoolean_AsIntArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, pSequence, SWIG_Scilab_GetFname()));
} }
} }
@ -46,16 +46,16 @@ SWIG_AsGet_Sequence_dec(bool)(SwigSciObject _obj, int **_pSequence) {
fragment="SWIG_SciBoolean_AsIntArrayAndSize") { fragment="SWIG_SciBoolean_AsIntArrayAndSize") {
SWIGINTERN int SWIGINTERN int
SWIG_AsSize_Sequence_dec(bool)(SwigSciObject _obj, int *_piSize) { SWIG_AsSize_Sequence_dec(bool)(SwigSciObject obj, int *piSize) {
int *piMatrix; int *piMatrix;
int iMatrixRowCount; int iMatrixRowCount;
int iMatrixColCount; int iMatrixColCount;
if (SWIG_SciBoolean_AsIntArrayAndSize(pvApiCtx, _obj, &iMatrixRowCount, &iMatrixColCount, &piMatrix, SWIG_Scilab_GetFname()) == SWIG_OK) { if (SWIG_SciBoolean_AsIntArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, &piMatrix, SWIG_Scilab_GetFname()) == SWIG_OK) {
if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) { if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) {
Scierror(999, _("%s: Wrong size for input argument #%d: An integer vector is expected.\n"), SWIG_Scilab_GetFname(), _obj); Scierror(999, _("%s: Wrong size for input argument #%d: An integer vector is expected.\n"), SWIG_Scilab_GetFname(), obj);
return SWIG_ERROR; return SWIG_ERROR;
} }
*_piSize = iMatrixRowCount * iMatrixColCount; *piSize = iMatrixRowCount * iMatrixColCount;
return SWIG_OK; return SWIG_OK;
} }
return SWIG_ERROR; return SWIG_ERROR;
@ -65,9 +65,9 @@ SWIG_AsSize_Sequence_dec(bool)(SwigSciObject _obj, int *_piSize) {
%fragment(SWIG_FromCreate_Sequence_frag(bool), "header") { %fragment(SWIG_FromCreate_Sequence_frag(bool), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_FromCreate_Sequence_dec(bool)(int _size, int **_sequence) { SWIG_FromCreate_Sequence_dec(bool)(int size, int **pSequence) {
*_sequence = new int[_size]; *pSequence = new int[size];
return *_sequence != NULL ? SWIG_OK : SWIG_ERROR; return *pSequence != NULL ? SWIG_OK : SWIG_ERROR;
} }
} }
@ -75,9 +75,9 @@ SWIG_FromCreate_Sequence_dec(bool)(int _size, int **_sequence) {
fragment="SWIG_SciBoolean_FromIntArrayAndSize") { fragment="SWIG_SciBoolean_FromIntArrayAndSize") {
SWIGINTERN SwigSciObject SWIGINTERN SwigSciObject
SWIG_FromSet_Sequence_dec(bool)(int _size, int *_sequence) { SWIG_FromSet_Sequence_dec(bool)(int size, int *pSequence) {
SwigSciObject obj = SWIG_SciBoolean_FromIntArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, _size, _sequence); SwigSciObject obj = SWIG_SciBoolean_FromIntArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, size, pSequence);
delete (int *)_sequence; delete (int *)pSequence;
return obj; return obj;
} }
} }
@ -85,16 +85,16 @@ SWIG_FromSet_Sequence_dec(bool)(int _size, int *_sequence) {
%fragment(SWIG_AsVal_SequenceItem_frag(bool), "header") { %fragment(SWIG_AsVal_SequenceItem_frag(bool), "header") {
SWIGINTERN bool SWIGINTERN bool
SWIG_AsVal_SequenceItem_dec(bool)(SwigSciObject _obj, int *_pSequence, int _iItemIndex) { SWIG_AsVal_SequenceItem_dec(bool)(SwigSciObject obj, int *pSequence, int iItemIndex) {
return _pSequence[_iItemIndex]; return pSequence[iItemIndex];
} }
} }
%fragment(SWIG_From_SequenceItem_frag(bool), "header") { %fragment(SWIG_From_SequenceItem_frag(bool), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_From_SequenceItem_dec(bool)(int *_pSequence, int _iItemIndex, bool _itemValue) { SWIG_From_SequenceItem_dec(bool)(int *pSequence, int iItemIndex, bool itemValue) {
_pSequence[_iItemIndex] = _itemValue; pSequence[iItemIndex] = itemValue;
return SWIG_OK; return SWIG_OK;
} }
} }

38
Lib/scilab/scisequencedouble.swg
View file

@ -9,11 +9,11 @@
%fragment(SWIG_AsCheck_Sequence_frag(double), "header") { %fragment(SWIG_AsCheck_Sequence_frag(double), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_AsCheck_Sequence_dec(double)(SwigSciObject _obj) { SWIG_AsCheck_Sequence_dec(double)(SwigSciObject obj) {
SciErr sciErr; SciErr sciErr;
int *piAddrVar; int *piAddrVar;
sciErr = getVarAddressFromPosition(pvApiCtx, _obj, &piAddrVar); sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -25,7 +25,7 @@ SWIG_AsCheck_Sequence_dec(double)(SwigSciObject _obj) {
} }
else else
{ {
Scierror(999, _("%s: Wrong type for input argument #%d: A double is expected.\n"), SWIG_Scilab_GetFname(), _obj); Scierror(999, _("%s: Wrong type for input argument #%d: A double is expected.\n"), SWIG_Scilab_GetFname(), obj);
return SWIG_ERROR; return SWIG_ERROR;
} }
} }
@ -35,10 +35,10 @@ SWIG_AsCheck_Sequence_dec(double)(SwigSciObject _obj) {
fragment="SWIG_SciDouble_AsDoubleArrayAndSize") { fragment="SWIG_SciDouble_AsDoubleArrayAndSize") {
SWIGINTERN int SWIGINTERN int
SWIG_AsGet_Sequence_dec(double)(SwigSciObject _obj, double **_pSequence) { SWIG_AsGet_Sequence_dec(double)(SwigSciObject obj, double **pSequence) {
int iMatrixRowCount; int iMatrixRowCount;
int iMatrixColCount; int iMatrixColCount;
return (SWIG_SciDouble_AsDoubleArrayAndSize(pvApiCtx, _obj, &iMatrixRowCount, &iMatrixColCount, _pSequence, SWIG_Scilab_GetFname())); return (SWIG_SciDouble_AsDoubleArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, pSequence, SWIG_Scilab_GetFname()));
} }
} }
@ -46,16 +46,16 @@ SWIG_AsGet_Sequence_dec(double)(SwigSciObject _obj, double **_pSequence) {
fragment="SWIG_SciDouble_AsDoubleArrayAndSize") { fragment="SWIG_SciDouble_AsDoubleArrayAndSize") {
SWIGINTERN int SWIGINTERN int
SWIG_AsSize_Sequence_dec(double)(SwigSciObject _obj, int *_piSize) { SWIG_AsSize_Sequence_dec(double)(SwigSciObject obj, int *piSize) {
double *pdblMatrix; double *pdblMatrix;
int iMatrixRowCount; int iMatrixRowCount;
int iMatrixColCount; int iMatrixColCount;
if (SWIG_SciDouble_AsDoubleArrayAndSize(pvApiCtx, _obj, &iMatrixRowCount, &iMatrixColCount, &pdblMatrix, SWIG_Scilab_GetFname()) == SWIG_OK) { if (SWIG_SciDouble_AsDoubleArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, &pdblMatrix, SWIG_Scilab_GetFname()) == SWIG_OK) {
if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) { if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) {
Scierror(999, _("%s: Wrong size for input argument #%d: A double vector is expected.\n"), SWIG_Scilab_GetFname(), _obj); Scierror(999, _("%s: Wrong size for input argument #%d: A double vector is expected.\n"), SWIG_Scilab_GetFname(), obj);
return SWIG_ERROR; return SWIG_ERROR;
} }
*_piSize = iMatrixRowCount * iMatrixColCount; *piSize = iMatrixRowCount * iMatrixColCount;
return SWIG_OK; return SWIG_OK;
} }
return SWIG_ERROR; return SWIG_ERROR;
@ -65,9 +65,9 @@ SWIG_AsSize_Sequence_dec(double)(SwigSciObject _obj, int *_piSize) {
%fragment(SWIG_FromCreate_Sequence_frag(double), "header") { %fragment(SWIG_FromCreate_Sequence_frag(double), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_FromCreate_Sequence_dec(double)(int _size, double **_sequence) { SWIG_FromCreate_Sequence_dec(double)(int size, double **pSequence) {
*_sequence = new double[_size]; *pSequence = new double[size];
return *_sequence != NULL ? SWIG_OK : SWIG_ERROR; return *pSequence != NULL ? SWIG_OK : SWIG_ERROR;
} }
} }
@ -75,9 +75,9 @@ SWIG_FromCreate_Sequence_dec(double)(int _size, double **_sequence) {
fragment="SWIG_SciDouble_FromDoubleArrayAndSize") { fragment="SWIG_SciDouble_FromDoubleArrayAndSize") {
SWIGINTERN SwigSciObject SWIGINTERN SwigSciObject
SWIG_FromSet_Sequence_dec(double)(int _size, double *_sequence) { SWIG_FromSet_Sequence_dec(double)(int size, double *pSequence) {
SwigSciObject obj = SWIG_SciDouble_FromDoubleArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, _size, _sequence); SwigSciObject obj = SWIG_SciDouble_FromDoubleArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, size, pSequence);
delete (double *)_sequence; delete (double *)pSequence;
return obj; return obj;
} }
} }
@ -85,16 +85,16 @@ SWIG_FromSet_Sequence_dec(double)(int _size, double *_sequence) {
%fragment(SWIG_AsVal_SequenceItem_frag(double), "header") { %fragment(SWIG_AsVal_SequenceItem_frag(double), "header") {
SWIGINTERN double SWIGINTERN double
SWIG_AsVal_SequenceItem_dec(double)(SwigSciObject _obj, double *_pSequence, int _iItemIndex) { SWIG_AsVal_SequenceItem_dec(double)(SwigSciObject obj, double *pSequence, int iItemIndex) {
return _pSequence[_iItemIndex]; return pSequence[iItemIndex];
} }
} }
%fragment(SWIG_From_SequenceItem_frag(double), "header") { %fragment(SWIG_From_SequenceItem_frag(double), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_From_SequenceItem_dec(double)(double *_pSequence, int _iItemIndex, double _itemValue) { SWIG_From_SequenceItem_dec(double)(double *pSequence, int iItemIndex, double itemValue) {
_pSequence[_iItemIndex] = _itemValue; pSequence[iItemIndex] = itemValue;
return SWIG_OK; return SWIG_OK;
} }
} }

40
Lib/scilab/scisequencefloat.swg
View file

@ -9,11 +9,11 @@
%fragment(SWIG_AsCheck_Sequence_frag(float), "header") { %fragment(SWIG_AsCheck_Sequence_frag(float), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_AsCheck_Sequence_dec(float)(SwigSciObject _obj) { SWIG_AsCheck_Sequence_dec(float)(SwigSciObject obj) {
SciErr sciErr; SciErr sciErr;
int *piAddrVar; int *piAddrVar;
sciErr = getVarAddressFromPosition(pvApiCtx, _obj, &piAddrVar); sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -25,7 +25,7 @@ SWIG_AsCheck_Sequence_dec(float)(SwigSciObject _obj) {
} }
else else
{ {
Scierror(999, _("%s: Wrong type for input argument #%d: A double is expected.\n"), SWIG_Scilab_GetFname(), _obj); Scierror(999, _("%s: Wrong type for input argument #%d: A double is expected.\n"), SWIG_Scilab_GetFname(), obj);
return SWIG_ERROR; return SWIG_ERROR;
} }
} }
@ -35,11 +35,10 @@ SWIG_AsCheck_Sequence_dec(float)(SwigSciObject _obj) {
fragment="SWIG_SciDouble_AsFloatArrayAndSize") { fragment="SWIG_SciDouble_AsFloatArrayAndSize") {
SWIGINTERN int SWIGINTERN int
SWIG_AsGet_Sequence_dec(float)(SwigSciObject _obj, float **_pSequence) { SWIG_AsGet_Sequence_dec(float)(SwigSciObject obj, float **pSequence) {
int iMatrixRowCount; int iMatrixRowCount;
int iMatrixColCount; int iMatrixColCount;
return (SWIG_SciDouble_AsFloatArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, pSequence, SWIG_Scilab_GetFname()));
return (SWIG_SciDouble_AsFloatArrayAndSize(pvApiCtx, _obj, &iMatrixRowCount, &iMatrixColCount, _pSequence, SWIG_Scilab_GetFname()));
} }
} }
@ -47,16 +46,16 @@ SWIG_AsGet_Sequence_dec(float)(SwigSciObject _obj, float **_pSequence) {
fragment="SWIG_SciDouble_AsFloatArrayAndSize") { fragment="SWIG_SciDouble_AsFloatArrayAndSize") {
SWIGINTERN int SWIGINTERN int
SWIG_AsSize_Sequence_dec(float)(SwigSciObject _obj, int *_piSize) { SWIG_AsSize_Sequence_dec(float)(SwigSciObject obj, int *piSize) {
float *pdblMatrix; float *pdblMatrix;
int iMatrixRowCount; int iMatrixRowCount;
int iMatrixColCount; int iMatrixColCount;
if (SWIG_SciDouble_AsFloatArrayAndSize(pvApiCtx, _obj, &iMatrixRowCount, &iMatrixColCount, &pdblMatrix, SWIG_Scilab_GetFname()) == SWIG_OK) { if (SWIG_SciDouble_AsFloatArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, &pdblMatrix, SWIG_Scilab_GetFname()) == SWIG_OK) {
if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) { if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) {
Scierror(999, _("%s: Wrong size for input argument #%d: A float vector is expected.\n"), SWIG_Scilab_GetFname(), _obj); Scierror(999, _("%s: Wrong size for input argument #%d: A float vector is expected.\n"), SWIG_Scilab_GetFname(), obj);
return SWIG_ERROR; return SWIG_ERROR;
} }
*_piSize = iMatrixRowCount * iMatrixColCount; *piSize = iMatrixRowCount * iMatrixColCount;
return SWIG_OK; return SWIG_OK;
} }
return SWIG_ERROR; return SWIG_ERROR;
@ -66,9 +65,9 @@ SWIG_AsSize_Sequence_dec(float)(SwigSciObject _obj, int *_piSize) {
%fragment(SWIG_FromCreate_Sequence_frag(float), "header") { %fragment(SWIG_FromCreate_Sequence_frag(float), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_FromCreate_Sequence_dec(float)(int _size, float **_sequence) { SWIG_FromCreate_Sequence_dec(float)(int size, float **pSequence) {
*_sequence = new float[_size]; *pSequence = new float[size];
return *_sequence != NULL ? SWIG_OK : SWIG_ERROR; return *pSequence != NULL ? SWIG_OK : SWIG_ERROR;
} }
} }
@ -76,9 +75,9 @@ SWIG_FromCreate_Sequence_dec(float)(int _size, float **_sequence) {
fragment="SWIG_SciDouble_FromFloatArrayAndSize") { fragment="SWIG_SciDouble_FromFloatArrayAndSize") {
SWIGINTERN SwigSciObject SWIGINTERN SwigSciObject
SWIG_FromSet_Sequence_dec(float)(int _size, float *_sequence) { SWIG_FromSet_Sequence_dec(float)(int size, float *pSequence) {
SwigSciObject obj = SWIG_SciDouble_FromFloatArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, _size, _sequence); SwigSciObject obj = SWIG_SciDouble_FromFloatArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, size, pSequence);
delete (float *)_sequence; delete (float *)pSequence;
return obj; return obj;
} }
} }
@ -86,16 +85,15 @@ SWIG_FromSet_Sequence_dec(float)(int _size, float *_sequence) {
%fragment(SWIG_AsVal_SequenceItem_frag(float), "header") { %fragment(SWIG_AsVal_SequenceItem_frag(float), "header") {
SWIGINTERN float SWIGINTERN float
SWIG_AsVal_SequenceItem_dec(float)(SwigSciObject _obj, float *_pSequence, int _iItemIndex) { SWIG_AsVal_SequenceItem_dec(float)(SwigSciObject obj, float *pSequence, int iItemIndex) {
return _pSequence[_iItemIndex]; return pSequence[iItemIndex];
} }
} }
%fragment(SWIG_From_SequenceItem_frag(float), "header") { %fragment(SWIG_From_SequenceItem_frag(float), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_From_SequenceItem_dec(float)(float *_pSequence, int _iItemIndex, float _itemValue) { SWIG_From_SequenceItem_dec(float)(float *pSequence, int iItemIndex, float itemValue) {
_pSequence[_iItemIndex] = _itemValue; pSequence[iItemIndex] = itemValue;
return SWIG_OK; return SWIG_OK;
} }
} }

38
Lib/scilab/scisequenceint.swg
View file

@ -9,12 +9,12 @@
%fragment(SWIG_AsCheck_Sequence_frag(int), "header") { %fragment(SWIG_AsCheck_Sequence_frag(int), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_AsCheck_Sequence_dec(int)(SwigSciObject _obj) { SWIG_AsCheck_Sequence_dec(int)(SwigSciObject obj) {
SciErr sciErr; SciErr sciErr;
int *piAddrVar; int *piAddrVar;
int iType = 0; int iType = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, _obj, &piAddrVar); sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -32,7 +32,7 @@ SWIG_AsCheck_Sequence_dec(int)(SwigSciObject _obj) {
} }
else else
{ {
Scierror(999, _("%s: Wrong type for input argument #%d: An integer is expected.\n"), SWIG_Scilab_GetFname(), _obj); Scierror(999, _("%s: Wrong type for input argument #%d: An integer is expected.\n"), SWIG_Scilab_GetFname(), obj);
return SWIG_ERROR; return SWIG_ERROR;
} }
} }
@ -41,10 +41,10 @@ SWIG_AsCheck_Sequence_dec(int)(SwigSciObject _obj) {
%fragment(SWIG_AsGet_Sequence_frag(int), "header", %fragment(SWIG_AsGet_Sequence_frag(int), "header",
fragment="SWIG_SciDoubleOrInt32_AsIntArrayAndSize") { fragment="SWIG_SciDoubleOrInt32_AsIntArrayAndSize") {
SWIGINTERN int SWIGINTERN int
SWIG_AsGet_Sequence_dec(int)(SwigSciObject _obj, int **_pSequence) { SWIG_AsGet_Sequence_dec(int)(SwigSciObject obj, int **pSequence) {
int iMatrixRowCount; int iMatrixRowCount;
int iMatrixColCount; int iMatrixColCount;
return (SWIG_SciDoubleOrInt32_AsIntArrayAndSize(pvApiCtx, _obj, &iMatrixRowCount, &iMatrixColCount, _pSequence, SWIG_Scilab_GetFname())); return (SWIG_SciDoubleOrInt32_AsIntArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, pSequence, SWIG_Scilab_GetFname()));
} }
} }
@ -52,16 +52,16 @@ SWIG_AsGet_Sequence_dec(int)(SwigSciObject _obj, int **_pSequence) {
fragment="SWIG_SciDoubleOrInt32_AsIntArrayAndSize") { fragment="SWIG_SciDoubleOrInt32_AsIntArrayAndSize") {
SWIGINTERN int SWIGINTERN int
SWIG_AsSize_Sequence_dec(int)(SwigSciObject _obj, int *_piSize) { SWIG_AsSize_Sequence_dec(int)(SwigSciObject obj, int *piSize) {
int *piMatrix; int *piMatrix;
int iMatrixRowCount; int iMatrixRowCount;
int iMatrixColCount; int iMatrixColCount;
if (SWIG_SciDoubleOrInt32_AsIntArrayAndSize(pvApiCtx, _obj, &iMatrixRowCount, &iMatrixColCount, &piMatrix, SWIG_Scilab_GetFname()) == SWIG_OK) { if (SWIG_SciDoubleOrInt32_AsIntArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, &piMatrix, SWIG_Scilab_GetFname()) == SWIG_OK) {
if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) { if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) {
Scierror(999, _("%s: Wrong size for input argument #%d: An integer vector is expected.\n"), SWIG_Scilab_GetFname(), _obj); Scierror(999, _("%s: Wrong size for input argument #%d: An integer vector is expected.\n"), SWIG_Scilab_GetFname(), obj);
return SWIG_ERROR; return SWIG_ERROR;
} }
*_piSize = iMatrixRowCount * iMatrixColCount; *piSize = iMatrixRowCount * iMatrixColCount;
return SWIG_OK; return SWIG_OK;
} }
return SWIG_ERROR; return SWIG_ERROR;
@ -71,9 +71,9 @@ SWIG_AsSize_Sequence_dec(int)(SwigSciObject _obj, int *_piSize) {
%fragment(SWIG_FromCreate_Sequence_frag(int), "header") { %fragment(SWIG_FromCreate_Sequence_frag(int), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_FromCreate_Sequence_dec(int)(int _size, int **_sequence) { SWIG_FromCreate_Sequence_dec(int)(int size, int **pSequence) {
*_sequence = new int[_size]; *pSequence = new int[size];
return *_sequence != NULL ? SWIG_OK : SWIG_ERROR; return *pSequence != NULL ? SWIG_OK : SWIG_ERROR;
} }
} }
@ -81,9 +81,9 @@ SWIG_FromCreate_Sequence_dec(int)(int _size, int **_sequence) {
fragment="SWIG_SciDouble_FromIntArrayAndSize") { fragment="SWIG_SciDouble_FromIntArrayAndSize") {
SWIGINTERN SwigSciObject SWIGINTERN SwigSciObject
SWIG_FromSet_Sequence_dec(int)(int _size, int *_sequence) { SWIG_FromSet_Sequence_dec(int)(int size, int *pSequence) {
SwigSciObject obj = SWIG_SciDouble_FromIntArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, _size, _sequence); SwigSciObject obj = SWIG_SciDouble_FromIntArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, size, pSequence);
delete (int *)_sequence; delete (int *)pSequence;
return obj; return obj;
} }
} }
@ -91,16 +91,16 @@ SWIG_FromSet_Sequence_dec(int)(int _size, int *_sequence) {
%fragment(SWIG_AsVal_SequenceItem_frag(int), "header") { %fragment(SWIG_AsVal_SequenceItem_frag(int), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_AsVal_SequenceItem_dec(int)(SwigSciObject _obj, int *_pSequence, int _iItemIndex) { SWIG_AsVal_SequenceItem_dec(int)(SwigSciObject obj, int *pSequence, int iItemIndex) {
return _pSequence[_iItemIndex]; return pSequence[iItemIndex];
} }
} }
%fragment(SWIG_From_SequenceItem_frag(int), "header") { %fragment(SWIG_From_SequenceItem_frag(int), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_From_SequenceItem_dec(int)(int *_pSequence, int _iItemIndex, int _itemValue) { SWIG_From_SequenceItem_dec(int)(int *pSequence, int iItemIndex, int itemValue) {
_pSequence[_iItemIndex] = _itemValue; pSequence[iItemIndex] = itemValue;
return SWIG_OK; return SWIG_OK;
} }
} }

40
Lib/scilab/scisequencepointer.swg
View file

@ -14,8 +14,8 @@
fragment="SWIG_ScilabList") { fragment="SWIG_ScilabList") {
SWIGINTERN int SWIGINTERN int
SWIG_AsCheck_Sequence_dec(ptr)(SwigSciObject _obj) { SWIG_AsCheck_Sequence_dec(ptr)(SwigSciObject obj) {
return SWIG_CheckScilabList(_obj); return SWIG_CheckScilabList(obj);
} }
} }
@ -23,8 +23,8 @@ SWIG_AsCheck_Sequence_dec(ptr)(SwigSciObject _obj) {
fragment="SWIG_ScilabList") { fragment="SWIG_ScilabList") {
SWIGINTERN int SWIGINTERN int
SWIG_AsGet_Sequence_dec(ptr)(SwigSciObject _obj, int **_piSequence) { SWIG_AsGet_Sequence_dec(ptr)(SwigSciObject obj, int **piSequence) {
return SWIG_GetScilabList(_obj, _piSequence); return SWIG_GetScilabList(obj, piSequence);
} }
} }
@ -32,8 +32,8 @@ SWIG_AsGet_Sequence_dec(ptr)(SwigSciObject _obj, int **_piSequence) {
fragment="SWIG_ScilabList") { fragment="SWIG_ScilabList") {
SWIGINTERN int SWIGINTERN int
SWIG_AsSize_Sequence_dec(ptr)(SwigSciObject _obj, int *_piSize) { SWIG_AsSize_Sequence_dec(ptr)(SwigSciObject obj, int *piSize) {
return SWIG_GetScilabListSize(_obj, _piSize); return SWIG_GetScilabListSize(obj, piSize);
} }
} }
@ -41,9 +41,9 @@ SWIG_AsSize_Sequence_dec(ptr)(SwigSciObject _obj, int *_piSize) {
fragment="<stdint.h>") { fragment="<stdint.h>") {
SWIGINTERN int SWIGINTERN int
SWIG_FromCreate_Sequence_dec(ptr)(int _size, uintptr_t **_sequence) { SWIG_FromCreate_Sequence_dec(ptr)(int size, uintptr_t **pSequence) {
*_sequence = new uintptr_t[_size]; *pSequence = new uintptr_t[size];
return *_sequence != NULL ? SWIG_OK : SWIG_ERROR; return *pSequence != NULL ? SWIG_OK : SWIG_ERROR;
} }
} }
@ -51,29 +51,29 @@ SWIG_FromCreate_Sequence_dec(ptr)(int _size, uintptr_t **_sequence) {
fragment="<stdint.h>") { fragment="<stdint.h>") {
SWIGINTERN SwigSciObject SWIGINTERN SwigSciObject
SWIG_FromSet_Sequence_dec(ptr)(int _size, uintptr_t *_sequence) { SWIG_FromSet_Sequence_dec(ptr)(int size, uintptr_t *pSequence) {
SciErr sciErr; SciErr sciErr;
int *piListAddr; int *piListAddr;
int iVarOut = SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition(); int iVarOut = SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition();
sciErr = createList(pvApiCtx, iVarOut, _size, &piListAddr); sciErr = createList(pvApiCtx, iVarOut, size, &piListAddr);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
for (int i=0; i<_size; i++) for (int i=0; i<size; i++)
{ {
sciErr = createPointerInList(pvApiCtx, iVarOut, piListAddr, i + 1, (void *)_sequence[i]); sciErr = createPointerInList(pvApiCtx, iVarOut, piListAddr, i + 1, (void *)pSequence[i]);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
} }
delete (int*)_sequence; delete (int*)pSequence;
return SWIG_OK; return SWIG_OK;
} }
} }
@ -81,14 +81,14 @@ SWIG_FromSet_Sequence_dec(ptr)(int _size, uintptr_t *_sequence) {
%fragment(SWIG_AsVal_SequenceItem_frag(ptr), "header") { %fragment(SWIG_AsVal_SequenceItem_frag(ptr), "header") {
SWIGINTERN void* SWIGINTERN void*
SWIG_AsVal_SequenceItem_dec(ptr)(SwigSciObject _obj, int *_piSequence, int _itemIndex) SWIG_AsVal_SequenceItem_dec(ptr)(SwigSciObject obj, int *piSequence, int itemIndex)
{ {
SciErr sciErr; SciErr sciErr;
int *piItemAddr; int *piItemAddr;
int iType; int iType;
void* pItemValue = NULL; void* pItemValue = NULL;
sciErr = getListItemAddress(pvApiCtx, _piSequence, _itemIndex + 1, &piItemAddr); sciErr = getListItemAddress(pvApiCtx, piSequence, itemIndex + 1, &piItemAddr);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
@ -104,11 +104,11 @@ SWIG_AsVal_SequenceItem_dec(ptr)(SwigSciObject _obj, int *_piSequence, int _item
if (iType != sci_pointer) if (iType != sci_pointer)
{ {
Scierror(999, _("%s: Wrong type for input argument #%d: A pointer is expected at list item #%d.\n"), fname, _obj, _itemIndex + 1); Scierror(999, _("%s: Wrong type for input argument #%d: A pointer is expected at list item #%d.\n"), fname, obj, itemIndex + 1);
return NULL; return NULL;
} }
sciErr = getPointerInList(pvApiCtx, _piSequence, _itemIndex + 1, &pItemValue); sciErr = getPointerInList(pvApiCtx, piSequence, itemIndex + 1, &pItemValue);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
@ -123,8 +123,8 @@ SWIG_AsVal_SequenceItem_dec(ptr)(SwigSciObject _obj, int *_piSequence, int _item
fragment="<stdint.h>") { fragment="<stdint.h>") {
SWIGINTERN int SWIGINTERN int
SWIG_From_SequenceItem_dec(ptr)(uintptr_t *_pSequence, int _iItemIndex, uintptr_t _itemValue) { SWIG_From_SequenceItem_dec(ptr)(uintptr_t *pSequence, int iItemIndex, uintptr_t itemValue) {
_pSequence[_iItemIndex] = _itemValue; pSequence[iItemIndex] = itemValue;
return SWIG_OK; return SWIG_OK;
} }
} }

40
Lib/scilab/scisequencestring.swg
View file

@ -9,11 +9,11 @@
%fragment(SWIG_AsCheck_Sequence_frag(std::string), "header") { %fragment(SWIG_AsCheck_Sequence_frag(std::string), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_AsCheck_Sequence_dec(std::string)(SwigSciObject _obj) { SWIG_AsCheck_Sequence_dec(std::string)(SwigSciObject obj) {
SciErr sciErr; SciErr sciErr;
int *piAddrVar; int *piAddrVar;
sciErr = getVarAddressFromPosition(pvApiCtx, _obj, &piAddrVar); sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -25,7 +25,7 @@ SWIG_AsCheck_Sequence_dec(std::string)(SwigSciObject _obj) {
} }
else else
{ {
Scierror(999, _("%s: Wrong type for input argument #%d: A string is expected.\n"), SWIG_Scilab_GetFname(), _obj); Scierror(999, _("%s: Wrong type for input argument #%d: A string is expected.\n"), SWIG_Scilab_GetFname(), obj);
return SWIG_ERROR; return SWIG_ERROR;
} }
} }
@ -35,10 +35,10 @@ SWIG_AsCheck_Sequence_dec(std::string)(SwigSciObject _obj) {
fragment="SWIG_SciString_AsCharPtrArrayAndSize") { fragment="SWIG_SciString_AsCharPtrArrayAndSize") {
SWIGINTERN int SWIGINTERN int
SWIG_AsGet_Sequence_dec(std::string)(SwigSciObject _obj, char ***_pSequence) { SWIG_AsGet_Sequence_dec(std::string)(SwigSciObject obj, char ***pSequence) {
int iRows = 0; int iRows = 0;
int iCols = 0; int iCols = 0;
return (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, _obj, &iRows, &iCols, _pSequence, SWIG_Scilab_GetFname())); return (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, obj, &iRows, &iCols, pSequence, SWIG_Scilab_GetFname()));
} }
} }
@ -46,12 +46,12 @@ SWIG_AsGet_Sequence_dec(std::string)(SwigSciObject _obj, char ***_pSequence) {
fragment="SWIG_SciString_AsCharPtrArrayAndSize") { fragment="SWIG_SciString_AsCharPtrArrayAndSize") {
SWIGINTERN int SWIGINTERN int
SWIG_AsSize_Sequence_dec(std::string)(SwigSciObject _obj, int *_piSize) { SWIG_AsSize_Sequence_dec(std::string)(SwigSciObject obj, int *piSize) {
char **pstMatrix; char **pstMatrix;
int iCols = 0; int iCols = 0;
int iRows = 0; int iRows = 0;
if (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, _obj, &iRows, &iCols, &pstMatrix, SWIG_Scilab_GetFname()) == SWIG_OK) { if (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, obj, &iRows, &iCols, &pstMatrix, SWIG_Scilab_GetFname()) == SWIG_OK) {
*_piSize = iRows * iCols; *piSize = iRows * iCols;
return SWIG_OK; return SWIG_OK;
} }
return SWIG_ERROR; return SWIG_ERROR;
@ -61,9 +61,9 @@ SWIG_AsSize_Sequence_dec(std::string)(SwigSciObject _obj, int *_piSize) {
%fragment(SWIG_FromCreate_Sequence_frag(std::string), "header") { %fragment(SWIG_FromCreate_Sequence_frag(std::string), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_FromCreate_Sequence_dec(std::string)(int _size, char ***_sequence) { SWIG_FromCreate_Sequence_dec(std::string)(int size, char ***pSequence) {
*_sequence = new char*[_size]; *pSequence = new char*[size];
return *_sequence != NULL ? SWIG_OK : SWIG_ERROR; return *pSequence != NULL ? SWIG_OK : SWIG_ERROR;
} }
} }
@ -71,9 +71,9 @@ SWIG_FromCreate_Sequence_dec(std::string)(int _size, char ***_sequence) {
fragment="SWIG_SciString_FromCharPtrArrayAndSize") { fragment="SWIG_SciString_FromCharPtrArrayAndSize") {
SWIGINTERN SwigSciObject SWIGINTERN SwigSciObject
SWIG_FromSet_Sequence_dec(std::string)(int _size, char **_sequence) { SWIG_FromSet_Sequence_dec(std::string)(int size, char **pSequence) {
SwigSciObject obj = SWIG_SciString_FromCharPtrArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, _size, _sequence); SwigSciObject obj = SWIG_SciString_FromCharPtrArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, size, pSequence);
delete (char **)_sequence; delete (char **)pSequence;
return obj; return obj;
} }
} }
@ -81,18 +81,18 @@ SWIG_FromSet_Sequence_dec(std::string)(int _size, char **_sequence) {
%fragment(SWIG_AsVal_SequenceItem_frag(std::string), "header") { %fragment(SWIG_AsVal_SequenceItem_frag(std::string), "header") {
SWIGINTERN std::string SWIGINTERN std::string
SWIG_AsVal_SequenceItem_dec(std::string)(SwigSciObject _obj, char **_pSequence, int _iItemIndex) { SWIG_AsVal_SequenceItem_dec(std::string)(SwigSciObject obj, char **pSequence, int iItemIndex) {
return std::string(_pSequence[_iItemIndex]); return std::string(pSequence[iItemIndex]);
} }
} }
%fragment(SWIG_From_SequenceItem_frag(std::string), "header") { %fragment(SWIG_From_SequenceItem_frag(std::string), "header") {
SWIGINTERN int SWIGINTERN int
SWIG_From_SequenceItem_dec(std::string)(char **_pSequence, int _iItemIndex, std::string _itemValue) { SWIG_From_SequenceItem_dec(std::string)(char **pSequence, int iItemIndex, std::string itemValue) {
char *pChar = new char(_itemValue.size() + 1); char *pChar = new char(itemValue.size() + 1);
strcpy(pChar, _itemValue.c_str()); strcpy(pChar, itemValue.c_str());
_pSequence[_iItemIndex] = pChar; pSequence[iItemIndex] = pChar;
return SWIG_OK; return SWIG_OK;
} }
} }

52
Lib/scilab/scishort.swg
View file

@ -8,14 +8,14 @@
} }
%fragment("SWIG_SciDoubleOrInt16_AsShort", "header") { %fragment("SWIG_SciDoubleOrInt16_AsShort", "header") {
SWIGINTERN int 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; SciErr sciErr;
int iType = 0; int iType = 0;
int iRows = 0; int iRows = 0;
int iCols = 0; int iCols = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -37,7 +37,7 @@ SWIG_SciDoubleOrInt16_AsShort(void *_pvApiCtx, int _iVar, short *_psValue, char
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iPrec != SCI_INT16) { 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; return SWIG_TypeError;
} }
sciErr = getMatrixOfInteger16(_pvApiCtx, piAddrVar, &iRows, &iCols, &psData); sciErr = getMatrixOfInteger16(_pvApiCtx, piAddrVar, &iRows, &iCols, &psData);
@ -46,10 +46,10 @@ SWIG_SciDoubleOrInt16_AsShort(void *_pvApiCtx, int _iVar, short *_psValue, char
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { 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; return SWIG_TypeError;
} }
*_psValue = *psData; *psValue = *psData;
} }
else if (iType == sci_matrix) { else if (iType == sci_matrix) {
double *pdData = NULL; double *pdData = NULL;
@ -61,22 +61,22 @@ SWIG_SciDoubleOrInt16_AsShort(void *_pvApiCtx, int _iVar, short *_psValue, char
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { 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; return SWIG_TypeError;
} }
dValue = *pdData; dValue = *pdData;
if (dValue != floor(dValue)) { 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; return SWIG_ValueError;
} }
if ((dValue < SHRT_MIN) || (dValue > SHRT_MAX)) { 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; return SWIG_OverflowError;
} }
*_psValue = (short) dValue; *psValue = (short) dValue;
} }
else { 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; return SWIG_TypeError;
} }
@ -89,9 +89,9 @@ SWIG_SciDoubleOrInt16_AsShort(void *_pvApiCtx, int _iVar, short *_psValue, char
} }
%fragment("SWIG_SciDouble_FromShort", "header") { %fragment("SWIG_SciDouble_FromShort", "header") {
SWIGINTERN int 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, if (createScalarDouble(_pvApiCtx,
SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, (double) _sValue)) SWIG_NbInputArgument(_pvApiCtx) + iVarOut, (double) sValue))
return SWIG_ERROR; return SWIG_ERROR;
return SWIG_OK; return SWIG_OK;
} }
@ -103,13 +103,13 @@ SWIG_SciDouble_FromShort(void *_pvApiCtx, int _iVarOut, short _sValue, char *_fn
*/ */
%fragment("SWIG_SciDoubleOrInt16_AsShortArrayAndSize", "header") { %fragment("SWIG_SciDoubleOrInt16_AsShortArrayAndSize", "header") {
SWIGINTERN int 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; SciErr sciErr;
int iType = 0; int iType = 0;
int iPrec = 0; int iPrec = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -127,17 +127,17 @@ SWIG_SciDoubleOrInt16_AsShortArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRow
int size = 0; int size = 0;
int i; int i;
sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, _iRows, _iCols, &pdData); sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, iRows, iCols, &pdData);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
size = (*_iRows) * (*_iCols); size = (*iRows) * (*iCols);
*_psValue = (short*) malloc(size * sizeof(int*)); *psValue = (short*) malloc(size * sizeof(int*));
for (i = 0; i < size; i++) for (i = 0; i < size; i++)
(*_psValue)[i] = (short) pdData[i]; (*psValue)[i] = (short) pdData[i];
} }
else if (iType == sci_ints) else if (iType == sci_ints)
{ {
@ -149,11 +149,11 @@ SWIG_SciDoubleOrInt16_AsShortArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRow
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iPrec != SCI_INT16) { 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; return SWIG_ERROR;
} }
sciErr = getMatrixOfInteger16(_pvApiCtx, piAddrVar, _iRows, _iCols, _psValue); sciErr = getMatrixOfInteger16(_pvApiCtx, piAddrVar, iRows, iCols, psValue);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -161,7 +161,7 @@ SWIG_SciDoubleOrInt16_AsShortArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRow
} }
else 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; return SWIG_ERROR;
} }
@ -170,16 +170,16 @@ SWIG_SciDoubleOrInt16_AsShortArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRow
} }
%fragment("SWIG_SciDouble_FromShortArrayAndSize", "header") { %fragment("SWIG_SciDouble_FromShortArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciDouble_FromShortArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, short *_psValue) { SWIG_SciDouble_FromShortArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, short *psValue) {
SciErr sciErr; SciErr sciErr;
int i; int i;
double *pdValues = NULL; double *pdValues = NULL;
pdValues = (double*) malloc(_iRows * _iCols * sizeof(double)); pdValues = (double*) malloc(iRows * iCols * sizeof(double));
for (i=0; i<_iRows * _iCols; i++) for (i=0; i<iRows * iCols; i++)
pdValues[i] = _psValue[i]; pdValues[i] = psValue[i];
sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _iRows, _iCols, pdValues); sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, iRows, iCols, pdValues);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
free(pdValues); free(pdValues);

54
Lib/scilab/scisignedchar.swg
View file

@ -7,7 +7,7 @@
} }
%fragment("SWIG_SciDoubleOrInt8_AsShort", "header") { %fragment("SWIG_SciDoubleOrInt8_AsShort", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciDoubleOrInt8_AsShort(void *_pvApiCtx, int _iVar, signed char *_pscValue, char *_fname) { SWIG_SciDoubleOrInt8_AsShort(void *_pvApiCtx, int iVar, signed char *pscValue, char *_fname) {
SciErr sciErr; SciErr sciErr;
int iType = 0; int iType = 0;
int iRows = 0; int iRows = 0;
@ -15,7 +15,7 @@ SWIG_SciDoubleOrInt8_AsShort(void *_pvApiCtx, int _iVar, signed char *_pscValue,
int iPrec = 0; int iPrec = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -36,7 +36,7 @@ SWIG_SciDoubleOrInt8_AsShort(void *_pvApiCtx, int _iVar, signed char *_pscValue,
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iPrec != SCI_INT8) { if (iPrec != SCI_INT8) {
Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit signed integer or a double expected.\n"), _fname, _iVar); Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit signed integer or a double expected.\n"), _fname, iVar);
return SWIG_TypeError; return SWIG_TypeError;
} }
sciErr = getMatrixOfInteger8(_pvApiCtx, piAddrVar, &iRows, &iCols, &pcData); sciErr = getMatrixOfInteger8(_pvApiCtx, piAddrVar, &iRows, &iCols, &pcData);
@ -45,10 +45,10 @@ SWIG_SciDoubleOrInt8_AsShort(void *_pvApiCtx, int _iVar, signed char *_pscValue,
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { if (iRows * iCols != 1) {
Scierror(999, _("%s: Wrong size for input argument #%d: A 8-bit signed integer or a double expected.\n"), _fname, _iVar); Scierror(999, _("%s: Wrong size for input argument #%d: A 8-bit signed integer or a double expected.\n"), _fname, iVar);
return SWIG_TypeError; return SWIG_TypeError;
} }
*_pscValue = *pcData; *pscValue = *pcData;
} }
else if (iType == sci_matrix) { else if (iType == sci_matrix) {
double *pdData = NULL; double *pdData = NULL;
@ -60,22 +60,22 @@ SWIG_SciDoubleOrInt8_AsShort(void *_pvApiCtx, int _iVar, signed char *_pscValue,
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { if (iRows * iCols != 1) {
Scierror(999, _("%s: Wrong size for input argument #%d: A 8-bit signed integer or a double expected.\n"), _fname, _iVar); Scierror(999, _("%s: Wrong size for input argument #%d: A 8-bit signed integer or a double expected.\n"), _fname, iVar);
return SWIG_TypeError; return SWIG_TypeError;
} }
dValue = *pdData; dValue = *pdData;
if (dValue != floor(dValue)) { if (dValue != floor(dValue)) {
Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 8-bit signed integer.\n"), _fname, _iVar); Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 8-bit signed integer.\n"), _fname, iVar);
return SWIG_ValueError; return SWIG_ValueError;
} }
if ((dValue < SCHAR_MIN) || (dValue > SCHAR_MAX)) { if ((dValue < SCHAR_MIN) || (dValue > SCHAR_MAX)) {
Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 8-bit signed integer.\n"), _fname, _iVar); Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 8-bit signed integer.\n"), _fname, iVar);
return SWIG_OverflowError; return SWIG_OverflowError;
} }
*_pscValue = (signed char) dValue; *pscValue = (signed char) dValue;
} }
else { else {
Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit signed integer or a double expected.\n"), _fname, _iVar); Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit signed integer or a double expected.\n"), _fname, iVar);
return SWIG_TypeError; return SWIG_TypeError;
} }
@ -88,9 +88,9 @@ SWIG_SciDoubleOrInt8_AsShort(void *_pvApiCtx, int _iVar, signed char *_pscValue,
} }
%fragment("SWIG_SciDouble_FromSignedChar", "header") { %fragment("SWIG_SciDouble_FromSignedChar", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciDouble_FromSignedChar(void *_pvApiCtx, int _iVarOut, signed char _scValue) { SWIG_SciDouble_FromSignedChar(void *_pvApiCtx, int iVarOut, signed char scValue) {
if (createScalarDouble(_pvApiCtx, if (createScalarDouble(_pvApiCtx,
SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, (double) _scValue)) SWIG_NbInputArgument(_pvApiCtx) + iVarOut, (double) scValue))
return SWIG_ERROR; return SWIG_ERROR;
return SWIG_OK; return SWIG_OK;
} }
@ -102,12 +102,12 @@ SWIG_SciDouble_FromSignedChar(void *_pvApiCtx, int _iVarOut, signed char _scValu
*/ */
%fragment("SWIG_SciDoubleOrInt8_AsSignedCharArrayAndSize", "header") { %fragment("SWIG_SciDoubleOrInt8_AsSignedCharArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciDoubleOrInt8_AsSignedCharArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows, int *_iCols, signed char **_pscValue, char *_fname) { SWIG_SciDoubleOrInt8_AsSignedCharArrayAndSize(void *_pvApiCtx, int iVar, int *iRows, int *iCols, signed char **pscValue, char *_fname) {
SciErr sciErr; SciErr sciErr;
int iType = 0; int iType = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -125,17 +125,17 @@ SWIG_SciDoubleOrInt8_AsSignedCharArrayAndSize(void *_pvApiCtx, int _iVar, int *_
int size = 0; int size = 0;
int i; int i;
sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, _iRows, _iCols, &pdData); sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, iRows, iCols, &pdData);
if (sciErr.iErr) if (sciErr.iErr)
{ {i
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
size = (*_iRows) * (*_iCols); size = (*iRows) * (*iCols);
*_pscValue = (signed char*) malloc(size * sizeof(int*)); *pscValue = (signed char*) malloc(size * sizeof(int*));
for (i = 0; i < size; i++) for (i = 0; i < size; i++)
(*_pscValue)[i] = (signed char) pdData[i]; (*pscValue)[i] = (signed char) pdData[i];
} }
else if (iType == sci_ints) else if (iType == sci_ints)
{ {
@ -147,11 +147,11 @@ SWIG_SciDoubleOrInt8_AsSignedCharArrayAndSize(void *_pvApiCtx, int _iVar, int *_
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iPrec != SCI_INT8) { if (iPrec != SCI_INT8) {
Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit signed integer or a double matrix expected.\n"), _fname, _iVar); Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit signed integer or a double matrix expected.\n"), _fname, iVar);
return SWIG_ERROR; return SWIG_ERROR;
} }
sciErr = getMatrixOfInteger8(_pvApiCtx, piAddrVar, _iRows, _iCols, (char **)_pscValue); sciErr = getMatrixOfInteger8(_pvApiCtx, piAddrVar, iRows, iCols, (char **)pscValue);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -159,7 +159,7 @@ SWIG_SciDoubleOrInt8_AsSignedCharArrayAndSize(void *_pvApiCtx, int _iVar, int *_
} }
else else
{ {
Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit signed integer or a double matrix expected.\n"), _fname, _iVar); Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit signed integer or a double matrix expected.\n"), _fname, iVar);
return SWIG_ERROR; return SWIG_ERROR;
} }
return SWIG_OK; return SWIG_OK;
@ -168,16 +168,16 @@ SWIG_SciDoubleOrInt8_AsSignedCharArrayAndSize(void *_pvApiCtx, int _iVar, int *_
%fragment("SWIG_SciDouble_FromSignedCharArrayAndSize", "header") { %fragment("SWIG_SciDouble_FromSignedCharArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciDouble_FromSignedCharArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, const signed char *_pscValue) { SWIG_SciDouble_FromSignedCharArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, const signed char *pscValue) {
SciErr sciErr; SciErr sciErr;
int i; int i;
double *pdValues = NULL; double *pdValues = NULL;
pdValues = (double*) malloc(_iRows * _iCols * sizeof(double)); pdValues = (double*) malloc(iRows * iCols * sizeof(double));
for (i=0; i<_iRows * _iCols; i++) for (i=0; i<iRows * iCols; i++)
pdValues[i] = _pscValue[i]; pdValues[i] = pscValue[i];
sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _iRows, _iCols, pdValues); sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, iRows, iCols, pdValues);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
free(pdValues); free(pdValues);

56
Lib/scilab/sciunsignedchar.swg
View file

@ -7,7 +7,7 @@
} }
%fragment("SWIG_SciUint8_AsUnsignedChar", "header") { %fragment("SWIG_SciUint8_AsUnsignedChar", "header") {
SWIGINTERN int 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; SciErr sciErr;
int iType = 0; int iType = 0;
int iRows = 0; int iRows = 0;
@ -16,7 +16,7 @@ SWIG_SciUint8_AsUnsignedChar(void *_pvApiCtx, int _iVar, unsigned char *_pucValu
int *piAddrVar = NULL; int *piAddrVar = NULL;
unsigned char *pucData = NULL; unsigned char *pucData = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -29,14 +29,14 @@ SWIG_SciUint8_AsUnsignedChar(void *_pvApiCtx, int _iVar, unsigned char *_pucValu
} }
if (iType == sci_ints) { if (iType == sci_ints) {
if (_pucValue) { if (pucValue) {
sciErr = getMatrixOfIntegerPrecision(_pvApiCtx, piAddrVar, &iPrec); sciErr = getMatrixOfIntegerPrecision(_pvApiCtx, piAddrVar, &iPrec);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iPrec != SCI_UINT8) { 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; return SWIG_ERROR;
} }
@ -46,14 +46,14 @@ SWIG_SciUint8_AsUnsignedChar(void *_pvApiCtx, int _iVar, unsigned char *_pucValu
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { 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; return SWIG_ERROR;
} }
*_pucValue = *pucData; *pucValue = *pucData;
} }
} }
else if (iType == sci_matrix) { else if (iType == sci_matrix) {
if (_pucValue) { if (pucValue) {
double *pdData = NULL; double *pdData = NULL;
double dValue = 0.0f; double dValue = 0.0f;
sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, &iRows, &iCols, &pdData); sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, &iRows, &iCols, &pdData);
@ -62,23 +62,23 @@ SWIG_SciUint8_AsUnsignedChar(void *_pvApiCtx, int _iVar, unsigned char *_pucValu
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { 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; return SWIG_TypeError;
} }
dValue = *pdData; dValue = *pdData;
if (dValue != floor(dValue)) { 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; return SWIG_ValueError;
} }
if ((dValue < 0) || (dValue > UCHAR_MAX)) { 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; return SWIG_OverflowError;
} }
*_pucValue = (unsigned char) dValue; *pucValue = (unsigned char) dValue;
} }
} }
else { 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; return SWIG_ERROR;
} }
@ -91,9 +91,9 @@ SWIG_SciUint8_AsUnsignedChar(void *_pvApiCtx, int _iVar, unsigned char *_pucValu
} }
%fragment("SWIG_SciUint8_FromUnsignedChar", "header") { %fragment("SWIG_SciUint8_FromUnsignedChar", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciUint8_FromUnsignedChar(void *_pvApiCtx, int _iVarOut, unsigned char _ucValue) { SWIG_SciUint8_FromUnsignedChar(void *_pvApiCtx, int iVarOut, unsigned char ucValue) {
if (createScalarDouble(pvApiCtx, if (createScalarDouble(pvApiCtx,
SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, (double) _ucValue)) SWIG_NbInputArgument(_pvApiCtx) + iVarOut, (double) ucValue))
return SWIG_ERROR; return SWIG_ERROR;
return SWIG_OK; return SWIG_OK;
} }
@ -105,13 +105,13 @@ SWIG_SciUint8_FromUnsignedChar(void *_pvApiCtx, int _iVarOut, unsigned char _ucV
*/ */
%fragment("SWIG_SciUint8_AsUnsignedCharArrayAndSize", "header") { %fragment("SWIG_SciUint8_AsUnsignedCharArrayAndSize", "header") {
SWIGINTERN int 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; SciErr sciErr;
int iType = 0; int iType = 0;
int iPrec = 0; int iPrec = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -129,17 +129,17 @@ SWIG_SciUint8_AsUnsignedCharArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows
int size = 0; int size = 0;
int i; int i;
sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, _iRows, _iCols, &pdData); sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, iRows, iCols, &pdData);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
size = (*_iRows) * (*_iCols); size = (*iRows) * (*iCols);
*_pucValue = (unsigned char*) malloc(size * sizeof(int*)); *pucValue = (unsigned char*) malloc(size * sizeof(int*));
for (i = 0; i < size; i++) for (i = 0; i < size; i++)
(*_pucValue)[i] = (unsigned char) pdData[i]; (*pucValue)[i] = (unsigned char) pdData[i];
} }
else if (iType == sci_ints) else if (iType == sci_ints)
{ {
@ -152,11 +152,11 @@ SWIG_SciUint8_AsUnsignedCharArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows
if (iPrec != SCI_UINT8) 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; return SWIG_ERROR;
} }
sciErr = getMatrixOfUnsignedInteger8(_pvApiCtx, piAddrVar, _iRows, _iCols, _pucValue); sciErr = getMatrixOfUnsignedInteger8(_pvApiCtx, piAddrVar, iRows, iCols, pucValue);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
@ -165,7 +165,7 @@ SWIG_SciUint8_AsUnsignedCharArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows
} }
else 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; return SWIG_ERROR;
} }
@ -175,16 +175,16 @@ SWIG_SciUint8_AsUnsignedCharArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows
%fragment("SWIG_SciUint8_FromUnsignedCharArrayAndSize", "header") { %fragment("SWIG_SciUint8_FromUnsignedCharArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciUint8_FromUnsignedCharArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, const unsigned char *_pucValues) { SWIG_SciUint8_FromUnsignedCharArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, const unsigned char *pucValues) {
SciErr sciErr; SciErr sciErr;
double *pdValues = NULL; double *pdValues = NULL;
int i; int i;
pdValues = (double*) malloc(_iRows * _iCols * sizeof(double)); pdValues = (double*) malloc(iRows * iCols * sizeof(double));
for (i=0; i<_iRows * _iCols; i++) for (i=0; i<iRows * iCols; i++)
pdValues[i] = _pucValues[i]; pdValues[i] = pucValues[i];
sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _iRows, _iCols, pdValues); sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, iRows, iCols, pdValues);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);

56
Lib/scilab/sciunsignedint.swg
View file

@ -7,7 +7,7 @@
} }
%fragment("SWIG_SciUint32_AsUnsignedInt", "header") { %fragment("SWIG_SciUint32_AsUnsignedInt", "header") {
SWIGINTERN int 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; SciErr sciErr;
int iType = 0; int iType = 0;
int iRows = 0; int iRows = 0;
@ -16,7 +16,7 @@ SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int _iVar, unsigned int *_puiValue
int *piAddrVar = NULL; int *piAddrVar = NULL;
unsigned int *puiData = NULL; unsigned int *puiData = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -29,14 +29,14 @@ SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int _iVar, unsigned int *_puiValue
} }
if (iType == sci_ints) { if (iType == sci_ints) {
if (_puiValue) { if (puiValue) {
sciErr = getMatrixOfIntegerPrecision(_pvApiCtx, piAddrVar, &iPrec); sciErr = getMatrixOfIntegerPrecision(_pvApiCtx, piAddrVar, &iPrec);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iPrec != SCI_UINT32) { 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; return SWIG_ERROR;
} }
@ -46,14 +46,14 @@ SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int _iVar, unsigned int *_puiValue
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { 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; return SWIG_ERROR;
} }
*_puiValue = *puiData; *puiValue = *puiData;
} }
} }
else if (iType == sci_matrix) { else if (iType == sci_matrix) {
if (_puiValue) { if (puiValue) {
double *pdData = NULL; double *pdData = NULL;
double dValue = 0.0f; double dValue = 0.0f;
sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, &iRows, &iCols, &pdData); sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, &iRows, &iCols, &pdData);
@ -62,23 +62,23 @@ SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int _iVar, unsigned int *_puiValue
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { 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; return SWIG_TypeError;
} }
dValue = *pdData; dValue = *pdData;
if (dValue != floor(dValue)) { 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; return SWIG_ValueError;
} }
if ((dValue < 0) || (dValue > UINT_MAX)) { 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; return SWIG_OverflowError;
} }
*_puiValue = (unsigned int) dValue; *puiValue = (unsigned int) dValue;
} }
} }
else { 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; return SWIG_ERROR;
} }
@ -91,9 +91,9 @@ SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int _iVar, unsigned int *_puiValue
} }
%fragment("SWIG_SciUint32_FromUnsignedInt", "header") { %fragment("SWIG_SciUint32_FromUnsignedInt", "header") {
SWIGINTERN int 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, if (createScalarDouble(_pvApiCtx,
SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, (double) _uiValue)) SWIG_NbInputArgument(_pvApiCtx) + iVarOut, (double) uiValue))
return SWIG_ERROR; return SWIG_ERROR;
return SWIG_OK; return SWIG_OK;
} }
@ -105,13 +105,13 @@ SWIG_SciUint32_FromUnsignedInt(void *_pvApiCtx, int _iVarOut, unsigned int _uiVa
*/ */
%fragment("SWIG_SciUint32_AsUnsignedIntArrayAndSize", "header") { %fragment("SWIG_SciUint32_AsUnsignedIntArrayAndSize", "header") {
SWIGINTERN int 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; SciErr sciErr;
int iType = 0; int iType = 0;
int iPrec = 0; int iPrec = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -129,17 +129,17 @@ SWIG_SciUint32_AsUnsignedIntArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows
int size = 0; int size = 0;
int i; int i;
sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, _iRows, _iCols, &pdData); sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, iRows, iCols, &pdData);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
size = (*_iRows) * (*_iCols); size = (*iRows) * (*iCols);
*_puiValue = (unsigned int*) malloc(size * sizeof(int*)); *puiValue = (unsigned int*) malloc(size * sizeof(int*));
for (i = 0; i < size; i++) for (i = 0; i < size; i++)
(*_puiValue)[i] = (unsigned int) pdData[i]; (*puiValue)[i] = (unsigned int) pdData[i];
} }
else if (iType == sci_ints) else if (iType == sci_ints)
{ {
@ -152,11 +152,11 @@ SWIG_SciUint32_AsUnsignedIntArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows
if (iPrec != SCI_UINT32) 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; return SWIG_ERROR;
} }
sciErr = getMatrixOfUnsignedInteger32(_pvApiCtx, piAddrVar, _iRows, _iCols, _puiValue); sciErr = getMatrixOfUnsignedInteger32(_pvApiCtx, piAddrVar, iRows, iCols, puiValue);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
@ -165,7 +165,7 @@ SWIG_SciUint32_AsUnsignedIntArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows
} }
else 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; return SWIG_ERROR;
} }
@ -175,16 +175,16 @@ SWIG_SciUint32_AsUnsignedIntArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRows
%fragment("SWIG_SciUint32_FromUnsignedIntArrayAndSize", "header") { %fragment("SWIG_SciUint32_FromUnsignedIntArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciUint32_FromUnsignedIntArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, unsigned int *_puiValues) { SWIG_SciUint32_FromUnsignedIntArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, unsigned int *puiValues) {
SciErr sciErr; SciErr sciErr;
double *pdValues = NULL; double *pdValues = NULL;
int i; int i;
pdValues = (double*) malloc(_iRows * _iCols * sizeof(double)); pdValues = (double*) malloc(iRows * iCols * sizeof(double));
for (i=0; i<_iRows * _iCols; i++) for (i=0; i<iRows * iCols; i++)
pdValues[i] = _puiValues[i]; pdValues[i] = puiValues[i];
sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + _iVarOut, _iRows, _iCols, pdValues); sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, pdValues);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
free(pdValues); free(pdValues);

20
Lib/scilab/sciunsignedlong.swg
View file

@ -8,12 +8,12 @@
} }
%fragment("SWIG_UnsignedInt_AsUnsignedLong", "header", fragment=SWIG_AsVal_frag(unsigned int)) { %fragment("SWIG_UnsignedInt_AsUnsignedLong", "header", fragment=SWIG_AsVal_frag(unsigned int)) {
SWIGINTERN 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; unsigned int uiValue = 0;
if(SWIG_AsVal_unsigned_SS_int(_iVar, &uiValue) != SWIG_OK) { if(SWIG_AsVal_unsigned_SS_int(iVar, &uiValue) != SWIG_OK) {
return SWIG_ERROR; return SWIG_ERROR;
} }
*_pulValue = (unsigned long) uiValue; *pulValue = (unsigned long) uiValue;
return SWIG_OK; return SWIG_OK;
} }
} }
@ -23,24 +23,24 @@ SWIG_UnsignedInt_AsUnsignedLong(void *_pvApiCtx, SwigSciObject _iVar, unsigned l
} }
%fragment("SWIG_UnsignedInt_FromUnsignedLong", "header", fragment=SWIG_From_frag(unsigned int)) { %fragment("SWIG_UnsignedInt_FromUnsignedLong", "header", fragment=SWIG_From_frag(unsigned int)) {
SWIGINTERN 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); return SWIG_From_unsigned_SS_int((unsigned int)ulValue);
} }
} }
%fragment("SWIG_SciUint32_FromUnsignedLongArrayAndSize", "header") { %fragment("SWIG_SciUint32_FromUnsignedLongArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciUint32_FromUnsignedLongArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, const unsigned long *_pulValues) { SWIG_SciUint32_FromUnsignedLongArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, const unsigned long *pulValues) {
SciErr sciErr; SciErr sciErr;
double *pdValues = NULL; double *pdValues = NULL;
int i; int i;
pdValues = (double*) malloc(_iRows * _iCols * sizeof(double)); pdValues = (double*) malloc(iRows * iCols * sizeof(double));
for (i=0; i<_iRows * _iCols; i++) { for (i=0; i<iRows * iCols; i++) {
pdValues[i] = _pulValues[i]; pdValues[i] = pulValues[i];
} }
sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _iRows, _iCols, pdValues); sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, iRows, iCols, pdValues);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
free(pdValues); free(pdValues);

57
Lib/scilab/sciunsignedshort.swg
View file

@ -7,7 +7,7 @@
} }
%fragment("SWIG_SciUint16_AsUnsignedShort", "header") { %fragment("SWIG_SciUint16_AsUnsignedShort", "header") {
SWIGINTERN int 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; SciErr sciErr;
int iType = 0; int iType = 0;
int iRows = 0; int iRows = 0;
@ -16,7 +16,7 @@ SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int _iVar, unsigned short *_pusV
int *piAddrVar = NULL; int *piAddrVar = NULL;
unsigned short *pusData = NULL; unsigned short *pusData = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -29,14 +29,14 @@ SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int _iVar, unsigned short *_pusV
} }
if (iType == sci_ints) { if (iType == sci_ints) {
if (_pusValue) { if (pusValue) {
sciErr = getMatrixOfIntegerPrecision(_pvApiCtx, piAddrVar, &iPrec); sciErr = getMatrixOfIntegerPrecision(_pvApiCtx, piAddrVar, &iPrec);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iPrec != SCI_UINT16) { 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; return SWIG_ERROR;
} }
@ -46,14 +46,14 @@ SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int _iVar, unsigned short *_pusV
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { 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; return SWIG_ERROR;
} }
*_pusValue = *pusData; *pusValue = *pusData;
} }
} }
else if (iType == sci_matrix) { else if (iType == sci_matrix) {
if (_pusValue) { if (pusValue) {
double *pdData = NULL; double *pdData = NULL;
double dValue = 0.0f; double dValue = 0.0f;
sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, &iRows, &iCols, &pdData); sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, &iRows, &iCols, &pdData);
@ -62,23 +62,23 @@ SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int _iVar, unsigned short *_pusV
return SWIG_ERROR; return SWIG_ERROR;
} }
if (iRows * iCols != 1) { 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; return SWIG_TypeError;
} }
dValue = *pdData; dValue = *pdData;
if (dValue != floor(dValue)) { 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; return SWIG_ValueError;
} }
if ((dValue < 0) || (dValue > USHRT_MAX)) { 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; return SWIG_OverflowError;
} }
*_pusValue = (unsigned short) dValue; *pusValue = (unsigned short) dValue;
} }
} }
else { 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; return SWIG_ERROR;
} }
@ -91,9 +91,8 @@ SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int _iVar, unsigned short *_pusV
} }
%fragment("SWIG_SciUint16_FromUnsignedShort", "header") { %fragment("SWIG_SciUint16_FromUnsignedShort", "header") {
SWIGINTERN int 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) {
int iVarOut = SWIG_NbInputArgument(_pvApiCtx) + _iVarOut; if (createScalarDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, (double) usValue))
if (createScalarDouble(_pvApiCtx, iVarOut, (double) _usValue))
return SWIG_ERROR; return SWIG_ERROR;
return SWIG_OK; return SWIG_OK;
} }
@ -105,13 +104,13 @@ SWIG_SciUint16_FromUnsignedShort(void *_pvApiCtx, int _iVarOut, unsigned short _
*/ */
%fragment("SWIG_SciUint16_AsUnsignedShortArrayAndSize", "header") { %fragment("SWIG_SciUint16_AsUnsignedShortArrayAndSize", "header") {
SWIGINTERN int 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; SciErr sciErr;
int iType = 0; int iType = 0;
int iPrec = 0; int iPrec = 0;
int *piAddrVar = NULL; int *piAddrVar = NULL;
sciErr = getVarAddressFromPosition(_pvApiCtx, _iVar, &piAddrVar); sciErr = getVarAddressFromPosition(_pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) { if (sciErr.iErr) {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
@ -129,17 +128,17 @@ SWIG_SciUint16_AsUnsignedShortArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRo
int size = 0; int size = 0;
int i; int i;
sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, _iRows, _iCols, &pdData); sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, iRows, iCols, &pdData);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
return SWIG_ERROR; return SWIG_ERROR;
} }
size = (*_iRows) * (*_iCols); size = (*iRows) * (*iCols);
*_pusValue = (unsigned short*) malloc(size * sizeof(int*)); *pusValue = (unsigned short*) malloc(size * sizeof(int*));
for (i = 0; i < size; i++) for (i = 0; i < size; i++)
(*_pusValue)[i] = (unsigned short) pdData[i]; (*pusValue)[i] = (unsigned short) pdData[i];
} }
else if (iType == sci_ints) else if (iType == sci_ints)
{ {
@ -152,11 +151,11 @@ SWIG_SciUint16_AsUnsignedShortArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRo
if (iPrec != SCI_UINT16) 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; return SWIG_ERROR;
} }
sciErr = getMatrixOfUnsignedInteger16(_pvApiCtx, piAddrVar, _iRows, _iCols, _pusValue); sciErr = getMatrixOfUnsignedInteger16(_pvApiCtx, piAddrVar, iRows, iCols, pusValue);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);
@ -165,7 +164,7 @@ SWIG_SciUint16_AsUnsignedShortArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRo
} }
else 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; return SWIG_ERROR;
} }
@ -175,16 +174,16 @@ SWIG_SciUint16_AsUnsignedShortArrayAndSize(void *_pvApiCtx, int _iVar, int *_iRo
%fragment("SWIG_SciUint16_FromUnsignedShortArrayAndSize", "header") { %fragment("SWIG_SciUint16_FromUnsignedShortArrayAndSize", "header") {
SWIGINTERN int SWIGINTERN int
SWIG_SciUint16_FromUnsignedShortArrayAndSize(void *_pvApiCtx, int _iVarOut, int _iRows, int _iCols, unsigned short *_pusValues) { SWIG_SciUint16_FromUnsignedShortArrayAndSize(void *_pvApiCtx, int iVarOut, int iRows, int iCols, unsigned short *pusValues) {
SciErr sciErr; SciErr sciErr;
double *pdValues = NULL; double *pdValues = NULL;
int i; int i;
pdValues = (double*) malloc(_iRows * _iCols * sizeof(double)); pdValues = (double*) malloc(iRows * iCols * sizeof(double));
for (i=0; i<_iRows * _iCols; i++) for (i=0; i<iRows * iCols; i++)
pdValues[i] = _pusValues[i]; pdValues[i] = pusValues[i];
sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _iRows, _iCols, pdValues); sciErr = createMatrixOfDouble(_pvApiCtx, SWIG_NbInputArgument(_pvApiCtx) + iVarOut, iRows, iCols, pdValues);
if (sciErr.iErr) if (sciErr.iErr)
{ {
printError(&sciErr, 0); printError(&sciErr, 0);

16
Lib/scilab/std_string.i
View file

@ -3,23 +3,23 @@
*/ */
%fragment(SWIG_AsPtr_frag(std::string), "header", fragment="SWIG_SciString_AsCharPtrAndSize") { %fragment(SWIG_AsPtr_frag(std::string), "header", fragment="SWIG_SciString_AsCharPtrAndSize") {
SWIGINTERN int SWIGINTERN int
SWIG_AsPtr_dec(std::string)(int _iVar, std::string **_pstValue) { SWIG_AsPtr_dec(std::string)(int iVar, std::string **pstValue) {
char* buf = 0; char* buf = 0;
size_t size = 0; size_t size = 0;
int alloc = SWIG_OLDOBJ; int alloc = SWIG_OLDOBJ;
if (SWIG_IsOK((SWIG_SciString_AsCharPtrAndSize(pvApiCtx, _iVar, &buf, &size, &alloc, SWIG_Scilab_GetFname())))) { if (SWIG_IsOK((SWIG_SciString_AsCharPtrAndSize(pvApiCtx, iVar, &buf, &size, &alloc, SWIG_Scilab_GetFname())))) {
if (buf) { if (buf) {
if (_pstValue) { if (pstValue) {
*_pstValue = new std::string(buf, size); *pstValue = new std::string(buf, size);
} }
if (alloc == SWIG_NEWOBJ) { if (alloc == SWIG_NEWOBJ) {
delete[] buf; delete[] buf;
} }
return SWIG_NEWOBJ; return SWIG_NEWOBJ;
} else { } else {
if (_pstValue) { if (pstValue) {
*_pstValue = NULL; *pstValue = NULL;
} }
return SWIG_OLDOBJ; return SWIG_OLDOBJ;
} }
@ -31,8 +31,8 @@ SWIG_AsPtr_dec(std::string)(int _iVar, std::string **_pstValue) {
%fragment(SWIG_From_frag(std::string), "header", fragment="SWIG_SciString_FromCharPtr") { %fragment(SWIG_From_frag(std::string), "header", fragment="SWIG_SciString_FromCharPtr") {
SWIGINTERN int SWIGINTERN int
SWIG_From_dec(std::string)(std::string _pstValue) { SWIG_From_dec(std::string)(std::string pstValue) {
return SWIG_SciString_FromCharPtr(pvApiCtx, SWIG_Scilab_GetOutputPosition(), _pstValue.c_str()); return SWIG_SciString_FromCharPtr(pvApiCtx, SWIG_Scilab_GetOutputPosition(), pstValue.c_str());
} }
} }