# Integer reading (Scilab gateway)

How to read matrices of integer in a gateway.

## Calling Sequence

Input argument profile:

Signed integer :

    SciErr getMatrixOfInteger8(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, char** _pcData8)

    SciErr getMatrixOfInteger16(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, short** _psData16)

    SciErr getMatrixOfInteger32(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piData32)

Unsigned integer :

    SciErr getMatrixOfUnsignedInteger8(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, unsigned char** _pucData8)

    SciErr getMatrixOfUnsignedInteger16(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, unsigned short** _pusData16)

    SciErr getMatrixOfUnsignedInteger32(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, unsigned int** _puiData32)

Named variable profile:

Signed integer :

    SciErr readNamedMatrixOfInteger8(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, char* _pcData8)

    SciErr readNamedMatrixOfInteger16(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, short* _psData16)

    SciErr readNamedMatrixOfInteger32(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piData32)

Unsigned integer :

    SciErr readNamedMatrixOfUnsignedInteger8(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, unsigned char* _pucData8)

    SciErr readNamedMatrixOfUnsignedInteger16(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, unsigned short* _pusData16)

    SciErr readNamedMatrixOfUnsignedInteger32(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, unsigned int* _puiData32)

## Arguments

_pvCtx

  Scilab environment pointer, pass in "pvApiCtx" provided by api_scilab.h.

_piAddress

  Address of the Scilab variable.

_pstName

  Name of the variable for "named" functions.

_piRows

  Return number of rows.

_piCols

  Return number of columns.

_pcData8, _pucData8, _psData16, _pusData16, _piData32, _puiData32

  Returns address of array ( size: _piRows * _piCols). For "Named" function, _pcData must be allocated before calling function.

SciErr

  Error structure where is stored errors messages history and first error number.

## Description

This help describes how matrices of integer can be handled through the Scilab API.

