add api functions to manage double as integer 48/10048/1
Antoine ELIAS [Wed, 19 Sep 2012 07:51:00 +0000 (09:51 +0200)]
Change-Id: I791d91ac56a4c0e0d044b27155e90af74d110ea9
(cherry picked from commit 5a2f3b54bdee7a56c0c28b71665fc13e5b6530f5)

scilab/modules/api_scilab/includes/api_common.h
scilab/modules/api_scilab/includes/api_double.h
scilab/modules/api_scilab/src/c/DllmainApi_scilab.c
scilab/modules/api_scilab/src/cpp/api_common.cpp
scilab/modules/api_scilab/src/cpp/api_double.cpp
scilab/modules/api_scilab/src/cpp/api_internal_double.h

index 34e37b0..4420fcc 100644 (file)
@@ -353,6 +353,21 @@ extern "C" {
     int checkVarDimension(void* _pvCtx, int* _piAddress, int _iRows, int _iCols);
 
     /**
+     * Check if type of variable
+     * @param[in] _iVar variable position
+     * @return 1 for true and 0 for false
+     */
+    int getInputArgumentType(void* _pvCtx, int _iVar);
+
+    /**
+     * Check if type of variable
+     * @param[in] _iVar variable position
+     * @param[in] _iType variable type to check
+     * @return 1 for true and 0 for false
+     */
+    int checkInputArgumentType(void* _pvCtx, int _iVar, int _iType);
+
+    /**
      * Check if a matrix is empty
      * @param[in] _piAddress variable address
      * @return 1 for true and 0 for false
index c6d873b..2a9d5c5 100644 (file)
@@ -22,228 +22,291 @@ extern "C" {
 
 #include "doublecomplex.h"
 
-/*******************************/
-/*   double matrix functions   */
-/*******************************/
-/**
- * Get double variable data
- * @param[in] _piAddress variable address
- * @param[out] _piRows return number of rows
- * @param[out] _piCols return number of columns
- * @param[out] _pdblReal return pointer to real data
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, double** _pdblReal);
-
-/**
- * Get complex double variable data
- * @param[in] _piAddress variable address
- * @param[out] _piRows return number of rows
- * @param[out] _piCols return number of columns
- * @param[out] _pdblReal return pointer to real data
- * @param[out] _pdblImg return pointer to imaginary data
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getComplexMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg);
-
-/**
- * Get double variable data
- * @param[in] _piAddress variable address
- * @param[out] _piRows return number of row 
- * @param[out] _piCols return number of column
- * @param[out] _pdblZ return pointer to Z format data ( Real1, Img1, Real2, Img2, ... )
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getComplexZMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, doublecomplex** _pdblZ);
-
-/**
- * Allocate a double variable
- * @param[in] _iVar variable number
- * @param[in] _iRows number of rows
- * @param[in] _iCols number of columns
- * @param[out] _pdblReal return pointer to real data
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr allocMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, double** _pdblReal);
-
-/**
- * Allocate a complex double variable
- * @param[in] _iVar variable number
- * @param[in] _iRows number of rows
- * @param[in] _iCols number of columns
- * @param[out] _pdblReal return pointer to real data
- * @param[out] _pdblImg return pointer to imaginary data
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr allocComplexMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg);
-
-/**
- * Create a double variable
- * @param[in] _iVar variable number
- * @param[in] _iRows number of rows
- * @param[in] _iCols number of columns
- * @param[in] _pdblReal pointer to real data
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr createMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const double* _pdblReal);
-
-/**
- * Create a complex double variable
- * @param[in] _iVar variable number
- * @param[in] _iRows number of rows
- * @param[in] _iCols number of columns
- * @param[in] _pdblReal pointer to real data
- * @param[in] _pdblImg pointer to imaginary data
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr createComplexMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg);
-
-/**
- * Create a complex double variable
- * @param[in] _iVar variable number
- * @param[in] _iRows number of rows
- * @param[in] _iCols number of columns
- * @param[in] _pdblData pointer to Z format data ( Real1, Img1, Real2, Img2, ... )
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr createComplexZMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const doublecomplex* _pdblData);
-
-/**
- * Create a named double variable
- * @param[in] _pstName variable name
- * @param[in] _iRows number of rows
- * @param[in] _iCols number of columns
- * @param[in] _pdblReal pointer to real data
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr createNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const double* _pdblReal);
-
-/**
- * Create a named complex double variable
- * @param[in] _pstName variable name
- * @param[in] _iRows mumber of rows
- * @param[in] _iCols number of columns
- * @param[in] _pdblReal pointer to real data
- * @param[in] _pdblImg pointer to imaginary data
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr createNamedComplexMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg);
-
-/**
- * Create a named complex double variable
- * @param[in] _pstName variable name
- * @param[in] _iRows number of rows
- * @param[in] _iCols number of columns
- * @param[in] _pdblData pointer to Z format data ( Real1, Img1, Real2, Img2, ... )
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr createNamedComplexZMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const doublecomplex* _pdblData);
-
-/**
- * Get double named variable data
- * @param[in] _pstName variable name
- * @param[out] _piRows return number of rows
- * @param[out] _piCols return number of columns
- * @param[out] _pdblReal return real data
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr readNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, double* _pdblReal);
-
-/**
- * Get double named variable data
- * @param[in] _pstName variable name
- * @param[out] _piRows return number of rows
- * @param[out] _piCols return number of columns
- * @param[out] _pdblReal return real data
- * @param[out] _pdblImg return imaginary data
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr readNamedComplexMatrixOfDouble(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg);
+    /*******************************/
+    /*   double matrix functions   */
+    /*******************************/
+    /**
+     * Get double variable data
+     * @param[in] _piAddress variable address
+     * @param[out] _piRows return number of rows
+     * @param[out] _piCols return number of columns
+     * @param[out] _pdblReal return pointer to real data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, double** _pdblReal);
 
-/*shortcut functions*/
+    /**
+     * Get complex double variable data
+     * @param[in] _piAddress variable address
+     * @param[out] _piRows return number of rows
+     * @param[out] _piCols return number of columns
+     * @param[out] _pdblReal return pointer to real data
+     * @param[out] _pdblImg return pointer to imaginary data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getComplexMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg);
 
+    /**
+     * Get double variable data
+     * @param[in] _piAddress variable address
+     * @param[out] _piRows return number of row
+     * @param[out] _piCols return number of column
+     * @param[out] _pdblZ return pointer to Z format data ( Real1, Img1, Real2, Img2, ... )
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getComplexZMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, doublecomplex** _pdblZ);
 
-/**
- * Check if the variable type is double
- * @param[in] _piAddress variable address
- * @return 1 for true and 0 for false
- */
-int isDoubleType(void* _pvCtx, int* _piAddress);
+    /**
+     * Get double variable data
+     * @param[in] _piAddress variable address
+     * @param[out] _piRows return number of rows
+     * @param[out] _piCols return number of columns
+     * @param[out] _piReal return pointer to real data as integer
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getMatrixOfDoubleAsInteger(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piReal);
 
-/**
- * Check if the named variable type is double
- * @param[in] _pstName variable name
- * @return 1 for true and 0 for false
- */
-int isNamedDoubleType(void* _pvCtx, const char* _pstName);
+    /**
+     * Get double variable data
+     * @param[in] _piAddress variable address
+     * @param[out] _piRows return number of rows
+     * @param[out] _piCols return number of columns
+     * @param[out] _piReal return pointer to real data as integer
+     * @param[out] _piImg return pointer to imaginary data as integer
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getComplexMatrixOfDoubleAsInteger(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piReal, int** _piImg);
 
-/**
- * Get scalar double value
- * @param[in] _piAddress variable address
- * @param[out] _pdblReal return real value
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-int getScalarDouble(void* _pvCtx, int* _piAddress, double* _pdblReal);
-
-/**
- * Get scalar complex double value
- * @param[in] _piAddress variable address
- * @param[out] _pdblReal return real part
- * @param[out] _pdblImg return imaginary part
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-int getScalarComplexDouble(void* _pvCtx, int* _piAddress, double* _pdblReal, double* _pdblImg);
+    /**
+     * Allocate a double variable
+     * @param[in] _iVar variable number
+     * @param[in] _iRows number of rows
+     * @param[in] _iCols number of columns
+     * @param[out] _pdblReal return pointer to real data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr allocMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, double** _pdblReal);
 
-/**
- * Get scalar double value from a named variable
- * @param[in] _pstName variable name
- * @param[out] _pdblReal return real value
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-int getNamedScalarDouble(void* _pvCtx, const char* _pstName, double* _pdblReal);
-
-/**
- * Get scalar complex double value from a named variable
- * @param[in] _pstName variable name
- * @param[out] _pdblReal return real part
- * @param[out] _pdblImg return imaginary part
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-int getNamedScalarComplexDouble(void* _pvCtx, const char* _pstName, double* _pdblReal, double* _pdblImg);
+    /**
+     * Allocate a complex double variable
+     * @param[in] _iVar variable number
+     * @param[in] _iRows number of rows
+     * @param[in] _iCols number of columns
+     * @param[out] _pdblReal return pointer to real data
+     * @param[out] _pdblImg return pointer to imaginary data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr allocComplexMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg);
 
-/**
- * Create a scalar double variable
- * @param[in] _iVar variable number
- * @param[in] _dblReal real value
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-int createScalarDouble(void* _pvCtx, int _iVar, double _dblReal);
-
-/**
- * Create a scalar complex double variable
- * @param[in] _iVar variable number
- * @param[in] _dblReal real part
- * @param[in] _dblImg imaginary part
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-int createScalarComplexDouble(void* _pvCtx, int _iVar, double _dblReal, double _dblImg);
+    /**
+     * Allocate a double variable
+     * @param[in] _iVar variable number
+     * @param[in] _iRows number of rows
+     * @param[in] _iCols number of columns
+     * @param[out] _piReal return pointer to integer real data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr allocMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, int** _piReal);
 
-/**
- * Create a named scalar double variable
- * @param[in] _pstName variable name
- * @param[in] _dblReal real value
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-int createNamedScalarDouble(void* _pvCtx, const char* _pstName, double _dblReal);
-
-/**
- * Create a named scalar complex double variable
- * @param[in] _pstName variable name
- * @param[in] _dblReal real part
- * @param[in] _dblImg imaginary part
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-int createNamedScalarComplexDouble(void* _pvCtx, const char* _pstName, double _dblReal, double _dblImg);
+    /**
+     * Allocate a complex double variable
+     * @param[in] _iVar variable number
+     * @param[in] _iRows number of rows
+     * @param[in] _iCols number of columns
+     * @param[out] _piReal return pointer to integer real data
+     * @param[out] _piImg return pointer to integer imaginary data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr allocComplexMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, int** _piReal, int** _piImg);
+
+    /**
+     * Create a double variable
+     * @param[in] _iVar variable number
+     * @param[in] _iRows number of rows
+     * @param[in] _iCols number of columns
+     * @param[in] _pdblReal pointer to real data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr createMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const double* _pdblReal);
+
+    /**
+     * Create a complex double variable
+     * @param[in] _iVar variable number
+     * @param[in] _iRows number of rows
+     * @param[in] _iCols number of columns
+     * @param[in] _pdblReal pointer to real data
+     * @param[in] _pdblImg pointer to imaginary data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr createComplexMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg);
+
+    /**
+     * Create a double variable
+     * @param[in] _iVar variable number
+     * @param[in] _iRows number of rows
+     * @param[in] _iCols number of columns
+     * @param[in] _piReal pointer to integer real data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr createMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, const int* _piReal);
+
+    /**
+     * Create a complex double variable
+     * @param[in] _iVar variable number
+     * @param[in] _iRows number of rows
+     * @param[in] _iCols number of columns
+     * @param[in] _piReal pointer to integer real data
+     * @param[in] _piImg pointer to integer imaginary data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr createComplexMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, const int* _piReal, const int* _piImg);
+
+    /**
+     * Create a complex double variable
+     * @param[in] _iVar variable number
+     * @param[in] _iRows number of rows
+     * @param[in] _iCols number of columns
+     * @param[in] _pdblData pointer to Z format data ( Real1, Img1, Real2, Img2, ... )
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr createComplexZMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const doublecomplex* _pdblData);
+
+    /**
+     * Create a named double variable
+     * @param[in] _pstName variable name
+     * @param[in] _iRows number of rows
+     * @param[in] _iCols number of columns
+     * @param[in] _pdblReal pointer to real data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr createNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const double* _pdblReal);
+
+    /**
+     * Create a named complex double variable
+     * @param[in] _pstName variable name
+     * @param[in] _iRows mumber of rows
+     * @param[in] _iCols number of columns
+     * @param[in] _pdblReal pointer to real data
+     * @param[in] _pdblImg pointer to imaginary data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr createNamedComplexMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg);
+
+    /**
+     * Create a named complex double variable
+     * @param[in] _pstName variable name
+     * @param[in] _iRows number of rows
+     * @param[in] _iCols number of columns
+     * @param[in] _pdblData pointer to Z format data ( Real1, Img1, Real2, Img2, ... )
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr createNamedComplexZMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const doublecomplex* _pdblData);
+
+    /**
+     * Get double named variable data
+     * @param[in] _pstName variable name
+     * @param[out] _piRows return number of rows
+     * @param[out] _piCols return number of columns
+     * @param[out] _pdblReal return real data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr readNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, double* _pdblReal);
+
+    /**
+     * Get double named variable data
+     * @param[in] _pstName variable name
+     * @param[out] _piRows return number of rows
+     * @param[out] _piCols return number of columns
+     * @param[out] _pdblReal return real data
+     * @param[out] _pdblImg return imaginary data
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr readNamedComplexMatrixOfDouble(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg);
+
+    /*shortcut functions*/
+
+
+    /**
+     * Check if the variable type is double
+     * @param[in] _piAddress variable address
+     * @return 1 for true and 0 for false
+     */
+    int isDoubleType(void* _pvCtx, int* _piAddress);
+
+    /**
+     * Check if the named variable type is double
+     * @param[in] _pstName variable name
+     * @return 1 for true and 0 for false
+     */
+    int isNamedDoubleType(void* _pvCtx, const char* _pstName);
+
+    /**
+     * Get scalar double value
+     * @param[in] _piAddress variable address
+     * @param[out] _pdblReal return real value
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    int getScalarDouble(void* _pvCtx, int* _piAddress, double* _pdblReal);
+
+    /**
+     * Get scalar complex double value
+     * @param[in] _piAddress variable address
+     * @param[out] _pdblReal return real part
+     * @param[out] _pdblImg return imaginary part
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    int getScalarComplexDouble(void* _pvCtx, int* _piAddress, double* _pdblReal, double* _pdblImg);
+
+    /**
+     * Get scalar double value from a named variable
+     * @param[in] _pstName variable name
+     * @param[out] _pdblReal return real value
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    int getNamedScalarDouble(void* _pvCtx, const char* _pstName, double* _pdblReal);
+
+    /**
+     * Get scalar complex double value from a named variable
+     * @param[in] _pstName variable name
+     * @param[out] _pdblReal return real part
+     * @param[out] _pdblImg return imaginary part
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    int getNamedScalarComplexDouble(void* _pvCtx, const char* _pstName, double* _pdblReal, double* _pdblImg);
+
+    /**
+     * Create a scalar double variable
+     * @param[in] _iVar variable number
+     * @param[in] _dblReal real value
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    int createScalarDouble(void* _pvCtx, int _iVar, double _dblReal);
+
+    /**
+     * Create a scalar complex double variable
+     * @param[in] _iVar variable number
+     * @param[in] _dblReal real part
+     * @param[in] _dblImg imaginary part
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    int createScalarComplexDouble(void* _pvCtx, int _iVar, double _dblReal, double _dblImg);
+
+    /**
+     * Create a named scalar double variable
+     * @param[in] _pstName variable name
+     * @param[in] _dblReal real value
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    int createNamedScalarDouble(void* _pvCtx, const char* _pstName, double _dblReal);
+
+    /**
+     * Create a named scalar complex double variable
+     * @param[in] _pstName variable name
+     * @param[in] _dblReal real part
+     * @param[in] _dblImg imaginary part
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    int createNamedScalarComplexDouble(void* _pvCtx, const char* _pstName, double _dblReal, double _dblImg);
 
 #ifdef __cplusplus
 }
index b03f616..d382a62 100644 (file)
 #include <stdio.h> 
 #include <windows.h> 
 /*--------------------------------------------------------------------------*/ 
-#pragma comment(lib,"../../bin/libintl.lib")
-#pragma comment(lib,"../../bin/blasplus.lib")
+#pragma comment(lib, "../../bin/libintl.lib")
+#pragma comment(lib, "../../bin/blasplus.lib")
+#pragma comment(lib, "../../bin/elementary_functions_f.lib")
+#pragma comment(lib, "../../bin/linpack_f.lib")
 /*--------------------------------------------------------------------------*/ 
 int WINAPI DllMain (HINSTANCE hInstance , DWORD reason, PVOID pvReserved)
 {
index f4a46e8..7e4376a 100644 (file)
@@ -1223,6 +1223,34 @@ int checkNamedVarType(void *_pvCtx, const char *_pstName, int _iType)
 }
 
 /*--------------------------------------------------------------------------*/
+int getInputArgumentType(void* _pvCtx, int _iVar)
+{
+    SciErr sciErr;
+    int* piAddr = NULL;
+    int iType = 0;
+
+    sciErr = getVarAddressFromPosition(_pvCtx, _iVar, &piAddr);
+    if(sciErr.iErr)
+    {
+        return 0;
+    }
+
+    sciErr = getVarType(_pvCtx, piAddr, &iType);
+    if(sciErr.iErr)
+    {
+        return 0;
+    }
+
+    return iType;
+}
+
+/*--------------------------------------------------------------------------*/
+int checkInputArgumentType(void* _pvCtx, int _iVar, int _iType)
+{
+    return getInputArgumentType(_pvCtx, _iVar) == _iType;
+}
+
+/*--------------------------------------------------------------------------*/
 int isEmptyMatrix(void *_pvCtx, int *_piAddress)
 {
     if (checkVarType(_pvCtx, _piAddress, sci_matrix))
index 4a73bdf..ea0a9eb 100644 (file)
@@ -20,6 +20,9 @@
 
 #include "call_scilab.h"
 
+
+extern int C2F(entier)(int *n, double *d__, int *s);
+extern int C2F(icopy)(int *, int *, int *, int *, int *);
 /*******************************/
 /*   double matrix functions   */
 /*******************************/
@@ -43,12 +46,14 @@ SciErr getComplexMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int
 
 SciErr getComplexZMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, doublecomplex** _pdblZ)
 {
-    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     double *pdblReal = NULL;
     double *pdblImg     = NULL;
 
     sciErr = getCommonMatrixOfDouble(_pvCtx, _piAddress, isVarComplex(_pvCtx, _piAddress), _piRows, _piCols, &pdblReal, &pdblImg);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_GET_ZDOUBLE, _("%s: Unable to get argument #%d"), "getComplexZMatrixOfDouble", getRhsFromAddress(_pvCtx, _piAddress));
         return sciErr;
@@ -58,41 +63,84 @@ SciErr getComplexZMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, in
     return sciErr;
 }
 
