Beispiel #1
0
int ScilabGateway::exists(char * fname, const int envId, void * pvApiCtx)
{
    SciErr err;
    int * addr = 0;
    int * id = 0;
    int row = 0;
    int col = 0;
    bool exists = false;

    CheckInputArgument(pvApiCtx, 1, 1);
    CheckOutputArgument(pvApiCtx, 1, 1);

    ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
    ScilabGatewayOptions & options = env.getGatewayOptions();
    OptionsHelper::setCopyOccured(false);
    ScilabObjects::initialization(env, pvApiCtx);
    options.setIsNew(false);

    err = getVarAddressFromPosition(pvApiCtx, 1, &addr);
    if (err.iErr)
    {
        throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
    }

    if (!ScilabObjects::isExternalObjOrClass(addr, pvApiCtx))
    {
        throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: An External Object expected."), 1);
        return 0;
    }

    err = getMatrixOfInteger32InList(pvApiCtx, addr, EXTERNAL_OBJ_ID_POSITION, &row, &col, &id);
    if (err.iErr)
    {
        throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
    }

    try
    {
        exists = env.isvalidobject(*id);
    }
    catch (std::exception & e)
    {
        throw;
    }

    createScalarBoolean(pvApiCtx, 1, exists ? 1 : 0);

    LhsVar(1) = 1;
    PutLhsVar();

    return 0;
}
Beispiel #2
0
/*--------------------------------------------------------------------------*/
static int setStacksizeMax(char *fname)
{
    /* we backup previous size */
    unsigned long backupSize = getCurrentStacksize();

    /* Bug 5495 on Windows 2000 -- WONT FIX GetLargestFreeMemoryRegion */
    /* it works on XP, Vista, S7ven */
    /* GetLargestFreeMemoryRegion() returns a superior size to real value */
    unsigned long maxmemfree = (GetLargestFreeMemoryRegion()) / sizeof(double);

    /* We have already max */
    if (maxmemfree <= backupSize)
    {
        LhsVar(1) = 0;
        C2F(putlhsvar) ();
        return 0;
    }

    /* we do a stacksize('min') */
    if (setStacksizeMin(fname) == 0)
    {
        unsigned long memmaxavailablebyscilab = get_max_memory_for_scilab_stack();
        unsigned long newMemSizeMax = maxmemfree;
        int errCode;

        if (memmaxavailablebyscilab < newMemSizeMax)
        {
            newMemSizeMax = memmaxavailablebyscilab;
        }

        if (newMemSizeMax < MIN_STACKSIZE)
        {
            newMemSizeMax = MIN_STACKSIZE;
        }

        errCode = setStacksize(newMemSizeMax);
        if (errCode != 0)
        {
            setStacksize(backupSize);
            Scierror(10001, _("%s: Cannot allocate memory.\n%s\n"), fname, getStackCreationErrorMessage(errCode));
        }
        return 0;
    }
    else
    {
        /* stacksize('min') fails */
        /* restore previous size */
        setStacksize(backupSize);
        Scierror(10001, _("%s: Cannot allocate memory.\n"), fname);
    }
    return 0;
}
Beispiel #3
0
/*--------------------------------------------------------------------------*/
static int sci_stacksizeMin(char *fname)
{
    if (setStacksizeMin(fname) == 0)
    {
        LhsVar(1) = 0;
        PutLhsVar();
    }
    else
    {
        Scierror(10001, _("%s: Cannot allocate memory.\n"), fname);
    }
    return 0;
}
Beispiel #4
0
/*--------------------------------------------------------------------------*/
int C2F(sci_banner)(char *fname,unsigned long fname_len)
{
	Rhs=Max(Rhs,0);
	CheckRhs(0,0) ;
	CheckLhs(0,1) ;

	banner();

	LhsVar(1) = 0;
	PutLhsVar();	

	return 0;
}
Beispiel #5
0
/*--------------------------------------------------------------------------*/
int C2F(sci_what)(char *fname, unsigned long fname_len)
{
    int sizecommandwords = 0;
    char **commandwords = getcommandkeywords(&sizecommandwords);

    Rhs = Max(0, Rhs);
    CheckRhs(0, 0);
    CheckLhs(1, 2);

    CreateLocalFunctionsTab();
    qsort( LocalFunctionsTab , SizeLocalFunctionsTab ,  sizeof (char *)  , cmpfunctionnames);

    if (Lhs == 1)
    {
        DispInternalFunctions();
        DispCommands();
        LhsVar(1) = 0;
    }
    else /* Lhs == 2 */
    {
        int ncol = 1;
        int nrowFunctions = SizeLocalFunctionsTab;
        int nrowCommands = sizecommandwords;

        CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &nrowFunctions, &ncol, LocalFunctionsTab);
        LhsVar(1) = Rhs + 1;

        CreateVarFromPtr(Rhs + 2, MATRIX_OF_STRING_DATATYPE, &nrowCommands, &ncol, commandwords);
        LhsVar(2) = Rhs + 2;

        freeArrayOfString(LocalFunctionsTab, nrowFunctions);
        freeArrayOfString(commandwords, nrowCommands);

    }

    PutLhsVar();
    return 0;
}
Beispiel #6
0
/*--------------------------------------------------------------------------*/
int sci_oemtochar(char *fname, unsigned long l)
{
    int l1 = 0, n1 = 0, m1 = 0;
    char *Output = NULL;

    if (getWarningMode())
    {
        sciprint(_("%s: Feature %s is obsolete.\n"), _("Warning"), fname);
        sciprint(_("%s: This feature will be permanently removed in Scilab %s\n\n"), _("Warning"), "5.4.1");
    }

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

    if (GetType(1) == sci_strings)
    {
        char *OEMstring = NULL;

        GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
        OEMstring = cstk(l1);

        Output = (char*)MALLOC((strlen(OEMstring) + 1) * sizeof(char));
        if (getScilabMode() == SCILAB_STD)
        {
            OemToChar(OEMstring, Output);
        }
        else
        {
            wsprintf(Output, "%s", OEMstring);
        }
    }
    else
    {
        Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
        return 0;
    }

    n1 = 1;
    m1 = (int)strlen(Output);
    CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &Output);
    if (Output)
    {
        FREE(Output);
        Output = NULL;
    }

    LhsVar(1) = Rhs + 1;
    PutLhsVar();
    return 0;
}
Beispiel #7
0
int ScilabGateway::remove(char * fname, const int envId, void * pvApiCtx)
{
    SciErr err;
    int * addr = 0;

    ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
    ScilabGatewayOptions & options = env.getGatewayOptions();
    OptionsHelper::setCopyOccured(false);
    ScilabObjects::initialization(env, pvApiCtx);
    options.setIsNew(false);

    if (Rhs == 0)
    {
        env.garbagecollect();

        LhsVar(1) = 0;
        PutLhsVar();

        return 0;
    }

    for (int i = 1; i <= Rhs; i++)
    {
        err = getVarAddressFromPosition(pvApiCtx, i, &addr);
        if (err.iErr)
        {
            throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
        }

        ScilabObjects::removeVar(addr, pvApiCtx);
    }

    LhsVar(1) = 0;
    PutLhsVar();

    return 0;
}
Beispiel #8
0
/*--------------------------------------------------------------------------*/
int sci_xinit(char * fname, void *pvApiCtx)
{
    SciErr err;
    int * addr = 0;
    char * path = 0;
    char * realPath = 0;

    CheckInputArgument(pvApiCtx, 1, 1);

    err = getVarAddressFromPosition(pvApiCtx, 1, &addr);
    if (err.iErr)
    {
        printError(&err, 0);
        Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
        return 0;
    }

    if (!isStringType(pvApiCtx, addr) || !checkVarDimension(pvApiCtx, addr, 1, 1))
    {
        Scierror(999, gettext("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
        return 0;
    }

    if (getAllocatedSingleString(pvApiCtx, addr, &path) != 0)
    {
        Scierror(999, _("%s: No more memory.\n"), fname);
        return 0;
    }

    realPath = expandPathVariable(path);

    if (realPath)
    {
        org_scilab_modules_graphic_export::Driver::setPath(getScilabJavaVM(), realPath);
        FREE(realPath);
    }
    else
    {
        Scierror(999, _("%s: Invalid path: %s.\n"), fname, path);
        return 0;
    }

    freeAllocatedSingleString(path);

    LhsVar(1) = 0;
    PutLhsVar();

    return 0;
}
Beispiel #9
0
/*--------------------------------------------------------------------------*/
int sci_mtell(char *fname, unsigned long fname_len)
{
    int m1 = 0, n1 = 0, l1 = 0;
    int one = 1;
    int l2 = 0, err = 0;
    int fd = ALL_FILES_DESCRIPTOR;

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

    /*  checking variable file */
    if ( Rhs >= 1)
    {
        if (GetType(1) == sci_matrix)
        {
            GetRhsVar(1, MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &l1);
            if (m1*n1 == 1)
            {
                fd = *istk(l1);
            }
            else
            {
                Scierror(999, _("%s: Wrong size for input argument #%d: An integer expected.\n"), fname, 1);
                return 0;
            }
        }
        else
        {
            Scierror(999, _("%s: Wrong type for input argument #%d: An integer expected.\n"), fname, 1);
            return 0;
        }
    }

    CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &one, &one, &l2);

    C2F(mtell)(&fd, stk(l2), &err);

    if (err >  0)
    {
        SciError(10000);
        return 0;
    }

    LhsVar(1) = Rhs + 1;
    PutLhsVar();

    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;
}
Beispiel #11
0
int sci_view(char *fname) 
{
  static int l1, m1, n1, l2, m2, n2, m3, n3, l3;
  static int minlhs=1, maxlhs=3, minrhs=3, maxrhs=3;

  /* Check number of inputs (rhs=3) and outputs (lhs=3) */
  CheckRhs(minrhs,maxrhs) ;
  CheckLhs(minlhs,maxlhs) ;

  /* Get X (1 ,double), Y (2, int) and  C (3, string) */
  GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
  GetRhsVar(2,MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);
  GetRhsVar(3,STRING_DATATYPE, &m3, &n3, &l3);

  /* Call display function
     stk(l1)->X (double), istk(l2)->Y (int), cstk(l3)->Z  (char)    */
  displ(stk(l1), m1, n1, istk(l2), m2, n2, cstk(l3), m3, n3);

  /*  Return variables  */
  LhsVar(1) = 1;
  LhsVar(2) = 2;
  LhsVar(3) = 3;
  return 0;
}
Beispiel #12
0
/*--------------------------------------------------------------------------*/
int sci_xpause(char *fname, unsigned long fname_len)
{
    int m1 = 0, n1 = 0, l1 = 0, sec = 0;

    CheckLhs(0, 1);
    CheckRhs(1, 1);
    if (Rhs == 1)
    {
        GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
        CheckScalar(1, m1, n1);
        sec = (int)  * stk(l1);
        if (sec <= 0)
        {
            Scierror(999, _("%s: Wrong values for input argument #%d: Non-negative integers expected.\n"), fname, 1);
            return 0;
        }

#ifdef _MSC_VER
        {
            int ms = (sec) / 1000; /** time is specified in milliseconds in scilab**/
            if (ms > 0)
            {
                Sleep(ms);    /* Number of milliseconds to sleep. */
            }
        }
#else
        {
            unsigned useconds;
            useconds = (unsigned) sec;
            if (useconds != 0)
#ifdef HAVE_USLEEP
            {
                usleep(useconds);
            }
#else
#ifdef HAVE_SLEEP
            {
                sleep(useconds);
            }
#endif
#endif
        }
#endif
    }
    LhsVar(1) = 0;
    PutLhsVar();
    return 0;
}
Beispiel #13
0
/*--------------------------------------------------------------------------*/
int sci_tohome(char *fname, void* pvApiCtx)
{

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

    if (!tohome())
    {
        sciprint(_("%s: This feature has not been implemented in this mode.\n"), fname);
    }

    LhsVar(1) = 0;
    PutLhsVar();

    return 0 ;
}
Beispiel #14
0
//
// FIXME: Remove GW after Scilab 5.4.0
//
int sci_clear_pixmap(char *fname, unsigned long fname_len )
{
    CheckRhs(0, 0);
    CheckLhs(0, 1);

    if (getWarningMode())
    {
        sciprint(_("%s: Function %s is obsolete.\n"), _("Warning"), fname);
        sciprint(_("%s: Please use %s instead.\n"), _("Warning"), "drawlater/drawnow");
        sciprint(_("%s: This function will be permanently removed in Scilab %s\n\n"), _("Warning"), "5.4.1");
    }

    LhsVar(1) = 0;
    PutLhsVar();
    return 0;
}
Beispiel #15
0
int sci_bug_9708(char *fname)
{
  SciErr sciErr;
  const char varname[] = "iputhereavariabletoolongforscilabandthereisnoerror";
  
  sciErr = createNamedMatrixOfString(pvApiCtx, varname, 1, 1, &varname);
  if(sciErr.iErr)
  {
    printError(&sciErr, 0);
    Scierror(999, _("%s: Invalid variable name.\n"), fname);
    return 0;
  }

  LhsVar(1) = 1;
  return 0;
}
/*--------------------------------------------------------------------------*/
int sci_getfilepartlevel(char *fname, unsigned long fname_len)
{
    CheckRhs(1, 1);
    CheckLhs(1, 1);

    if (GetType(1) == sci_strings)
    {
        int m = 0, n = 0;
        char **InputString = NULL;

        GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &m, &n, &InputString);
        if ( (m == 1) && (n == 1) )
        {
            char *result = NULL;
            result = getFilePartLevel(InputString[0]);
            if (result == NULL)
            {
                int l = 0;
                m = 0, n = 0;
                CreateVar(Rhs + 1, STRING_DATATYPE,  &m, &n, &l);
            }
            else
            {
                n = 1;
                CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, (m = (int)strlen(result), &m), &n, &result);
                if (result)
                {
                    FREE(result);
                    result = NULL;
                }
            }

            LhsVar(1) = Rhs + 1;
        }
        else
        {
            freeArrayOfString(InputString, m * n);
            Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
        }
    }
    else
    {
        Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
    }

    return 0;
}
/*--------------------------------------------------------------------------*/ 
int C2F(sci_getlanguagestable)(char *fname,unsigned long fname_len)
{
	static int n1,m1;
	char **Output=NULL;

	int i=0;

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

	Output=(char**)MALLOC(sizeof(char*)*2* NumberLanguages);
	
	for (i=0;i<NumberLanguages;i++)
	{
		char *alphacode=NULL;
		char *language=NULL;

		alphacode=(char*)MALLOC((strlen(LANGUAGE_COUNTRY_TAB[i].alphacode)+1)*sizeof(char));
		strcpy(alphacode,LANGUAGE_COUNTRY_TAB[i].alphacode);

		language=(char*)MALLOC((strlen(LANGUAGE_COUNTRY_TAB[i].languagedescription)+1)*sizeof(char));
		strcpy(language,LANGUAGE_COUNTRY_TAB[i].languagedescription);

		Output[i]=alphacode;
		Output[NumberLanguages+i]=language;

	}
	
	m1=NumberLanguages;
	n1=2;
	CreateVarFromPtr( Rhs+1,MATRIX_OF_STRING_DATATYPE,&m1,&n1,Output);
	LhsVar(1) = Rhs+1;
	PutLhsVar();;	

	if (Output) 
	{
		for (i=0;i<NumberLanguages;i++)
		{
			FREE(Output[i]);
			Output[i]=NULL;
			FREE(Output[NumberLanguages+i]);
			Output[NumberLanguages+i]=NULL;
		}
	}

	return 0;
}
Beispiel #18
0
int ScilabGateway::getClasspath(char * fname, const int envId, void * pvApiCtx)
{
    CheckInputArgument(pvApiCtx, 0, 0);

    ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
    ScilabGatewayOptions & options = env.getGatewayOptions();
    OptionsHelper::setCopyOccurred(false);
    ScilabObjects::initialization(env, pvApiCtx);
    options.setIsNew(false);

    env.getclasspath(ScilabStringStackAllocator(pvApiCtx, Rhs + 1));

    LhsVar(1) = Rhs + 1;
    PutLhsVar();

    return 0;
}
Beispiel #19
0
/*
 * sets SIP verbosity level
 * TODO
 *    - even in quiet mode, all function should output useful 
 *    info/debug/error codes in a global variable (sip_ans_msg)
 */
