Pointer reading (Scilab gateway)¶

How to read pointer in a list.

Calling Sequence¶

Input argument profile:

SciErr getPointerInList(void* _pvCtx, int* _piParent, int _iItemPos, void** _pvPtr)

Named variable profile:

SciErr readPointerInNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, void** _pvPtr)

Arguments¶

:_pvCtx Scilab environment pointer, pass in “pvApiCtx” provided by: api_scilab.h.
: :_iVar Position in the Scilab memory where you want to put the: variable.

: :_pstName Name of the variable for “named” functions. : :_piParent Address of the parent of the new item. : :_iItemPos Position of the new item in the list. : :_pvPtr Return pointer on data. : :SciErr Error structure where is stored errors messages history and

first error number.

:

Description¶

This help describes how to read pointer in a list.

Gateway Source¶

#include "api_scilab.h"

static int iTab = 0;
void insert_indent(void)
{
    int i = 0;
    for(i = 0 ; i < iTab ; i++)
    {
            sciprint("\t");
    }
}

int get_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_list_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_double_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_poly_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_boolean_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_sparse_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_bsparse_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_integer_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_string_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_pointer_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);

int common_read(char *fname,unsigned long fname_len)
{
    SciErr sciErr;
    int iItem       = 0;
    int iRet        = 0;
    int *piAddr     = NULL;

    CheckInputArgument(pvApiCtx, 1, 1);

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

    get_info(1, NULL, piAddr, 0);
    AssignOutputVariable(1) = 0;
    return 0;
}

int get_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int iRet    = 0;
    int iType   = 0;

    sciErr = getVarType(pvApiCtx, _piAddr, &iType);
    switch(iType)
    {
    case sci_matrix :
            iRet = get_double_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_poly :
            iRet = get_poly_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_boolean :
            iRet = get_boolean_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_sparse :
            iRet = get_sparse_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_boolean_sparse :
            iRet = get_bsparse_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_ints :
            iRet = get_integer_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_strings :
            iRet = get_string_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_list :
            insert_indent();
            sciprint("List ");
            iRet = get_list_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_tlist :
            insert_indent();
            sciprint("TList ");
            iRet = get_list_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_mlist :
            insert_indent();
            sciprint("MList ");
            iRet = get_list_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_pointer :
            iRet = get_pointer_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    default :
            insert_indent();
            sciprint("Unknown type\n");
            return 1;
    }
    return iRet;
}

int get_list_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int i;
    int iRet        = 0;
    int iItem       = 0;
    int* piChild    = NULL;

    sciErr = getListItemNumber(pvApiCtx, _piAddr, &iItem);
    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    sciprint("(%d)\n", iItem);
    for(i = 0 ; i < iItem ; i++)
    {
            sciErr = getListItemAddress(pvApiCtx, _piAddr, i + 1, &piChild);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            iTab++;
            iRet = get_info(_iRhs, _piAddr, piChild, i + 1);
            iTab--;
    }
    return 0;;
}

int get_double_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int iRows           = 0;
    int iCols           = 0;
    double* pdblReal    = NULL;
    double* pdblImg     = NULL;

    if(_iItemPos == 0)
    {//not in list
            if(isVarComplex(pvApiCtx, _piAddr))
            {
                    sciErr = getComplexMatrixOfDouble(pvApiCtx, _piAddr, &iRows, &iCols, &pdblReal, &pdblImg);
            }
            else
            {
                    sciErr = getMatrixOfDouble(pvApiCtx, _piAddr, &iRows, &iCols, &pdblReal);
            }
    }
    else
    {
            if(isVarComplex(pvApiCtx, _piAddr))
            {
                    sciErr = getComplexMatrixOfDoubleInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &pdblReal, &pdblImg);
            }
            else
            {
                    sciErr = getMatrixOfDoubleInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &pdblReal);
            }
    }

    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    insert_indent();
    sciprint("Double (%d x %d)\n", iRows, iCols);
    return 0;;
}