+SciErr getMatrixOfDoubleAsInteger(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piReal)
+{
+    SciErr sciErr;
+    double* pdblReal = NULL;
+    int iSize = 0;
+    sciErr = getCommonMatrixOfDouble(_pvCtx, _piAddress, 0, _piRows, _piCols, &pdblReal, NULL);
+    if (sciErr.iErr)
+    {
+        return sciErr;
+    }
+
+    iSize = *_piRows * *_piCols;
+    *_piReal = (int*)pdblReal;
+
+    //Warning we overwrite double by int !!!!
+    C2F(entier)(&iSize, pdblReal, *_piReal);
+    return sciErr;
+}
+
+SciErr getComplexMatrixOfDoubleAsInteger(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piReal, int** _piImg)
+{
+    SciErr sciErr;
+    double* pdblReal = NULL;
+    double* pdblImg  = NULL;
+    int iSize = 0;
+    sciErr = getCommonMatrixOfDouble(_pvCtx, _piAddress, 1, _piRows, _piCols, &pdblReal, &pdblImg);
+    if (sciErr.iErr)
+    {
+        return sciErr;
+    }
+
+    iSize = *_piRows * *_piCols;
+    *_piReal = (int*)pdblReal;
+    *_piImg = (int*)pdblImg;
+
+    //Warning we overwrite double by int !!!!
+    C2F(entier)(&iSize, pdblReal, *_piReal);
+    C2F(entier)(&iSize, pdblImg, *_piImg);
+    return sciErr;
+}
+
 SciErr getCommonMatrixOfDouble(void* _pvCtx, int* _piAddress, int _iComplex, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg)
 {
-    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     int iType = 0;
-    if(        _piAddress == NULL)
+    if (       _piAddress == NULL)
     {
         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "getComplexMatrixOfDouble" : "getMatrixOfDouble");
         return sciErr;
     }
 
     sciErr = getVarType(_pvCtx, _piAddress, &iType);
