自学教程：C++ CheckRhs函数代码示例

/*--------------------------------------------------------------------------*/int sci_getsystemmetrics(char *fname, unsigned long l){    char *param = NULL;    int nIndex = -1;    int m1 = 0;    int n1 = 0;    int l1 = 0;    CheckRhs(1, 1);    if (GetType(1) != sci_strings)    {        Scierror(999, _("%s: Wrong type for input argument #%d: String expected./n"), fname, 1);        return 0;    }    GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);    param = cstk(l1);    nIndex = getnIndexFromString(param);    if ( nIndex > -1 )    {        int one = 1;        CreateVar(Rhs + 1, MATRIX_OF_INTEGER_DATATYPE, &one, &one, &l1);        *istk(l1) = GetSystemMetrics(nIndex);        LhsVar(1) = Rhs + 1;        PutLhsVar();    }    else    {        Scierror(999, _("%s: Wrong value for input argument: %s./n"), fname, _("see help"));    }    return 0;}

/*--------------------------------------------------------------------------*/int sci_librarieslist(char *fname, unsigned long fname_len){    char **libraries = NULL;    int sizelibraries = 0;    CheckRhs(0, 0);    CheckLhs(0, 1);    libraries = getlibrarieslist(&sizelibraries);    if (libraries)    {        int m = 0, n = 0;        m = sizelibraries;        n = 1;        CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &m, &n, libraries);    }    else    {        int m = 0, n = 0, l = 0;        CreateVarFromPtr(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &n, &m, &l);    }    LhsVar(1) = Rhs + 1;    freeArrayOfString(libraries, sizelibraries);    PutLhsVar();    return 0;}

/* * Stub function to load the gateway */int sci_loadXcos(char *fname, unsigned long fname_len){    CheckRhs(0, 1);    LhsVar(1) = 0;    PutLhsVar();    return 0;}

/*--------------------------------------------------------------------------*/int sci_iswaitingforinput(char *fname, unsigned long fname_len){    BOOL res = FALSE;    int un = 1, outIndex = 0;    Rhs = Max(Rhs, 0);    CheckRhs(0, 1);    CheckLhs(0, 1);    if (getScilabMode() == SCILAB_STD)    {        res = ConsoleIsWaitingForInput();    }    else    {        sciprint(_("%s: Not implemented in this mode./n"), fname);    }    CreateVar(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &un, &un, &outIndex);    *istk(outIndex) = res;    LhsVar(1) = Rhs + 1;    PutLhsVar();    return 0;}

int int_imread(char * fname){  int mR, nR, lR;  IplImage * pImage;  CheckRhs(1, 1);  CheckLhs(1, 1);  GetRhsVar(1, "c", &mR, &nR, &lR);  // fix default mode for compatibility with previous version of SIVP  pImage = cvLoadImage(cstk(lR), 1);  /* if load image failed */  if(pImage == NULL)    {      Scierror(999, "%s: Can not open file %s./r/n", fname, cstk(lR));      return -1;    }  IplImg2Mat(pImage, 2);  LhsVar(1) = 2;  cvReleaseImage(&pImage);  return 0;}

/*--------------------------------------------------------------------------*/int sci_fromjava(char *fname, unsigned long fname_len){    static int n1;    int *paramoutINT = (int*)MALLOC(sizeof(int) + 1);    Rhs = Max(0, Rhs);    CheckRhs(0, 0);    CheckLhs(1, 1);    if ( IsFromJava() )    {        *paramoutINT = (int)(TRUE);    }    else    {        *paramoutINT = (int)(FALSE);    }    n1 = 1;    CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &paramoutINT);    if (paramoutINT)    {        FREE(paramoutINT);        paramoutINT = NULL;    }    LhsVar(1) = Rhs + 1;    PutLhsVar();    return 0;}