int get_poly_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int i;
    int iLen            = 0;
    int iRows           = 0;
    int iCols           = 0;
    char pstVar[16];
    int* piCoeff        = NULL;
    double** pdblReal   = NULL;
    double** pdblImg    = NULL;

    sciErr = getPolyVariableName(pvApiCtx, _piAddr, pstVar, &iLen);
    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    if(_iItemPos == 0)
    {//not in list
            sciErr = getMatrixOfPoly(pvApiCtx, _piAddr, &iRows, &iCols, NULL, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            piCoeff     = (int*)malloc(sizeof(int) * iRows * iCols);
            sciErr = getMatrixOfPoly(pvApiCtx, _piAddr, &iRows, &iCols, piCoeff, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            pdblReal    = (double**)malloc(sizeof(double*) * iRows * iCols);
            pdblImg     = (double**)malloc(sizeof(double*) * iRows * iCols);

            for(i = 0 ; i < iRows * iCols ; i++)
            {
                    pdblReal[i] = (double*)malloc(sizeof(double) * piCoeff[i]);
                    pdblImg[i]  = (double*)malloc(sizeof(double) * piCoeff[i]);
            }

            if(isVarComplex(pvApiCtx, _piAddr))
            {
                    sciErr = getComplexMatrixOfPoly(pvApiCtx, _piAddr, &iRows, &iCols, piCoeff, pdblReal, pdblImg);
                    if(sciErr.iErr)
                    {
                            printError(&sciErr, 0);
                            return 0;
                    }
            }
            else
            {
                    sciErr = getMatrixOfPoly(pvApiCtx, _piAddr, &iRows, &iCols, piCoeff, pdblReal);
                    if(sciErr.iErr)
                    {
                            printError(&sciErr, 0);
                            return 0;
                    }
            }
    }
    else
    {
            sciErr = getMatrixOfPolyInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, NULL, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            piCoeff = (int*)malloc(sizeof(int) * iRows * iCols);

            sciErr = getMatrixOfPolyInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, piCoeff, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            pdblReal    = (double**)malloc(sizeof(double*) * iRows * iCols);
            pdblImg     = (double**)malloc(sizeof(double*) * iRows * iCols);

            for(i = 0 ; i < iRows * iCols ; i++)
            {
                    pdblReal[i] = (double*)malloc(sizeof(double) * piCoeff[i]);
                    pdblImg[i]  = (double*)malloc(sizeof(double) * piCoeff[i]);
            }

            if(isVarComplex(pvApiCtx, _piAddr))
            {
                    sciErr = getComplexMatrixOfPolyInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, piCoeff, pdblReal, pdblImg);
            }
            else
            {
                    sciErr = getMatrixOfPolyInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, piCoeff, pdblReal);
            }
    }

    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    insert_indent();
    sciprint("Poly  (%d x %d), varname : \'%s\'\n", iRows, iCols, pstVar);

    for(i = 0 ; i < iRows * iCols ; i++)
    {
            free(pdblReal[i]);
            free(pdblImg[i]);
    }

    free(pdblReal);
    free(pdblImg);
    free(piCoeff);
    return 0;;
}
int get_boolean_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int iRows       = 0;
    int iCols       = 0;
    int* piBool     = NULL;

    if(_iItemPos == 0)
    {
            sciErr = getMatrixOfBoolean(pvApiCtx, _piAddr, &iRows, &iCols, &piBool);
    }
    else
    {
            sciErr = getMatrixOfBooleanInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &piBool);
    }

    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    insert_indent();
    sciprint("Boolean (%d x %d)\n", iRows, iCols);
    return 0;
}
int get_sparse_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int iRows           = 0;
    int iCols           = 0;
    int iItem           = 0;
    int* piNbRow        = NULL;
    int* piColPos       = NULL;
    double* pdblReal    = NULL;
    double* pdblImg     = NULL;

    if(_iItemPos == 0)
    {//Not in list
            if(isVarComplex(pvApiCtx, _piAddr))
            {
                    sciErr = getComplexSparseMatrix(pvApiCtx, _piAddr, &iRows, &iCols, &iItem, &piNbRow, &piColPos, &pdblReal, &pdblImg);
            }
            else
            {
                    sciErr = getSparseMatrix(pvApiCtx, _piAddr, &iRows, &iCols, &iItem, &piNbRow, &piColPos, &pdblReal);
            }
    }
    else
    {
            if(isVarComplex(pvApiCtx, _piAddr))
            {
                    sciErr = getComplexSparseMatrixInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &iItem, &piNbRow, &piColPos, &pdblReal, &pdblImg);
            }
            else
            {
                    sciErr = getSparseMatrixInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &iItem, &piNbRow, &piColPos, &pdblReal);
            }
    }

    insert_indent();
    sciprint("Sparse (%d x %d), Item(s) : %d \n", iRows, iCols, iItem);
    return 0;;
}