SipExport int
sip_set_verbose_int(char *fname)
{
   int rname,cname,pname,
       rout,cout,
       minlhs=1, maxlhs=1, minrhs=0, maxrhs=1;

   char *prev;

   CheckRhs(minrhs,maxrhs);
   CheckLhs(minlhs,maxlhs);

   /* print previous value */
   switch (sip_verbose) {
      case SIP_WORDY:
         prev = "wordy";
         break;
      case SIP_QUIET:
         prev = "quiet";
         break;
      default:
         sip_error("BUG: internal variable has invalid value (please report)");
         break;
   }

   cout = 1;
   rout = strlen(prev);
   CreateVarFromPtr(2, "c", &rout, &cout, &prev);

   
   if (Rhs == 0) 
      /* toggle previous value */
      sip_verbose = (sip_verbose == SIP_QUIET) ? SIP_WORDY : SIP_QUIET;
   else { 
      /* set new value */
      GetRhsVar(1, "c", &rname, &cname, &pname); 
      if (cname == 1 && *cstk(pname) == 'q')
         sip_verbose = SIP_QUIET;
      else
         sip_verbose = SIP_WORDY;
   }

   LhsVar(1)=2;
   
   return true;
}
Beispiel #20
0
/*--------------------------------------------------------------------------*/
int sci_getpid(char *fname, unsigned long fname_len)
{
    int one = 1;
    int l1 = 0;
    int pid = 0;

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

    C2F(getpidc)(&pid);
    CreateVar(Rhs + 1, MATRIX_OF_INTEGER_DATATYPE, &one, &one, &l1);
    *istk(l1) = (int) pid;

    LhsVar(1) = Rhs + 1;
    PutLhsVar();
    return 0;
}
Beispiel #21
0
int NdofInterface(char *fname)
{
    static int un = 1, nddl;

    /*    Define minls=1,  maxlhs   */
    static int minlhs = 1,  maxlhs = 1;

    /*   Check lhs   */
    CheckLhs(minlhs, maxlhs) ;

    CreateVar(1, "d", &un, &un, &nddl);

    Ndof(istk(nddl));

    LhsVar(1) = 1;
    return 0;
}
Beispiel #22
0
int
introundmode (char *fname)
{
  int direct;
  int t, u, v;

  CheckRhs (1, 1);
  CheckLhs (1, 1);
  
  GetRhsVar (1, "i", &t, &u, &direct);
  CreateVar (2, "i", &t, &u, &v);
  
  *istk (v) = roundmode(istk (direct)); 
  
  LhsVar (1) = 2;
  
  return 0;
}
Beispiel #23
0
/*--------------------------------------------------------------------------*/
static int sci_format_norhs(char *fname)
{
    SciErr sciErr;
    double dParamout[2];

    getFormat(&dParamout[0], &dParamout[1]);

    sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, 1, 2, dParamout);
    if (sciErr.iErr)
    {
        printError(&sciErr, 0);
        Scierror(999, _("%s: Memory allocation error.\n"), fname);
        return 0;
    }
    LhsVar(1) = Rhs + 1;
    PutLhsVar();
    return 0;
}
/*--------------------------------------------------------------------------*/
int sci_system_setproperty(char *fname,unsigned long fname_len)
{
	Rhs = Max(Rhs,0);
	CheckRhs(2,2);
	CheckLhs(1,1);

	if ( (GetType(1) == sci_strings) && (GetType(2) == sci_strings) )
	{
		static int m1,n1=0,l1=0;
		static int m2,n2=0,l2=0;
		char *propertyName = NULL;
		char *propertyValue = NULL;
		char *previousValue = NULL;

		GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
		propertyName = cstk(l1);

		GetRhsVar(2,STRING_DATATYPE,&m2,&n2,&l2);
		propertyValue = cstk(l2);

		previousValue = system_setproperty(propertyName,propertyValue);

		if (previousValue)
		{
			n1=1;
			CreateVarFromPtr(Rhs+1,STRING_DATATYPE,(m1=(int)strlen(propertyValue), &m1),&n1,&previousValue);
		}
		else
		{
			n1 = 0;
			m1 = 0;
			l1 = 0;
			CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,&n1,&m1,&l1);
		}
		LhsVar(1)=Rhs+1;
		if (previousValue) {FREE(previousValue); previousValue = NULL;}
        PutLhsVar();
	}
	else
	{
		Scierror(999,_("%s: Wrong type for input argument #%d or #%d: String expected.\n"),fname, 1, 2);
	}
	return 0;
}
Beispiel #25
0
/*--------------------------------------------------------------------------*/
int sci_opentk(char *fname, unsigned long l)
{
    Tcl_Interp *TCLinterpLocal = NULL;

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

    TCLinterpLocal = Tcl_CreateInterp();
    Tcl_Init(TCLinterpLocal);
    Tk_Init(TCLinterpLocal);
    TKmainWindow = Tk_MainWindow(TCLinterpLocal);
    Tk_GeometryRequest(TKmainWindow, 200, 200);
    Tk_SetWindowBackground(TKmainWindow, WhitePixelOfScreen(Tk_Screen(TKmainWindow)));

    LhsVar(1) = 0;
    PutLhsVar();

    return 0;
}
Beispiel #26
0
/*--------------------------------------------------------------------------*/
int sci_filesep(char *fname, unsigned long fname_len)
{
    int n1, m1;
    char *separator;

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

    /* Pass as reference as it will always be copied into the stack */
    separator = DIR_SEPARATOR;

    n1 = 1;
    m1 = (int) strlen(separator);
    CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &separator);
    LhsVar(1) = Rhs + 1;

    PutLhsVar();

    return 0;
}
Beispiel #27
0
SipExport int 
imvariance_int(char *fname) 
{
  static int l1, m1, n1, l2;
  static int minlhs=1, maxlhs=1, minrhs=1, maxrhs=1;

  /* Check number of inputs and outputs */
  CheckRhs(minrhs,maxrhs);
  CheckLhs(minlhs,maxlhs);

  /*Input parameters: */
  GetRhsVar(1, "d", &m1, &n1, &l1); 

  CreateVar(2, "d", &m1, &n1, &l2);

  imvariance(stk(l1), stk(l2), m1, n1);

  LhsVar(1) = 2;
  return 0;
}
Beispiel #28
0
/*--------------------------------------------------------------------------*/
int sci_is_handle_valid(char *fname, unsigned long fname_len)
{

    /* Call isValid = is_handle_valid(h) with h a matrix of handle */
    /* and isValid a matrix of boolean */

    int nbCol = 0;
    int nbRow = 0;
    int nbHandle = 0;
    int handleStackPointer = 0;
    int resultStackPointer = 0;
    int i = 0;

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

    /* Get handles matrix */
    if (VarType(1) != sci_handles)
    {
        Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of handle expected.\n"), fname, 1);
        return  -1;
    }

    GetRhsVar(1, (char *)GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &handleStackPointer);
    nbHandle = nbRow * nbCol;

    /* create output matrix */
    CreateVar(Rhs + 1, (char *)MATRIX_OF_BOOLEAN_DATATYPE, &nbRow, &nbCol, &resultStackPointer);

    /* Check each handle */
    for (i = 0; i < nbHandle; i++)
    {
        *istk(resultStackPointer + i) = ((getObjectFromHandle((long)getHandleFromStack((size_t)(handleStackPointer + i))) != NULL)
                                         ? TRUE : FALSE);
    }

    LhsVar(1) = Rhs + 1;
    PutLhsVar();

    return 0;
}
Beispiel #29
0
/*--------------------------------------------------------------------------*/
int sci_win64(char *fname,unsigned long l)
{
	BOOL Status = FALSE;

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

#ifdef _WIN64
	Status = TRUE;
#endif

    if(createScalarBoolean(pvApiCtx, Rhs + 1, Status) != 0)
    {
        return 1;
    }

	LhsVar(1) = Rhs + 1;

    PutLhsVar();
	return 0;
}
Beispiel #30
0
/*--------------------------------------------------------------------------*/
int sci_winopen(char *fname, unsigned long l)
{
    int m1 = 0, n1 = 0, l1 = 0;

    CheckRhs(1, 1);

    GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);

    if (winopen(cstk(l1)))
    {
        LhsVar(1) = 0;
    }
    else
    {
        Scierror(999, _("%s: Cannot open file %s.\n"), fname, cstk(l1));
        return 0;
    }

    PutLhsVar();
    return 0;
}