integer example - Integer use case. (original) (raw)

int integerExample(char fname,unsigned long fname_len) { SciErr sciErr; int piAddr = NULL; int iType = 0; int iRet = 0; int iPrec = 0;

CheckRhs(1,1);
CheckLhs(0,1);

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

if(isIntegerType(pvApiCtx, piAddr))
{
    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr, &iPrec);
    if(sciErr.iErr)
    {
        printError(&sciErr, 0);
        return sciErr.iErr;
    }

    switch(iPrec)
    {
    case SCI_INT8 :
        if(isScalar(pvApiCtx, piAddr))
        {
            char cData  = 0;
            iRet = getScalarInteger8(pvApiCtx, piAddr, &cData);
            if(iRet)
            {
                return iRet;
            }

            iRet = createScalarInteger8(pvApiCtx, Rhs + 1, cData);
            if(iRet)
            {
                return iRet;
            }
        }
        else
        {
            int iRows       = 0;
            int iCols       = 0;
            char* pcData    = NULL;

            sciErr = getMatrixOfInteger8(pvApiCtx, piAddr, &iRows, &iCols, &pcData);
            if(sciErr.iErr)
            {
                printError(&sciErr, 0);
                return sciErr.iErr;
            }

            sciErr = createMatrixOfInteger8(pvApiCtx, Rhs + 1, iRows, iCols, pcData);
            if(sciErr.iErr)
            {
                printError(&sciErr, 0);
                return sciErr.iErr;
            }
        }
        break;
    case SCI_INT16 :
        if(isScalar(pvApiCtx, piAddr))
        {
            short sData = 0;
            iRet = getScalarInteger16(pvApiCtx, piAddr, &sData);
            if(iRet)
            {
                return iRet;
            }

            iRet = createScalarInteger16(pvApiCtx, Rhs + 1, sData);
            if(iRet)
            {
                return iRet;
            }
        }
        else
        {
            int iRows       = 0;
            int iCols       = 0;
            short* psData   = NULL;

            sciErr = getMatrixOfInteger16(pvApiCtx, piAddr, &iRows, &iCols, &psData);
            if(sciErr.iErr)
            {
                printError(&sciErr, 0);
                return sciErr.iErr;
            }

            sciErr = createMatrixOfInteger16(pvApiCtx, Rhs + 1, iRows, iCols, psData);
            if(sciErr.iErr)
            {
                printError(&sciErr, 0);
                return sciErr.iErr;
            }
        }
        break;
    case SCI_INT32 :
        if(isScalar(pvApiCtx, piAddr))
        {
            int iData = 0;
            iRet = getScalarInteger32(pvApiCtx, piAddr, &iData);
            if(iRet)
            {
                return iRet;
            }

            iRet = createScalarInteger32(pvApiCtx, Rhs + 1, iData);
            if(iRet)
            {
                return iRet;
            }
        }
        else
        {
            int iRows       = 0;
            int iCols       = 0;
            int* piData     = NULL;

            sciErr = getMatrixOfInteger32(pvApiCtx, piAddr, &iRows, &iCols, &piData);
            if(sciErr.iErr)
            {
                printError(&sciErr, 0);
                return sciErr.iErr;
            }

            sciErr = createMatrixOfInteger32(pvApiCtx, Rhs + 1, iRows, iCols, piData);
            if(sciErr.iErr)
            {
                printError(&sciErr, 0);
                return sciErr.iErr;
            }
        }
        break;

#ifdef SCILAB_INT64 case SCI_INT64 : #endif case SCI_UINT8 : if(isScalar(pvApiCtx, piAddr)) { unsigned char ucData = 0; iRet = getScalarUnsignedInteger8(pvApiCtx, piAddr, &ucData); if(iRet) { return iRet; }

            iRet = createScalarUnsignedInteger8(pvApiCtx, Rhs + 1, ucData);
            if(iRet)
            {
                return iRet;
            }
        }
        else
        {
            int iRows               = 0;
            int iCols               = 0;
            unsigned char* pucData  = NULL;

            sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddr, &iRows, &iCols, &pucData);
            if(sciErr.iErr)
            {
                printError(&sciErr, 0);
                return sciErr.iErr;
            }

            sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, Rhs + 1, iRows, iCols, pucData);
            if(sciErr.iErr)
            {
                printError(&sciErr, 0);
                return sciErr.iErr;
            }
        }
        break;

    case SCI_UINT16 :
        if(isScalar(pvApiCtx, piAddr))
        {
            unsigned short usData = 0;
            iRet = getScalarUnsignedInteger16(pvApiCtx, piAddr, &usData);
            if(iRet)
            {
                return iRet;
            }

            iRet = createScalarUnsignedInteger16(pvApiCtx, Rhs + 1, usData);
            if(iRet)
            {
                return iRet;
            }
        }
        else
        {
            int iRows               = 0;
            int iCols               = 0;
            unsigned short* pusData = NULL;

            sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddr, &iRows, &iCols, &pusData);
            if(sciErr.iErr)
            {
                printError(&sciErr, 0);
                return sciErr.iErr;
            }

            sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, Rhs + 1, iRows, iCols, pusData);
            if(sciErr.iErr)
            {
                printError(&sciErr, 0);
                return sciErr.iErr;
            }
        }
        break;
    case SCI_UINT32 :
        if(isScalar(pvApiCtx, piAddr))
        {
            unsigned int uiData = 0;
            iRet = getScalarUnsignedInteger32(pvApiCtx, piAddr, &uiData);
            if(iRet)
            {
                return iRet;
            }

            iRet = createScalarUnsignedInteger32(pvApiCtx, Rhs + 1, uiData);
            if(iRet)
            {
                return iRet;
            }
        }
        else
        {
            int iRows               = 0;
            int iCols               = 0;
            unsigned int* puiData   = NULL;

            sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddr, &iRows, &iCols, &puiData);
            if(sciErr.iErr)
            {
                printError(&sciErr, 0);
                return sciErr.iErr;
            }

            sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, Rhs + 1, iRows, iCols, puiData);
            if(sciErr.iErr)
            {
                printError(&sciErr, 0);
                return sciErr.iErr;
            }
        }
        break;

#ifdef SCILAB_INT64 case SCI_UINT64 : #endif default : break; } } return 0;}