int sci_bug_11046(char *fname){    CheckRhs(0, 0);    sciprint("Overload call macro/n"); // %_myscifun    OverLoad(0);    return 0;}

SipExport intsip_get_verbose_int(char *fname){   int rout,cout,       minlhs=1, maxlhs=1, minrhs=0, maxrhs=0;   char *pout;   CheckRhs(minrhs,maxrhs);   CheckLhs(minlhs,maxlhs);   switch (sip_verbose) {      case SIP_WORDY:         pout = "wordy";         break;      case SIP_QUIET:         pout = "quiet";         break;      default:         sip_error("BUG: internal variable has invalid value (please report)");         break;   }   cout = 1;   rout = strlen(pout);   CreateVarFromPtr(1, "c", &rout, &cout, &pout);   LhsVar(1)=1;      return true;}

/*--------------------------------------------------------------------------*/int sci_gethistoryfile(char *fname, unsigned long fname_len){    char *filename = NULL;    int m1 = 0, n1 = 0;    CheckRhs(0, 0) ;    CheckLhs(0, 1) ;    filename = getFilenameScilabHistory();    if (filename)    {        n1 = 1;        m1 = (int)strlen(filename);        CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &filename);        if (filename)        {            FREE(filename);            filename = NULL;        }        LhsVar(1) = Rhs + 1;        PutLhsVar();    }    else    {        Scierror(999, _("%s: An error occurred: %s/n"), fname, _("filename not defined."));    }    return 0;}

int interface_gravite(char *fname){  static int un = 1, nddl = N_DOF;  static int n, nbis;  static int q, G;  /*    Define minls=1, maxlhs, minrhs, maxrhs   */  static int minlhs = 1, minrhs = 1, maxlhs = 1, maxrhs = 1;  /*   Check rhs and lhs   */  CheckRhs(minrhs, maxrhs) ;  CheckLhs(minlhs, maxlhs) ;  GetRhsVar(1, "d", &n, &nbis, &q);  if (n * nbis != N_DOF)  {    sciprint("Wrong size!/r/n");    Error(999);    return 0;  }  CreateVar(2, "d", &nddl, &un, &G);  modele_gravite(stk(q), stk(G));  LhsVar(1) = 2;  return 0;}

int TagsInterface(char *fname){  static int one = 1, ndof = NDOF;  static int n, nbis;  static int q, N;  /*    Define minls=1, maxlhs, minrhs, maxrhs   */  static int minlhs = 1, minrhs = 2, maxlhs = 1, maxrhs = 2;  /*   Check rhs and lhs   */  CheckRhs(minrhs, maxrhs) ;  CheckLhs(minlhs, maxlhs) ;  GetRhsVar(1, "d", &n, &nbis, &q);  if (n * nbis != NDOF)  {    sciprint("Wrong size!/r/n");    Error(999);    return 0;  }  CreateVar(2, "d", &ndof, &one, &N);  Tags(stk(N), stk(q));  LhsVar(1) = 2;  return 0;}

/*--------------------------------------------------------------------------*/int sci_timer(char *fname,unsigned long fname_len){	double timerval = 0;	Rhs = Max(0, Rhs);	CheckLhs(0,1);	CheckRhs(0,0);	timerval = scilab_timer();	if (timerval >= 0.)	{		int l1 = 0, n1 = 1;		CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE, &n1, &n1,&l1);		*stk(l1) = (double)timerval;		LhsVar(1) = Rhs+1;		PutLhsVar();	}	else	{		Scierror(999,_("%s: An error occurred./n"), fname);	}	return 0;}

/*--------------------------------------------------------------------------*/ int C2F(sci_getlanguagealias)(char *fname,unsigned long fname_len){	static int l1,n1,m1;	char *Output=NULL;	CheckRhs(0,0);	CheckLhs(0,1);	Output=getlanguagealias();	if (Output)	{		n1=1;		CreateVarFromPtr( Rhs+1,STRING_DATATYPE,(m1=(int)strlen(Output), &m1),&n1,&Output);		LhsVar(1) = Rhs+1;		PutLhsVar();;			if (Output) {FREE(Output);Output=NULL;}	}	else	{		m1=0;		n1=0;		l1=0;		CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,  &m1, &n1, &l1);		LhsVar(1)=Rhs+1;		PutLhsVar();;		return 0;	}		return 0;}