-    if(sciErr.iErr || iType != sci_matrix)
+    if (sciErr.iErr || iType != sci_matrix)
     {
         addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s excepted"), _iComplex ? "getComplexMatrixOfDouble" : "getMatrixOfDouble", _("double matrix"));
         return sciErr;
     }
 
-    if(isVarComplex(_pvCtx, _piAddress) != _iComplex)
+    if (isVarComplex(_pvCtx, _piAddress) != _iComplex)
     {
         addErrorMessage(&sciErr, API_ERROR_INVALID_COMPLEXITY, _("%s: Bad call to get a non complex matrix"), "getComplexMatrixOfDouble");
         return sciErr;
     }
 
     sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_GET_DOUBLE, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexMatrixOfDouble" : "getMatrixOfDouble", getRhsFromAddress(_pvCtx, _piAddress));
         return sciErr;
     }
 
-    if(_pdblReal != NULL)
+    if (_pdblReal != NULL)
     {
         *_pdblReal     = (double*)(_piAddress + 4);
     }
-    if(_iComplex && _pdblImg != NULL)
+    if (_iComplex && _pdblImg != NULL)
     {
         *_pdblImg      = (double*)(_piAddress + 4) + *_piRows * *_piCols;
     }
@@ -101,42 +149,87 @@ SciErr getCommonMatrixOfDouble(void* _pvCtx, int* _piAddress, int _iComplex, int
 
 SciErr allocMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, double** _pdblReal)
 {
-    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     double *pdblReal   = NULL;
 
-    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 0, _iRows, _iCols, &pdblReal, NULL);
-    if(sciErr.iErr)
+    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, '$', 0, _iRows, _iCols, &pdblReal, NULL);
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_ALLOC_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfDouble");
         return sciErr;
     }
 