int get_bsparse_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int iRows       = 0;
    int iCols       = 0;
    int iItem       = 0;
    int* piNbRow    = NULL;
    int* piColPos   = NULL;

    if(_iItemPos == 0)
    {//Not in list
            sciErr = getBooleanSparseMatrix(pvApiCtx, _piAddr, &iRows, &iCols, &iItem, &piNbRow, &piColPos);
    }
    else
    {
            sciErr = getBooleanSparseMatrixInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &iItem, &piNbRow, &piColPos);
    }

    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    insert_indent();
    sciprint("Boolean Sparse (%d x %d), Item(s) : %d \n", iRows, iCols, iItem);
    return 0;;
}
int get_integer_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int iPrec               = 0;
    int iRows               = 0;
    int iCols               = 0;
    char* pcData            = NULL;
    short* psData           = NULL;
    int* piData             = NULL;
    unsigned char* pucData  = NULL;
    unsigned short* pusData = NULL;
    unsigned int* puiData   = NULL;

    if(_iItemPos == 0)
    {//Not in list
            sciErr = getMatrixOfIntegerPrecision(pvApiCtx, _piAddr, &iPrec);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            switch(iPrec)
            {
            case SCI_INT8 :
                    sciErr = getMatrixOfInteger8(pvApiCtx, _piAddr, &iRows, &iCols, &pcData);
                    break;
            case SCI_INT16 :
                    sciErr = getMatrixOfInteger16(pvApiCtx, _piAddr, &iRows, &iCols, &psData);
                    break;
            case SCI_INT32 :
                    sciErr = getMatrixOfInteger32(pvApiCtx, _piAddr, &iRows, &iCols, &piData);
                    break;
            case SCI_UINT8 :
                    sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, _piAddr, &iRows, &iCols, &pucData);
                    break;
            case SCI_UINT16 :
                    sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, _piAddr, &iRows, &iCols, &pusData);
                    break;
            case SCI_UINT32 :
                    sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, _piAddr, &iRows, &iCols, &puiData);
                    break;
            default :
                    return 1;
            }
    }
    else
    {
            sciErr = getMatrixOfIntegerPrecision(pvApiCtx, _piAddr, &iPrec);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            switch(iPrec)
            {
            case SCI_INT8 :
                    sciErr = getMatrixOfInteger8InList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &pcData);
                    break;
            case SCI_INT16 :
                    sciErr = getMatrixOfInteger16InList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &psData);
                    break;
            case SCI_INT32 :
                    sciErr = getMatrixOfInteger32InList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &piData);
                    break;
            case SCI_UINT8 :
                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &pucData);
                    break;
            case SCI_UINT16 :
                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &pusData);
                    break;
            case SCI_UINT32 :
                    sciErr = getMatrixOfUnsignedInteger32InList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &puiData);
                    break;
            default :
                    return 1;
            }
    }

    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    insert_indent();

    if(iPrec > 10)
    {
            sciprint("Unsigned ");
    }

    sciprint("Integer %d bits (%d x %d)\n", (iPrec % 10) * 8, iRows, iCols);
    return 0;;
}
int get_string_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int i;
    int iRows       = 0;
    int iCols       = 0;
    int* piLen      = NULL;
    char **pstData  = NULL;

    if(_iItemPos == 0)
    {//Not in list
            sciErr = getMatrixOfString(pvApiCtx, _piAddr, &iRows, &iCols, NULL, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            piLen = (int*)malloc(sizeof(int) * iRows * iCols);
            sciErr = getMatrixOfString(pvApiCtx, _piAddr, &iRows, &iCols, piLen, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            pstData = (char**)malloc(sizeof(char*) * iRows * iCols);

            for(i = 0 ; i < iRows * iCols ; i++)
            {
                    pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
            }

            sciErr = getMatrixOfString(pvApiCtx, _piAddr, &iRows, &iCols, piLen, pstData);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }
    }
    else
    {
            sciErr = getMatrixOfStringInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, NULL, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            piLen = (int*)malloc(sizeof(int) * iRows * iCols);

            sciErr = getMatrixOfStringInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, piLen, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            pstData = (char**)malloc(sizeof(char*) * iRows * iCols);

            for(i = 0 ; i < iRows * iCols ; i++)
            {
                    pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
            }

            sciErr = getMatrixOfStringInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, piLen, pstData);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }
    }
    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    insert_indent();
    sciprint("Strings (%d x %d)\n", iRows, iCols);
    return 0;;
}
int get_pointer_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    void* pvPtr     = NULL;

    if(_iItemPos == 0)
    {
            sciErr = getPointer(pvApiCtx, _piAddr, &pvPtr);
    }
    else
    {
            sciErr = getPointerInList(pvApiCtx, _piParent, _iItemPos, &pvPtr);
    }

    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    insert_indent();
    sciprint("Pointer : 0x%08X\n", pvPtr);
    return 0;
}

Scilab test script¶

function read_all()
d = [1,2,3;4,5,6;7,8,9];common_read(d);
s=`poly`_(0,"x");p=1+s+2*s^2;p = [(p * 2),(p * s + 3);(p * 2 * s ** 2 - 6),(12 - 4 * p * (- s) ** 2)];common_read(p);
b = [%t,%f;%t,%f;%f,%t];common_read(b);
sp=`sparse`_([2,-1,0,0,0;-1,2,-1,0,0;0,-1,2,-1,0;0,0,-1,2,-1;0,0,0,-1,2]);common_read(sp);
bsp=`sparse`_([1,2;4,5;3,10],[%t,%t,%t]);common_read(bsp);
i8 = `int8`_([1,2,3]);common_read(i8);
ui32 = `uint32`_([3;2;1]);common_read(ui32);
str = ["may", "the", "puffin"; "be", "with","you"];common_read(str);
if `with_module`_('umfpack') then
    Cp = `taucs_chfact`_(sp);
    l = `list`_(`list`_(d, p, `list`_(b, sp)), `list`_(i8, bsp), `list`_(ui32, str), Cp);
else
    l = `list`_(`list`_(d, p, `list`_(b, sp)), `list`_(i8, bsp), `list`_(ui32, str));
end
common_read(l)
endfunction
read_all;

Pointer reading (Scilab gateway)¶

Calling Sequence¶

Arguments¶

Description¶

Gateway Source¶

Scilab test script¶

Table Of Contents

This Page

Navigation

Pointer reading (Scilab gateway)¶

Calling Sequence¶

Arguments¶

Description¶

Gateway Source¶

Scilab test script¶

Table Of Contents

This Page

Quick search

Navigation