/*--------------------------------------------------------------------------*/int sci_deletefile(char *fname,unsigned long fname_len){	CheckRhs(1,1);	CheckLhs(1,1);	if (GetType(1) == sci_strings)	{		int m1,n1,l1;		char *VarName=NULL;		GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);		/* Bug 3089 */		VarName = cstk(l1);		n1=1;		if ( deleteafile(VarName) )		{			CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);			*istk(l1)=(int)(TRUE);		}		else		{			CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);			*istk(l1)=(int)(FALSE);		}		LhsVar(1)=Rhs+1;		PutLhsVar();	}	else	{		Scierror(999,_("%s: Wrong type for input argument: A string expected./n"),fname);	}	return 0;}

/*--------------------------------------------------------------------------*/int sci_ctree2(char *fname, unsigned long fname_len){    int one = 1, ipvec = 0, nvec = 0, mvec = 0, noin = 0, moin = 0, ipoin = 0, noinr = 0, moinr = 0, ipoinr = 0;    int ndep = 0, mdep = 0, ipdep = 0, ndepuptr = 0, mdepuptr = 0, ipdepuptr = 0, ipord = 0, ipok = 0, n = 0, nord = 0;    CheckRhs(5, 5);    CheckLhs(2, 2);    GetRhsVar(1, MATRIX_OF_INTEGER_DATATYPE, &nvec, &mvec, &ipvec);    GetRhsVar(2, MATRIX_OF_INTEGER_DATATYPE, &noin, &moin, &ipoin);    GetRhsVar(3, MATRIX_OF_INTEGER_DATATYPE, &noinr, &moinr, &ipoinr);    GetRhsVar(4, MATRIX_OF_INTEGER_DATATYPE, &ndep, &mdep, &ipdep);    GetRhsVar(5, MATRIX_OF_INTEGER_DATATYPE, &ndepuptr, &mdepuptr, &ipdepuptr);    n = nvec * mvec;    CreateVar(6, MATRIX_OF_INTEGER_DATATYPE, &n, &one, &ipord);    CreateVar(7, MATRIX_OF_INTEGER_DATATYPE, &one, &one, &ipok);    ctree2(istk(ipvec), n, istk(ipdep), istk(ipdepuptr), istk(ipoin), istk(ipoinr), istk(ipord), &nord, istk(ipok));    *istk(iadr(C2F(intersci).iwhere[5]) + 1) = nord;    LhsVar(1) = 6;    LhsVar(2) = 7;    PutLhsVar();    return 0;}

int InertiaInterface(char *fname){    static int ndof = NDOF;    static int n, nbis;    static int q, M;    /*    Define minls=1, maxlhs, minrhs, maxrhs   */    static int minlhs = 1, minrhs = 1, maxlhs = 1, maxrhs = 1;    /*   Check rhs and lhs   */    CheckRhs(minrhs, maxrhs) ;    CheckLhs(minlhs, maxlhs) ;    GetRhsVar(1, "d", &n, &nbis, &q);    if (n * nbis != NDOF)    {        sciprint("Wrong size!/r/n");        Error(999);        return 0;    }    CreateVar(2, "d", &ndof, &ndof, &M);    Inertia(stk(M), stk(q));    LhsVar(1) = 2;    return 0;}

int cdf_generic(char *fname, void* pvApiCtx, struct cdf_descriptor *cdf){    int iErr = 0;    struct cdf_item const * it;    char *option;    CheckRhs(cdf->minrhs, cdf->maxrhs);    CheckLhs(cdf->minlhs, cdf->maxlhs);    option = create_string(pvApiCtx, 1);    for (it = cdf->items; it != cdf->end_item; ++it)    {        if (strcmp(option, it->option) == 0)        {            /* "which" argument (5th) inferred from position in item list */            iErr = CdfBase(fname, pvApiCtx, it->inarg, it->oarg, it->shift, it - cdf->items + 1, cdf->fun);            break;        }    }    destroy_string(option);    if (it == cdf->end_item)    {        /* no target found */        char *optlist;        optlist = cdf_options(cdf);        Scierror(999, _("%s: Wrong value for input argument #%d: Must be in the set {%s}./n"), fname, 1, optlist);        FREE(optlist);        return 1;    }    return iErr;}

/*--------------------------------------------------------------------------*/int sci_type(char *fname, void* pvApiCtx){    SciErr sciErr;    int* piAddr	= NULL;    int iType		= 0;    int iRet = 0;    CheckRhs(1, 1);    CheckLhs(1, 1);    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);    if (sciErr.iErr)    {        printError(&sciErr, 0);        return 0;    }    sciErr = getVarType(pvApiCtx, piAddr, &iType);    if (sciErr.iErr)    {        printError(&sciErr, 0);        return 0;    }    iRet = createMatrixOfDoubleFromInteger(pvApiCtx, Rhs + 1, 1, 1, &iType);    if (iRet)    {        return 0;    }    LhsVar(1) = Rhs + 1;    PutLhsVar();    return 0;}

int sci_exec_if(char *fname){    static int l1, m1, n1;    void *p_sci;    static int l2, m2, n2;    static int minrhs=2, maxrhs=2;    static int err;    debug_3 ("[sci_exec_if] ..................... /r/n");    CheckRhs(minrhs,maxrhs);    // example: pfir1    m1=1;    n1=1;    GetRhsVar(1,"p",&m1,&n1,&l1);    // example: SCI_RESET    GetRhsVar(2, "i", &m2, &n2, &l2);    p_sci = (void *) ((unsigned long int) *stk(l1));    sci_exec_ifcpp(p_sci, *(istk(l2)));    if (sci_err) {        sciprint("/n%s:/n info:%d/n",sci_err_msg,sci_info);        Scierror(999,"%s failed err=%d", fname, sci_err);        return 0;    }    debug_3 ("[sci_exec_if] +++++++++++++++++++++ /r/n");    return 0;}

/*--------------------------------------------------------------------------*/ int sci_loadfftwlibrary(char *fname,unsigned long fname_len){	static int l1,n1,m1;	char *FFTWLibname=NULL;	CheckRhs(1,1);	if (GetType(1) == sci_strings)	{		GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);		FFTWLibname=cstk(l1);		setfftwlibname(FFTWLibname);		n1=1;		if ( LoadFFTWLibrary(FFTWLibname) )		{			CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);			*istk(l1)=(int)(TRUE);		}		else		{			CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);			*istk(l1)=(int)(FALSE);		}		LhsVar(1)=Rhs+1;		PutLhsVar();	}	else	{		 Scierror(999,_("%s: Wrong type for input argument #%d: A string expected./n"),fname,1);	}	return(0);}

int sci_create_if(char *fname){    static int l1, m1, n1;    static int l2, m2, n2;    static int minlhs=1, maxlhs=1;    static int minrhs=1, maxrhs=1;    static int err;    void *p_sci;    debug_1 ("[if_sci_create] ..................... /r/n");    CheckRhs(minrhs,maxrhs);    CheckLhs(minlhs,maxlhs);    // Example: SCI_FIR    GetRhsVar(1, "i", &m1, &n1, &l1);    p_sci = sci_create_ifcpp(*(istk(l1)));    if (p_sci == NULL) {        Scierror(999,"%s failed err=%d", fname, sci_err);    }    else {        /* see C:/Program Files/scicoslab-44b7/examples/interface-tour-so/ex10intc.c */        m2=1;        n2=1;        CreateVarFromPtr(2,"p",&m2,&n2, p_sci);        LhsVar(1) =2; /* return pointer */    }    debug_1 ("p_sci = 0x%X /r/n", p_sci);    debug_1 ("[if_sci_create] +++++++++++++++++++++ /r/n");    return 0;}

/*--------------------------------------------------------------------------*/int sci_xfarcs(char *fname, unsigned long fname_len){    int m1 = 0, n1 = 0, l1 = 0;    int m2 = 0, n2 = 0, l2 = 0;    long hdl = 0;    int i = 0;    double angle1 = 0.0;    double angle2 = 0.0;    CheckRhs(1, 2);    GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);    if (m1 != 6)    {        Scierror(999, _("%s: Wrong size for input argument #%d: %s expected./n"), fname, 1, "(6,n)");        return 0;    }    if (Rhs == 2)    {        GetRhsVar(2, MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);        CheckVector(2, m2, n2);        if (n1 != m2 * n2)        {            Scierror(999, _("%s: Wrong size for input arguments #%d and #%d./n"), fname, 1, 2);            return 0;        }    }    else    {        m2 = 1;        n2 = n1;        CreateVar(2, MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);        for (i = 0; i < n2; ++i)        {            *istk(l2 + i) = i + 1;        }    }    getOrCreateDefaultSubwin();    for (i = 0; i < n1; ++i)    {        angle1 = DEG2RAD(*stk(l1 + (6 * i) + 4) / 64.0);        angle2 = DEG2RAD(*stk(l1 + (6 * i) + 5) / 64.0);        Objarc(&angle1, &angle2, stk(l1 + (6 * i)), stk(l1 + (6 * i) + 1),               stk(l1 + (6 * i) + 2), stk(l1 + (6 * i) + 3), istk(l2 + i), istk(l2 + i), TRUE, FALSE, &hdl);    }    /** Construct Compound and make it current object **/    setCurrentObject(ConstructCompoundSeq(n1));    LhsVar(1) = 0;    PutLhsVar();    return 0;}