-    *_pdblReal = pdblReal;
+    *_pdblReal = pdblReal;
 
     return sciErr;
 }
 
 SciErr allocComplexMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg)
 {
-    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
+    double *pdblReal   = NULL;
+    double *pdblImg            = NULL;
+
+    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, '$', 1, _iRows, _iCols, &pdblReal, &pdblImg);
+    if (sciErr.iErr)
+    {
+        addErrorMessage(&sciErr, API_ERROR_ALLOC_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
+        return sciErr;
+    }
+
+    *_pdblReal = pdblReal;
+    *_pdblImg  = pdblImg;
+    return sciErr;
+}
+
+SciErr allocMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, int** _piReal)
+{
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
+    double *pdblReal   = NULL;
+
+    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', 0, _iRows, _iCols, &pdblReal, NULL);
+    if (sciErr.iErr)
+    {
+        addErrorMessage(&sciErr, API_ERROR_ALLOC_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfDouble");
+        return sciErr;
+    }
+
+    *_piReal = (int*)pdblReal;
+
+    return sciErr;
+}
+
+SciErr allocComplexMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, int** _piReal, int** _piImg)
+{
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     double *pdblReal   = NULL;
     double *pdblImg            = NULL;
 
-    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 1, _iRows, _iCols, &pdblReal, &pdblImg);
-    if(sciErr.iErr)
+    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', 1, _iRows, _iCols, &pdblReal, &pdblImg);
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_ALLOC_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
         return sciErr;
     }
 