## Gateway Source

    #include "api_scilab.h"
    void* create_output(int _iCoeff, int _iSize, int _iRows, int _iCols, void* _pvDataIn);

    int read_integer(char *fname,unsigned long fname_len)
    {
    	SciErr sciErr;
    	//output variable info
    	int iRows8					= 0;
    	int iCols8					= 0;
    	int iRows16					= 0;
    	int iCols16					= 0;
    	int iRows32					= 0;
    	int iCols32					= 0;
    	int iRowsu8					= 0;
    	int iColsu8					= 0;
    	int iRowsu16				= 0;
    	int iColsu16				= 0;
    	int iRowsu32				= 0;
    	int iColsu32				= 0;
    	int iPrec					= 0;
    	int* piAddr8				= NULL;
    	int* piAddr16				= NULL;
    	int* piAddr32				= NULL;
    	int* piAddru8				= NULL;
    	int* piAddru16				= NULL;
    	int* piAddru32				= NULL;
    	char* pcData				= NULL;
    	short* psData				= NULL;
    	int* piData					= NULL;
    	unsigned char* pucData		= NULL;
    	unsigned short* pusData		= NULL;
    	unsigned int* puiData		= NULL;
    	char* pcDataOut				= NULL;
    	short* psDataOut			= NULL;
    	int* piDataOut				= NULL;
    	unsigned char* pucDataOut	= NULL;
    	unsigned short* pusDataOut	= NULL;
    	unsigned int* puiDataOut	= NULL;

    	//check input/ouput arguments count
        CheckInputArgument(pvApiCtx, 6, 6);
        CheckOutputArgument(pvApiCtx, 6, 6);

    	//get varialbe address
    	sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr8);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddru8);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr16);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddru16);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr32);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddru32);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//check variable precision
    	sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr8, &iPrec);
    	if(sciErr.iErr || iPrec != SCI_INT8)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//check variable precision
    	sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru8, &iPrec);
    	if(sciErr.iErr || iPrec != SCI_UINT8)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//check variable precision
    	sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr16, &iPrec);
    	if(sciErr.iErr || iPrec != SCI_INT16)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//check variable precision
    	sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru16, &iPrec);
    	if(sciErr.iErr || iPrec != SCI_UINT16)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}
    	//check variable precision
    	sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr32, &iPrec);
    	if(sciErr.iErr || iPrec != SCI_INT32)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//check variable precision
    	sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru32, &iPrec);
    	if(sciErr.iErr || iPrec != SCI_UINT32)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//retrieve dimensions and data
    	sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//retrieve dimensions and data
    	sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddru8, &iRowsu8, &iColsu8, &pucData);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//retrieve dimensions and data
    	sciErr = getMatrixOfInteger16(pvApiCtx, piAddr16, &iRows16, &iCols16, &psData);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//retrieve dimensions and data
    	sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddru16, &iRowsu16, &iColsu16, &pusData);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//retrieve dimensions and data
    	sciErr = getMatrixOfInteger32(pvApiCtx, piAddr32, &iRows32, &iCols32, &piData);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//retrieve dimensions and data
    	sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddru32, &iRowsu32, &iColsu32, &puiData);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//alloc and fill new variable
    	pcDataOut   = (char*)create_output(2, 1, iRows8, iCols8, (void*)pcData);
    	pucDataOut  = (unsigned char*)create_output(4, 1, iRowsu8, iColsu8, (void*)pucData);
    	psDataOut   = (short*)create_output(8, 2, iRows16, iCols16, (void*)psData);
    	pusDataOut  = (unsigned short*)create_output(16, 2, iRowsu16, iColsu16, (void*)pusData);
    	piDataOut   = (int*)create_output(32, 4, iRows32, iCols32, (void*)piData);
    	puiDataOut  = (unsigned int*)create_output(64, 4, iRowsu32, iColsu32, (void*)puiData);

    	//create new variable
    	sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows8, iCols8, pcDataOut);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//create new variable
    	sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 2, iRowsu8, iColsu8, pucDataOut);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//create new variable
    	sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 3, iRows16, iCols16, psDataOut);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//create new variable
    	sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 4, iRowsu16, iColsu16, pusDataOut);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//create new variable
    	sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 5, iRows32, iCols32, piDataOut);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//create new variable
    	sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 6, iRowsu32, iColsu32, puiDataOut);
    	if(sciErr.iErr)
    	{
    		printError(&sciErr, 0);
    		return 0;
    	}

    	//assign allocated variables to Lhs position
    	AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
    	AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
    	AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
    	AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
    	AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
    	AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6;
    	return 0;
    }

    void* create_output(int _iCoeff, int _iSize, int _iRows, int _iCols, void* _pvDataIn)
    {
    	int i = 0;
    	void* pvDataOut = (void*)malloc(_iSize * _iRows * _iCols);
    	for(i = 0 ; i < _iRows * _iCols ; i++)
    	{
    		int iVal = 0;
    		memcpy(&iVal, (char*)_pvDataIn + i * _iSize, _iSize);
    		iVal *= _iCoeff;
    		memcpy((char*)pvDataOut + i * _iSize, &iVal, _iSize);
    	}
    	return pvDataOut;
    }

## Scilab test script

    a8  = int8([    1   -2  3   -4  5; ..
                    -6  7   -8  9   -10; ..
                    11  -12 13  -14 15]);

    au8 = uint8([   1   2   3   4   5; ..
                    6   7   8   9   10; ..
                    11  12  13  14  15]);

    a16  = int16([  1   -2  3   -4  5; ..
                    -6  7   -8  9   -10; ..
                    11  -12 13  -14 15]);

    au16 = uint16([ 1   2   3   4   5; ..
                    6   7   8   9   10; ..
                    11  12  13  14  15]);

    a32 = int32([   1   -2  3   -4  5; ..
                    -6  7   -8  9   -10; ..
                    11  -12 13  -14 15]);

    au32 = uint32([ 1   2   3   4   5; ..
                    6   7   8   9   10; ..
                    11  12  13  14  15]);

    [c8, cu8, c16, cu16, c32, cu32] = read_integer(a8, au8, a16, au16, a32, au32);

    if or(c8 <> a8 * 2) then error("failed"), end
    if or(cu8 <> au8 * 4) then error("failed"), end
    if or(c16 <> a16 * 8) then error("failed"), end
    if or(cu16 <> au16 * 16) then error("failed"), end
    if or(c32 <> a32 * 32) then error("failed"), end
    if or(cu32 <> au32 * 64) then error("failed"), end