/*--------------------------------------------------------------------------*/int sci_xname(char *fname, unsigned long fname_len){    int m1 = 0, n1 = 0, l1 = 0;    char *pstCurrentFigure = NULL;    CheckRhs(1, 1);    CheckLhs(1, 1);    GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);    pstCurrentFigure = getCurrentFigure();    if (pstCurrentFigure == NULL)    {        pstCurrentFigure = createNewFigureWithAxes();    }    setGraphicObjectProperty(pstCurrentFigure, __GO_NAME__, cstk(l1), jni_string, 1);    LhsVar(1) = 0;    PutLhsVar();    return 0;}

/*--------------------------------------------------------------------------*/int C2F(sci_havewindow)(char *fname, unsigned long fname_len){    static int n1, m1;    int *Status = NULL;    CheckRhs(0, 1);    CheckLhs(1, 1);    Status = (int*)MALLOC(sizeof(int));    *Status = (int) ( getScilabMode() == SCILAB_STD );    m1 = 1;    n1 = 1;    CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &Status);    LhsVar(1) = Rhs + 1;    if (Status)    {        FREE(Status);        Status = NULL;    }    PutLhsVar();    return 0;}

/* ========================================================================== */int sci_gpuLoadDynLib(char* fname){    int row         = 0;    int col         = 0;    int* piLen      = NULL;    char** pstData  = NULL;    int* pstrA      = NULL;    int inputType_A = 0;    int  i          = 0;    CheckRhs(1, 1);    CheckLhs(0, 1);    // get lib    getVarAddressFromPosition(pvApiCtx,1,&pstrA);    getVarType(pvApiCtx, pstrA, &inputType_A);    getMatrixOfString(pvApiCtx, pstrA, &row, &col, NULL, NULL);    piLen = (int*)malloc(sizeof(int) * row * col);    getMatrixOfString(pvApiCtx, pstrA, &row, &col, piLen, NULL);    pstData = (char**)malloc(sizeof(char*) * row * col);    for(i = 0 ; i < row * col ; i++)    {        pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));    }    getMatrixOfString(pvApiCtx, pstrA, &row, &col, piLen, pstData);    // open lib    printf("%s/n", *pstData);    Sci_dlopen(*pstData);    LhsVar(1) = Rhs + 1;    PutLhsVar();    return 0;}

int sci_deleteNamedVariable(char *fname, unsigned long fname_len){    SciErr sciErr;    int iRet = 0;    int* piAddr = NULL;    char* pstVarName = NULL;    CheckRhs(1, 1);    CheckLhs(1, 1);    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);    if (sciErr.iErr)    {        printError(&sciErr, 0);        return 1;    }    if (getAllocatedSingleString(pvApiCtx, piAddr, &pstVarName))    {        //error        return 1;    }    if (isNamedVarExist(pvApiCtx, pstVarName))    {        iRet = deleteNamedVariable(pvApiCtx, pstVarName);    }    createScalarBoolean(pvApiCtx, Rhs + 1, iRet);    AssignOutputVariable(pvApiCtx, 1) = Rhs + 1;    return 0;}

/*--------------------------------------------------------------------------*/int sci_tzer(char *fname, unsigned long fname_len){    CheckRhs(4, 4);    CheckLhs(2, 3);    C2F(scitzer)(fname, fname_len);    return 0;}