-    *_pdblReal = pdblReal;
-    *_pdblImg          = pdblImg;
+    *_piReal = (int*)pdblReal;
+    *_piImg  = (int*)pdblImg;
     return sciErr;
 }
 
-SciErr allocCommonMatrixOfDouble(void* _pvCtx, int _iVar, int _iComplex, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg)
+SciErr allocCommonMatrixOfDouble(void* _pvCtx, int _iVar, char _cType, int _iComplex, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg)
 {
-    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     int iNewPos                        = Top - Rhs + _iVar;
     int iAddr                          = *Lstk(iNewPos);
     int* piAddr                        = NULL;
@@ -151,26 +244,35 @@ SciErr allocCommonMatrixOfDouble(void* _pvCtx, int _iVar, int _iComplex, int _iR
 
     getNewVarAddressFromPosition(_pvCtx, iNewPos, &piAddr);
     fillCommonMatrixOfDouble(_pvCtx, piAddr, _iComplex, _iRows, _iCols, _pdblReal, _pdblImg);
-    updateInterSCI(_iVar, '$', iAddr, sadr(iadr(iAddr) + 4));
+
+    int iSCIAddress = sadr(iadr(iAddr) + 4);
+    if (_cType == 'i')
+    {
+        iSCIAddress = iadr(iSCIAddress);
+    }
+
+    updateInterSCI(_iVar, _cType, iAddr, iSCIAddress);
     updateLstk(iNewPos, sadr(iadr(iAddr) + 4), _iRows * _iCols * (_iComplex + 1));
     return sciErr;
 }
 
 SciErr fillCommonMatrixOfDouble(void* _pvCtx, int* _piAddress, int _iComplex, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg)
 {
-    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     _piAddress[0]              = sci_matrix;
     _piAddress[1]              = Min(_iRows, _iRows * _iCols);
     _piAddress[2]              = Min(_iCols, _iRows * _iCols);
     _piAddress[3]              = _iComplex;
 
 
-    if(_pdblReal != NULL)
+    if (_pdblReal != NULL)
     {
         *_pdblReal             = (double*)(_piAddress + 4);
     }
 
-    if(_iComplex != 0 && _pdblImg != NULL)
+    if (_iComplex != 0 && _pdblImg != NULL)
     {
         *_pdblImg      = *_pdblReal + _iRows * _iCols;
     }
@@ -180,14 +282,16 @@ SciErr fillCommonMatrixOfDouble(void* _pvCtx, int* _piAddress, int _iComplex, in
 
 SciErr createMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const double* _pdblReal)
 {
-    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     double *pdblReal   = NULL;
 
     int iOne                                   = 1;
     int iSize                                  = _iRows * _iCols;
 
     sciErr = allocMatrixOfDouble(_pvCtx, _iVar, _iRows, _iCols, &pdblReal);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_CREATE_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
         return sciErr;
@@ -199,15 +303,17 @@ SciErr createMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, con
 
 SciErr createComplexMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
 {
-    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     double *pdblReal   = NULL;
     double *pdblImg            = NULL;
 
-    int iOne                                   = 1;
-    int iSize                                  = _iRows * _iCols;
+    int iOne = 1;
+    int iSize = _iRows * _iCols;
 
     sciErr = allocComplexMatrixOfDouble(_pvCtx, _iVar, _iRows, _iCols, &pdblReal, &pdblImg);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_CREATE_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
         return sciErr;
@@ -218,15 +324,61 @@ SciErr createComplexMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCo
     return sciErr;
 }
 
+SciErr createMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, const int* _piReal)
+{
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
+    double *pdblReal   = NULL;
+
+    int iOne = 1;
+    int iSize = _iRows * _iCols;
+
+    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', 0, _iRows, _iCols, &pdblReal, NULL);
+    if (sciErr.iErr)
+    {
+        addErrorMessage(&sciErr, API_ERROR_CREATE_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
+        return sciErr;
+    }
+
+    C2F(icopy)(&iSize, (int*)_piReal, &iOne, (int*)pdblReal, &iOne);
+    return sciErr;
+}
+
+SciErr createComplexMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, const int* _piReal, const int* _piImg)
+{
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
+    double *pdblReal   = NULL;
+    double *pdblImg            = NULL;
+
+    int iOne = 1;
+    int iSize = _iRows * _iCols;
+
+    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', 1, _iRows, _iCols, &pdblReal, &pdblImg);
+    if (sciErr.iErr)
+    {
+        addErrorMessage(&sciErr, API_ERROR_CREATE_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
+        return sciErr;
+    }
+
+    C2F(icopy)(&iSize, (int*)_piReal, &iOne, (int*)pdblReal, &iOne);
+    C2F(icopy)(&iSize, (int*)_piImg, &iOne, (int*)pdblImg, &iOne);
+    return sciErr;
+}
+
 SciErr createComplexZMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const doublecomplex* _pdblData)
 {
-    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     double *pdblReal           = NULL;
     double *pdblImg                    = NULL;
 
 
     sciErr = allocComplexMatrixOfDouble(_pvCtx, _iVar, _iRows, _iCols, &pdblReal, &pdblImg);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_CREATE_ZDOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
         return sciErr;
@@ -248,7 +400,9 @@ SciErr createNamedComplexMatrixOfDouble(void* _pvCtx, const char* _pstName, int
 
 SciErr createNamedComplexZMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const doublecomplex* _pdblData)
 {
-    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     int iVarID[nsiz];
     int iSaveRhs                       = Rhs;
     int iSaveTop                       = Top;
@@ -288,7 +442,9 @@ SciErr createNamedComplexZMatrixOfDouble(void* _pvCtx, const char* _pstName, int
 
 SciErr createCommonNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iComplex, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg)
 {
-    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     int iVarID[nsiz];
     int iSaveRhs               = Rhs;
     int iSaveTop               = Top;
@@ -322,7 +478,7 @@ SciErr createCommonNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int _
     //copy data in stack
     C2F(dcopy)(&iSize, const_cast<double*>(_pdblReal), &iOne, pdblReal, &iOne);
 
-    if(_iComplex)
+    if (_iComplex)
     {
         C2F(dcopy)(&iSize, const_cast<double*>(_pdblImg), &iOne, pdblImg, &iOne);
     }
@@ -352,7 +508,9 @@ SciErr readNamedComplexMatrixOfDouble(void* _pvCtx, const char* _pstName, int* _
 
 SciErr readCommonNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iComplex, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg)
 {
-    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     int* piAddr                = NULL;
     double* pdblReal   = NULL;
     double* pdblImg            = NULL;
@@ -360,20 +518,20 @@ SciErr readCommonNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iC
     int iOne           = 1;
 
     sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_DOUBLE, _("%s: Unable to get variable \"%s\""), _iComplex ? "readNamedComplexMatrixOfDouble" : "readNamedMatrixOfDouble", _pstName);
         return sciErr;
     }
 
     sciErr = getCommonMatrixOfDouble(_pvCtx, piAddr, _iComplex, _piRows, _piCols, &pdblReal, &pdblImg);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_READ_NAMED_DOUBLE, _("%s: Unable to get variable \"%s\""), _iComplex ? "readNamedComplexMatrixOfDouble" : "readNamedMatrixOfDouble", _pstName);
         return sciErr;
     }
 
-    if(_pdblReal == NULL || (_iComplex && _pdblImg == NULL))
+    if (_pdblReal == NULL || (_iComplex && _pdblImg == NULL))
     {
         return sciErr;
     }
@@ -381,7 +539,7 @@ SciErr readCommonNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iC
     iSize = (*_piRows) * (*_piCols);
     /* dcopy source to dest */
     C2F(dcopy)(&iSize, pdblReal, &iOne, _pdblReal, &iOne);
-    if(_iComplex)
+    if (_iComplex)
     {
         C2F(dcopy)(&iSize, pdblImg, &iOne, _pdblImg, &iOne);
     }
@@ -413,7 +571,9 @@ int getScalarComplexDouble(void* _pvCtx, int* _piAddress, double* _pdblReal, dou
 /*--------------------------------------------------------------------------*/
 static int getCommonScalarDouble(void* _pvCtx, int* _piAddress, int _iComplex, double* _pdblReal, double* _pdblImg)
 {
-       SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     int iRows  = 0;
     int iCols  = 0;
 
@@ -421,26 +581,26 @@ static int getCommonScalarDouble(void* _pvCtx, int* _piAddress, int _iComplex, d
     double* pdblImg     = NULL;
 
     sciErr = getCommonMatrixOfDouble(_pvCtx, _piAddress, _iComplex, &iRows, &iCols, &pdblReal, &pdblImg);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_GET_SCALAR_DOUBLE, _("%s: Unable to get argument #%d"), _iComplex ? "getScalarComplexDouble" : "getScalarDouble", getRhsFromAddress(_pvCtx, _piAddress));
         printError(&sciErr, 0);
         return sciErr.iErr;
     }
 
-    if(isScalar(_pvCtx, _piAddress) == 0)
+    if (isScalar(_pvCtx, _piAddress) == 0)
     {
         addErrorMessage(&sciErr, API_ERROR_GET_SCALAR_DOUBLE, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), _iComplex ? "getScalarComplexDouble" : "getScalarDouble", getRhsFromAddress(_pvCtx, _piAddress));
         printError(&sciErr, 0);
         return sciErr.iErr;
     }
 
-    if(_pdblReal != NULL)
+    if (_pdblReal != NULL)
     {
         *_pdblReal     = pdblReal[0];
     }
 
-    if(_pdblImg != NULL)
+    if (_pdblImg != NULL)
     {
         *_pdblImg              = pdblImg[0];
     }
@@ -460,14 +620,16 @@ int getNamedScalarComplexDouble(void* _pvCtx, const char* _pstName, double* _pdb
 /*--------------------------------------------------------------------------*/
 static int getCommonNamedScalarDouble(void* _pvCtx, const char* _pstName, int _iComplex, double* _pdblReal, double* _pdblImg)
 {
-       SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     int iRows  = 0;
     int iCols  = 0;
 
     double dblReal = 0;
     double dblImg       = 0;
 
-    if(isNamedScalar(_pvCtx, _pstName) == 0)
+    if (isNamedScalar(_pvCtx, _pstName) == 0)
     {
         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_SCALAR_DOUBLE, _("%s: Wrong type for input argument \"%s\": A scalar expected.\n"), _iComplex ? "getNamedScalarComplexDouble" : "getNamedScalarDouble", _pstName);
         printError(&sciErr, 0);
@@ -475,19 +637,19 @@ static int getCommonNamedScalarDouble(void* _pvCtx, const char* _pstName, int _i
     }
 
     sciErr = readCommonNamedMatrixOfDouble(_pvCtx, _pstName, _iComplex, &iRows, &iCols, &dblReal, &dblImg);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_GET_NAMED_SCALAR_DOUBLE, _("%s: Unable to get argument \"%s\""), _iComplex ? "getNamedScalarComplexDouble" : "getNamedScalarDouble", _pstName);
         printError(&sciErr, 0);
         return sciErr.iErr;
     }
 
-    if(_pdblReal != NULL)
+    if (_pdblReal != NULL)
     {
         _pdblReal[0]   = dblReal;
     }
 
-    if(_pdblImg != NULL)
+    if (_pdblImg != NULL)
     {
         _pdblImg[0]            = dblImg;
     }
@@ -507,12 +669,14 @@ int createScalarComplexDouble(void* _pvCtx, int _iVar, double _dblReal, double _
 /*--------------------------------------------------------------------------*/
 static int createCommonScalarDouble(void* _pvCtx, int _iVar, int _iComplex, double _dblReal, double _dblImg)
 {
-       SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
     double *pdblReal   = NULL;
     double *pdblImg            = NULL;
 
-    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, _iComplex, 1, 1, &pdblReal, &pdblImg);
-    if(sciErr.iErr)
+    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, '$', _iComplex, 1, 1, &pdblReal, &pdblImg);
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_DOUBLE, _("%s: Unable to create variable in Scilab memory"), _iComplex ? "createScalarComplexDouble" : "createScalarDouble");
         printError(&sciErr, 0);
@@ -520,7 +684,7 @@ static int createCommonScalarDouble(void* _pvCtx, int _iVar, int _iComplex, doub
     }
 
     pdblReal[0] = _dblReal;
-    if(_iComplex)
+    if (_iComplex)
     {
         pdblImg[0]     = _dblImg;
     }
@@ -539,10 +703,12 @@ int createNamedScalarComplexDouble(void* _pvCtx, const char* _pstName, double _d
 /*--------------------------------------------------------------------------*/
 static int createCommonNamedScalarDouble(void* _pvCtx, const char* _pstName, int _iComplex, double _dblReal, double _dblImg)
 {
-       SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
+    SciErr sciErr;
+    sciErr.iErr = 0;
+    sciErr.iMsgCount = 0;
 
     sciErr = createCommonNamedMatrixOfDouble(_pvCtx, _pstName, _iComplex, 1, 1, &_dblReal, &_dblImg);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         addErrorMessage(&sciErr, API_ERROR_CREATE_NAMED_SCALAR, _("%s: Unable to create variable in Scilab memory"), _iComplex ? "createNamedScalarComplexDouble" : "createNamedScalarDouble");
         printError(&sciErr, 0);
index 1370cee..776007a 100644 (file)
@@ -14,7 +14,7 @@
 
 //internal double functions
 SciErr getCommonMatrixOfDouble(void* _pvCtx, int* _piAddress, int _iComplex, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg);
-SciErr allocCommonMatrixOfDouble(void* _pvCtx, int _iVar, int _iComplex, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg);
+SciErr allocCommonMatrixOfDouble(void* _pvCtx, int _iVar, char _cType, int _iComplex, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg);
 SciErr fillCommonMatrixOfDouble(void* _pvCtx, int* _piAddress, int _iComplex, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg);
 SciErr createCommonNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iComplex, int _iRows, int _iCols, const double* _pdblReal, const double* _pdblImg);
 SciErr readCommonNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int _iComplex, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg);