/*--------------------------------------------------------------------------*/
static int TwoLhs(struct VariableStruct* Vstruct,int lenStructArray,BOOL Sorted)
{
char **Tab=NULL;
int *Size=NULL;
int i=0;
int m=0;
int n=0;
if (Sorted) SortVarsStructByStrings(Vstruct,lenStructArray);
Tab=(char **)MALLOC(sizeof(char*)*lenStructArray);
Size=(int *)MALLOC(sizeof(int)*lenStructArray);
for (i=0;i<lenStructArray;i++)
{
Tab[i] = strdup(Vstruct[i].NameVariable);
Size[i]=Vstruct[i].SizeVariable;
}
m=lenStructArray;
n=1;
CreateVarFromPtr(Rhs+1,MATRIX_OF_STRING_DATATYPE, &m, &n, Tab);
LhsVar(1) = Rhs+1;
CreateVarFromPtr(Rhs+2,MATRIX_OF_INTEGER_DATATYPE, &m, &n, &Size);
LhsVar(2) = Rhs+2;
freeArrayOfString(Tab, lenStructArray);
if (Size) {FREE(Size);Size=NULL;}
PutLhsVar();
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;
}
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_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, ¶moutINT);
if (paramoutINT)
{
FREE(paramoutINT);
paramoutINT = NULL;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
SipExport int
sip_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;
}
/*--------------------------------------------------------------------------*/
static int sci_stacksizeNoRhs(char *fname)
{
int n1 = 0, m1 = 0;
int *paramoutINT = NULL;
int total = 0;
int used = 0;
paramoutINT = (int *)MALLOC(sizeof(int) * 2);
C2F(getstackinfo) (&total, &used);
paramoutINT[0] = total;
paramoutINT[1] = used;
n1 = 1;
m1 = 2;
CreateVarFromPtr(Rhs + 1, MATRIX_OF_INTEGER_DATATYPE, &n1, &m1, (int *)¶moutINT);
LhsVar(1) = Rhs + 1;
if (paramoutINT)
{
FREE(paramoutINT);
paramoutINT = NULL;
}
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
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 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;
}
/*--------------------------------------------------------------------------*/
static int OneLhs(struct VariableStruct* Vstruct,int lenStructArray,BOOL Sorted)
{
int i=0;
int m=0;
int n=0;
char **LocalTab = NULL;
if (Sorted) SortVarsStructByStrings(Vstruct,lenStructArray);
LocalTab=(char **)MALLOC(sizeof(char*)*(lenStructArray));
for (i=0;i<lenStructArray;i++)
{
if (strlen(Vstruct[i].NameVariable)>0)
{
LocalTab[i] = strdup(Vstruct[i].NameVariable);
}
}
m=lenStructArray;
n=1;
CreateVarFromPtr(Rhs+1,MATRIX_OF_STRING_DATATYPE, &m, &n,LocalTab);
LhsVar(1)=Rhs+1;
freeArrayOfString(LocalTab, lenStructArray);
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;
}
/*--------------------------------------------------------------------------*/
static int sci_emptystr_one_rhs(char *fname)
{
int m1 = 0, n1 = 0; /* m1 is the number of row ; n1 is the number of col*/
/*With a matrix for input argument returns a zero length character strings matrix of the same size */
int Type = VarType(1);
if (Type == sci_matrix)
{
char **Input_StringMatrix_One = NULL;
GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &Input_StringMatrix_One);
if ((m1 == 0) && (n1 == 0)) /* emptystr([]) */
{
int l = 0;
CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l);
LhsVar(1) = Rhs + 1 ;
PutLhsVar();
return 0;
}
}
else
{
if ((Type == sci_mlist) || (Type == sci_tlist))
{
/* compatibility with 4.1.2 */
int lw = 1 + Top - Rhs;
C2F(overload)(&lw, fname, (int)strlen(fname));
return 0;
}
else
{
int RHSPOS = 1;
int l1 = 0;
int il = 0;
int lw = RHSPOS + Top - Rhs;
l1 = *Lstk(lw);
il = iadr(l1);
if (*istk(il ) < 0)
{
il = iadr(*istk(il + 1));
}
/* get dimensions */
m1 = getNumberOfLines(il); /* row */
n1 = getNumberOfColumns(il); /* col */
}
}
/* m1 is the number of row ; n1 is the number of col*/
CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, NULL);
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int C2F(sci_clearfun)(char *fname, unsigned long fname_len)
{
static int l1 = 0, n1 = 0, m1 = 0;
int *Status = NULL;
CheckRhs(1, 1);
CheckLhs(1, 1);
if (GetType(1) == sci_strings)
{
char *VarName = NULL;
int id[nsiz];
int zero = 0;
int fptr = 0;
int job = 0;
GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
VarName = cstk(l1);
Status = (int*)MALLOC(sizeof(int));
C2F(cvname)(id, VarName, &zero, (unsigned long)strlen(VarName));
job = SCI_HFUNCTIONS_FIND; /* Find function & returns fptr value */
C2F(funtab)(id, &fptr, &job, "NULL_NAME", 0);
if (fptr != 0)
{
job = SCI_HFUNCTIONS_DELETE; /* delete function entry */
C2F(funtab)(id, &fptr, &job, "NULL_NAME", 0);
*Status = TRUE;
}
else /* fptr = 0 function doesn't exist */
{
*Status = FALSE;
}
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();
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
return 0;
}
return 0;
}
/*--------------------------------------------------------------------------*/
static int sci_emptystr_two_rhs(char *fname)
{
/*value_param_pos_1 is the number of row ; value_param_pos_2 is the number of col*/
int Type_One = GetType(1);
int Type_Two = GetType(2);
if ((Type_One == sci_matrix) && (Type_Two == sci_matrix))
{
double value_param_pos_1 = 0;
double value_param_pos_2 = 0;
int matrixdimension = 0;
int m1 = 0, n1 = 0, l1 = 0;
int m2 = 0, n2 = 0, l2 = 0;
GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
value_param_pos_1 = *stk(l1);
value_param_pos_2 = *stk(l2);
matrixdimension = (int)(value_param_pos_1 * value_param_pos_2);
if (matrixdimension > 0)
{
int m = (int)value_param_pos_1;
int n = (int)value_param_pos_2;
CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &m, &n, NULL);
}
else
{
/* returns [] */
int l = 0;
int m = 0;
int n = 0;
CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &m, &n, &l);
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
else
{
if (Type_One != sci_matrix)
{
Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of integers expected.\n"), fname, 1);
}
else /* Type_Two */
{
Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of integers expected.\n"), fname, 2);
}
}
return 0;
}
/*--------------------------------------------------------------------------*/
int C2F(sci_getos)(char *fname,unsigned long fname_len)
{
static int n1 = 0, m1 = 0;
char *OperatingSystem = getOSFullName();
Rhs = Max(0,Rhs);
CheckRhs(0,0);
CheckLhs(1,2);
if (OperatingSystem)
{
n1 = 1;
CreateVarFromPtr( Rhs+1,STRING_DATATYPE,(m1=(int)strlen(OperatingSystem), &m1),&n1,&OperatingSystem);
if (OperatingSystem) {FREE(OperatingSystem); OperatingSystem = NULL;}
LhsVar(1)=Rhs+1;
if (Lhs == 2)
{
char *Release = getOSRelease();
if (Release)
{
n1 = 1;
CreateVarFromPtr(Rhs+ 2,STRING_DATATYPE,(m1=(int)strlen(Release), &m1),&n1,&Release);
if (Release) {FREE(Release); Release = NULL;}
LhsVar(2) = Rhs + 2;
}
else
{
Scierror(999,_("%s: No more memory.\n"),fname);
return 0;
}
}
PutLhsVar();
}
else
{
Scierror(999,_("%s: No more memory.\n"),fname);
}
return 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;
}
/*--------------------------------------------------------------------------*/
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;
}
/*--------------------------------------------------------------------------*/
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;
}
/*
* 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;
}
/*--------------------------------------------------------------------------*/
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;
}
/*--------------------------------------------------------------------------*/
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;
}
/*----------------------------------------------------------------------------*/
int sci_strrev(char *fname,unsigned long fname_len)
{
CheckRhs(1,1);
CheckLhs(0,1);
if (GetType(1) == sci_strings)
{
int m1 = 0; int n1 = 0;
char **InputStrings = NULL;
int m1n1 = 0; /* m1 * n1 */
char **OutputStrings = NULL;
GetRhsVar(1,MATRIX_OF_STRING_DATATYPE,&m1,&n1,&InputStrings);
m1n1 = m1 * n1;
OutputStrings = strings_strrev(InputStrings,m1n1);
if (OutputStrings)
{
CreateVarFromPtr(Rhs+1,MATRIX_OF_STRING_DATATYPE,&m1,&n1,OutputStrings);
freeArrayOfString(InputStrings,m1n1);
freeArrayOfString(OutputStrings,m1n1);
LhsVar(1) = Rhs+1 ;
PutLhsVar();
}
else
{
freeArrayOfString(InputStrings,m1n1);
Scierror(999,_("%s: No more memory.\n"),fname);
return 0;
}
}
else
{
Scierror(999,_("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"),fname,1);
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_findfiles(char *fname, unsigned long fname_len)
{
static int l1 = 0, n1 = 0, m1 = 0;
char *pathextented = NULL;
char *path = NULL;
char *filespec = NULL;
char **FilesList = NULL;
int sizeListReturned = 0;
Rhs = Max(Rhs, 0);
CheckRhs(0, 2);
CheckLhs(0, 1);
switch (Rhs)
{
default:
case 0:
{
int ierr = 0;
path = scigetcwd(&ierr);
if (ierr)
{
Scierror(999, _("%s: Error while trying to retrieve the name of the current directory.\n"), fname);
return 0;
}
else
{
filespec = strdup(DEFAULT_FILESPEC);
}
}
break;
case 1:
{
if (GetType(1) == sci_strings)
{
GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
path = strdup(cstk(l1));
filespec = strdup(DEFAULT_FILESPEC);
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
return 0;
}
}
break;
case 2:
{
if ((GetType(1) == sci_strings) && (GetType(2) == sci_strings))
{
GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
path = strdup(cstk(l1));
GetRhsVar(2, STRING_DATATYPE, &m1, &n1, &l1);
filespec = strdup(cstk(l1));
}
else
{
Scierror(999, _("%s: Wrong type for input arguments: Strings expected.\n"), fname);
return 0;
}
}
break;
}
pathextented = expandPathVariable(path);
if (path)
{
FREE(path);
path = NULL;
}
FilesList = findfiles(pathextented, filespec, &sizeListReturned, FALSE);
if (pathextented)
{
FREE(pathextented);
pathextented = NULL;
}
if (filespec)
{
FREE(filespec);
filespec = NULL;
}
if (FilesList)
{
int ncol = 0, nrow = 0;
ncol = 1;
nrow = sizeListReturned;
CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &nrow, &ncol, FilesList);
LhsVar(1) = Rhs + 1;
}
else
{
n1 = 0;
m1 = 0;
l1 = 0;
CreateVarFromPtr(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &n1, &m1, &l1);
LhsVar(1) = Rhs + 1;
}
freeArrayOfString(FilesList, sizeListReturned);
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_mcisendstring(char *fname, unsigned long l)
{
int m1, n1, l1;
char *Output = NULL;
int *BoolOutput = NULL;
int *CodeOutput = NULL;
CheckRhs(1, 1);
CheckLhs(1, 3);
if (GetType(1) == sci_strings)
{
MCIERROR Error;
char *MCICommand = NULL;
char ReturnString[2048];
GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
MCICommand = cstk(l1);
Error = mciSendString(MCICommand, (LPSTR)ReturnString, sizeof(ReturnString), NULL);
BoolOutput = (int*)MALLOC(sizeof(int));
CodeOutput = (int*)MALLOC(sizeof(int));
*BoolOutput = (int)0;
*CodeOutput = (int)Error;
if (Error)
{
char ErrorText[128];
*BoolOutput = (int)FALSE;
if ( mciGetErrorString(Error, ErrorText, sizeof(ErrorText)) == FALSE )
{
wsprintf(ErrorText, "%s", "Unknown MCI error");
}
Output = strdup(ErrorText);
}
else
{
*BoolOutput = (int)TRUE;
Output = strdup("OK");
}
n1 = 1;
if ( Lhs == 1 )
{
CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &BoolOutput);
LhsVar(1) = Rhs + 1;
}
else if ( Lhs == 2 )
{
CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &BoolOutput);
LhsVar(1) = Rhs + 1;
CreateVarFromPtr(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &n1, &n1, &CodeOutput);
LhsVar(2) = Rhs + 2;
}
else /* Lhs == 3 */
{
CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &BoolOutput);
LhsVar(1) = Rhs + 1;
CreateVarFromPtr(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &n1, &n1, &CodeOutput);
LhsVar(2) = Rhs + 2;
m1 = (int)strlen(Output);
CreateVarFromPtr(Rhs + 3, STRING_DATATYPE, &m1, &n1, &Output);
LhsVar(3) = Rhs + 3;
}
if (Output)
{
FREE(Output);
Output = NULL;
}
if (BoolOutput)
{
FREE(BoolOutput);
BoolOutput = NULL;
}
if (CodeOutput)
{
FREE(CodeOutput);
Output = NULL;
}
PutLhsVar();
return 0;
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
return 0;
}
}
/*--------------------------------------------------------------------------*/
int C2F(sci_predef)(char *fname,unsigned long fname_len)
{
int previous_n_var_protected = 0;
Rhs = Max(0, Rhs);
CheckRhs(0,1);
CheckLhs(0,1);
previous_n_var_protected = getNumberPredefVariablesProtected();
if (Rhs == 0)
{
int one = 1 ,l = 0;
CreateVar(Rhs+1, MATRIX_OF_INTEGER_DATATYPE, &one, &one,&l);
*istk(l) = (int) previous_n_var_protected;
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
else /* Rhs == 1 */
{
int *out_values = NULL;
int nout = 0 , mout = 0;
int new_n_var_protected = 0;
if ( VarType(1) == sci_matrix )
{
int m1 = 0, n1 = 0, l1 = 0;
GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
if ( (m1 == n1) && (n1 == 1) )
{
double dn_var = *stk(l1);
int n_var = (int) dn_var;
if (dn_var != (double)n_var)
{
Scierror(999,_("%s: Wrong value for input argument #%d: A int expected.\n"),fname,1);
return 0;
}
setNumberPredefVariablesProtected(n_var);
}
else
{
Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname,1);
return 0;
}
}
else if ( VarType(1) == sci_strings )
{
int m1 = 0, n1 = 0, l1 = 0;
char *protectMode = NULL;
GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
protectMode = cstk(l1);
if (protectMode)
{
if ( ((strlen(protectMode) == 1 ) && (protectMode[0] == 'c')) ||
(strcmp(protectMode,"clear") == 0) )
{
clearPredef();
}
else if ( ((strlen(protectMode) == 1 ) && (protectMode[0] == 'a')) ||
(strcmp(protectMode,"all") == 0) )
{
predefAll();
}
else if (strcmp(protectMode,"names") == 0)
{
int nbElements = 0;
char **variablesPredef = getPredefinedVariablesName(&nbElements);
if (variablesPredef && (nbElements > 0))
{
SciErr sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, nbElements, 1, variablesPredef);
freeArrayOfString(variablesPredef, nbElements);
variablesPredef = NULL;
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999,_("%s: Memory allocation error.\n"), fname);
}
else
{
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
return 0;
}
else
{
createEmptyMatrix(pvApiCtx, Rhs + 1);
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
}
else
{
Scierror(999,_("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"),fname,1,"clear","all");
return 0;
}
}
}
else
{
Scierror(999,_("%s: Wrong type for input argument #%d: A scalar or a string expected.\n"),fname,1);
return 0;
}
new_n_var_protected = getNumberPredefVariablesProtected();
out_values = (int*)MALLOC(sizeof(int)*2);
out_values[0] = previous_n_var_protected;
out_values[1] = new_n_var_protected;
nout = 1 ; mout = 2;
CreateVarFromPtr(Rhs+1,MATRIX_OF_INTEGER_DATATYPE, &nout, &mout, &out_values);
if (out_values) {FREE(out_values); out_values = NULL;}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_setlookandfeel(char *fname, unsigned long fname_len)
{
CheckRhs(0, 1);
CheckLhs(0, 1);
org_scilab_modules_gui_utils::LookAndFeelManager * lnf = 0;
if (Rhs == 0)
{
try
{
lnf = new org_scilab_modules_gui_utils::LookAndFeelManager(getScilabJavaVM());
}
catch (const GiwsException::JniException & e)
{
Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
return FALSE;
}
if (lnf)
{
int n1 = 1;
int *paramoutINT = (int *)MALLOC(sizeof(int));
*paramoutINT = (int)booltoBOOL(lnf->setSystemLookAndFeel());
delete lnf;
n1 = 1;
CreateVarFromPtr(Rhs + 1,
const_cast<char *>(MATRIX_OF_BOOLEAN_DATATYPE),
&n1, &n1, ¶moutINT);
LhsVar(1) = Rhs + 1;
if (paramoutINT)
{
FREE(paramoutINT);
paramoutINT = NULL;
}
PutLhsVar();
}
else
{
Scierror(999, _("%s: No more memory.\n"), fname);
}
}
else if (GetType(1) == sci_strings)
{
int m1, n1 = 0, l1 = 0;
char *looknfeel = NULL;
GetRhsVar(1, const_cast<char *>(STRING_DATATYPE), &m1, &n1, &l1);
looknfeel = cstk(l1);
try
{
lnf = new org_scilab_modules_gui_utils::LookAndFeelManager(getScilabJavaVM());
}
catch (const GiwsException::JniException & e)
{
Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
return FALSE;
}
if (lnf)
{
int *paramoutINT = (int *)MALLOC(sizeof(int));
*paramoutINT = (int)booltoBOOL(lnf->setLookAndFeel(looknfeel));
delete lnf;
n1 = 1;
CreateVarFromPtr(Rhs + 1,
const_cast<char *>(MATRIX_OF_BOOLEAN_DATATYPE),
&n1, &n1, ¶moutINT);
LhsVar(1) = Rhs + 1;
if (paramoutINT)
{
FREE(paramoutINT);
paramoutINT = NULL;
}
PutLhsVar();
}
else
{
Scierror(999, _("%s: No more memory.\n"), fname);
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
}
return 0;
}
/*----------------------------------------------------------
* int_imread:
* interface for imread function.
* should provide [RGB]=imread(name)
* [Index,Map]=imread(name) at Scilab level
*
* TO-DO
* - return on errors, even if exeption is NULL
*
* $Revision: 1.2 $ $Date: 2009-03-29 21:34:48 $
*----------------------------------------------------------*/
SipExport int
int_imread(char *fname)
{
/* Interface variables */
HyperMat *Img;
int m1, n1,l1, /* for name input argument */
m2, n2, /* for index output argument */
minlhs=1, maxlhs=2, minrhs=1, maxrhs=1, i;
double *l2;
/* Other variables */
unsigned long imgsize;
/* ImageMagick variables */
ExceptionInfo exception;
Image *image;
ImageInfo *image_info;
PixelPacket *pix;
ImageType imgtype;
bool stat;
CheckRhs(minrhs,maxrhs) ;
CheckLhs(minlhs,maxlhs) ;
/* Get name (#1) */
GetRhsVar(1, "c", &m1, &n1, &l1);
/* Initialize the image info structure and read an image. */
InitializeMagick(NULL);
GetExceptionInfo(&exception);
image_info=CloneImageInfo((ImageInfo *) NULL);
(void) strncpy(image_info->filename,cstk(l1),MaxTextExtent);
image=ReadImage(image_info,&exception);
if (image == (Image *) NULL) {
/* clean up */
if(exception.reason != NULL) {
char errmsg[50];
for (i=0; i<49; i++)
errmsg[i]=' ';
errmsg[49]='\0';
strncpy(errmsg,SipGetLocaleExceptionMessage(exception.severity,exception.reason),50);
DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
DestroyMagick();
sip_error(errmsg);
}
DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
DestroyMagick();
sip_error("unknown reason");
}
m2 = image->rows; n2 = image->columns;
if (sip_verbose == SIP_WORDY)
sciprint("Size:\t%ld rows X %ld columns\n\r", m2, n2);
imgsize = m2 * n2;
pix=GetImagePixels(image, 0, 0, n2, m2);
if(pix == (PixelPacket *) NULL)
SIP_MAGICK_ERROR;
switch(image->storage_class) {
case DirectClass: {
imgtype = GetImageType(image, &exception);
if(imgtype == BilevelType) {
stat = magick_binary_image_to_double_array(fname,pix,&l2, m2, n2);
if (!stat) return false;
CreateVarFromPtr(2, "d",&m2,&n2,&l2);
free(l2);
} else {
stat= magick_truecolor_image_to_double_hypermat(fname,pix,&Img,m2,n2);
if (!stat) return false;
CreateHMat(2,Img);
free_sci_tru_img(&Img);
}
m1 = n1 = 0;
CreateVar(3,"d",&m1,&n1,&l1);
break;
}
case PseudoClass: {
stat= magick_index_map_to_sci_dbl(fname,image,2);
if (!stat) return false;
break;
}
default:
sip_error("unknown color class");
break;
}
LhsVar(1) = 2;
LhsVar(2) = 3;
/* Terminate Imagemagick */
DestroyImageInfo(image_info);
DestroyImage(image);
DestroyExceptionInfo(&exception);
DestroyMagick();
return true;
}
/*--------------------------------------------------------------------------*/
int sci_xls_open(char *fname, unsigned long fname_len)
{
#undef IN
#define max_char_xls_open 256
int i = 0, m1 = 0, n1 = 0, l1 = 0, l2 = 0, one = 1, fd = 0, f_swap = 0;
int ierr = 0, ns = 0, result = 0;
double res;
char **sst = NULL;
char **Sheetnames = NULL;
int *Abspos = NULL;
int nsheets = 0;
char *filename_IN = NULL;
char TMP[max_char_xls_open];
char sep[2];
char *TMPDIR = NULL;
#ifdef _MSC_VER
sep[0] = '\\';
#else
sep[0] = '/';
#endif
sep[1] = '\0';
CheckLhs(4, 4);
CheckRhs(1, 1);
if (VarType(1) != sci_strings)
{
Scierror(999, "%s: Invalid type of input argument: String expected.", fname);
return 0;
}
/* checking variable file */
GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
filename_IN = expandPathVariable(cstk(l1));
if (filename_IN)
{
/* bug 5615 */
/* remove blank characters @ the end */
int len = (int)strlen(filename_IN);
int i = 0;
if (len >= 1)
{
for (i = len - 1; i >= 0; i--)
{
if (filename_IN[i] == ' ')
{
filename_IN[i] = '\0';
}
else
{
break;
}
}
}
if (!FileExist(filename_IN))
{
Scierror(999, _("The file %s does not exist.\n"), filename_IN);
return 0;
}
}
TMPDIR = getTMPDIR();
strcpy(TMP, TMPDIR);
if (TMPDIR)
{
FREE(TMPDIR);
TMPDIR = NULL;
}
strcat(TMP, sep);
strcat(TMP, xls_basename(filename_IN));
result = ripole(filename_IN, TMP, 0, 0);
if (result != OLE_OK)
{
if (result == OLEER_NO_INPUT_FILE)
{
Scierror(999, _("The file %s does not exist.\n"), filename_IN);
}
else if (result == OLEER_NOT_OLE_FILE ||
result == OLEER_INSANE_OLE_FILE ||
result == OLEER_LOADFAT_BAD_BOUNDARY || result == OLEER_MINIFAT_READ_FAIL || result == OLEER_PROPERTIES_READ_FAIL)
{
Scierror(999, _("%s: File %s is not an ole2 file.\n"), fname, filename_IN);
if (filename_IN)
{
FREE(filename_IN);
filename_IN = NULL;
}
}
else if (result == -1)
{
Scierror(999, _("%s: Cannot open file %s.\n"), fname, filename_IN);
if (filename_IN)
{
FREE(filename_IN);
filename_IN = NULL;
}
}
return 0;
}
strcat(TMP, sep);
strcat(TMP, "Workbook");
C2F(mopen) (&fd, TMP, "rb", &f_swap, &res, &ierr);
if (ierr != 0)
{
Scierror(999, _("%s: There is no xls stream in the ole2 file %s.\n"), fname, filename_IN);
if (filename_IN)
{
FREE(filename_IN);
filename_IN = NULL;
}
return 0;
}
if (filename_IN)
{
FREE(filename_IN);
filename_IN = NULL;
}
CreateVar(Rhs + 1, MATRIX_OF_INTEGER_DATATYPE, &one, &one, &l2);
*istk(l2) = fd; /* logical unit */
xls_open(&ierr, &fd, &sst, &ns, &Sheetnames, &Abspos, &nsheets);
/*return *err:
* 0 = OK
* 1 = not an OLE file
* 2 = no Workbook included
* 3 = memory allocation problem
* 4 = incorrect file
* 5 = not a BIFF8 xls file
*/
switch (ierr)
{
case 0:
/* OK */
break;
case 1:
Scierror(999, _("%s: Not an ole2 file.\n"), fname);
return 0;
case 2:
Scierror(999, _("%s: The file has no Workbook directory.\n"), fname);
return 0;
case 3:
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
case 4:
Scierror(990, _("%s: Incorrect or corrupted file.\n"), fname);
return 0;
case 5:
Scierror(999, _("%s: Only BIFF8 file format is handled.\n"), fname);
return 0;
default:
break;
}
if (ns != 0)
{
/* Create a typed list to return the properties */
CreateVarFromPtr(Rhs + 2, MATRIX_OF_STRING_DATATYPE, &one, &ns, sst);
freeArrayOfString(sst, ns);
}
else
{
CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &ns, &ns, &l2);
}
if (nsheets != 0)
{
/* Create a typed list to return the properties */
CreateVarFromPtr(Rhs + 3, MATRIX_OF_STRING_DATATYPE, &one, &nsheets, Sheetnames);
freeArrayOfString(Sheetnames, nsheets);
CreateVar(Rhs + 4, MATRIX_OF_DOUBLE_DATATYPE, &one, &nsheets, &l2);
for (i = 0; i < nsheets; i++)
{
*stk(l2 + i) = Abspos[i];
}
if (Abspos)
{
FREE(Abspos);
Abspos = NULL;
}
}
else
{
CreateVar(Rhs + 3, MATRIX_OF_DOUBLE_DATATYPE, &nsheets, &nsheets, &l2);
CreateVar(Rhs + 4, MATRIX_OF_DOUBLE_DATATYPE, &nsheets, &nsheets, &l2);
}
LhsVar(1) = Rhs + 1;
LhsVar(2) = Rhs + 2;
LhsVar(3) = Rhs + 3;
LhsVar(4) = Rhs + 4;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_xls_read(char *fname, unsigned long fname_len)
{
int m1 = 0, n1 = 0, l1 = 0, zero = 0, ierr = 0;
double *data = NULL;
int *ind = NULL;
int M = 0, N = 0, MN = 0;
int pos = 0, fd = 0;
CheckLhs(2, 2);
CheckRhs(2, 2);
if (VarType(1) != sci_matrix)
{
Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 1);
return 0;
}
if (VarType(2) != sci_matrix)
{
Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 2);
return 0;
}
/* checking variable fd */
GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
fd = (int) * stk(l1);
/* checking variable Pos */
GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
pos = (int) * stk(l1);
xls_read(&fd, &pos, &data, &ind, &N, &M, &ierr);
switch (ierr)
{
case 1 :
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
break;
case 2 :
Scierror(999, _("%s: Failed to read expected data, may be invalid xls file.\n"), fname);
return 0;
break;
case 3 :
Scierror(999, _("%s: End of file.\n"), fname);
return 0;
break;
default :
/* no error */
break;
}
MN = M * N;
if (MN == 0)
{
CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &zero, &zero, &l1);
CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &zero, &zero, &l1);
}
else
{
CreateVarFromPtr(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &N, &M, &data);
CreateVarFromPtr(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &N, &M, &ind);
FREE(data);
data = NULL;
FREE(ind);
ind = NULL;
}
LhsVar(1) = Rhs + 1;
LhsVar(2) = Rhs + 2;
PutLhsVar();
return 0;
}
/*----------------------------------------------------------------------------*/
int sci_strstr(char *fname, unsigned long fname_len)
{
CheckRhs(2, 2);
CheckLhs(0, 1);
if ( (GetType(1) == sci_strings) && (GetType(2) == sci_strings) )
{
int m1 = 0;
int n1 = 0;
char **InputString_Parameter1 = NULL;
int m1n1 = 0; /* m1 * n1 */
int m2 = 0;
int n2 = 0 ;
char **InputString_Parameter2 = NULL;
int m2n2 = 0; /* m2 * n2 */
GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, &InputString_Parameter1);
m1n1 = m1 * n1;
GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &m2, &n2, &InputString_Parameter2);
m2n2 = m2 * n2;
if (m2n2 == 0)
{
freeArrayOfString(InputString_Parameter1, m1n1);
freeArrayOfString(InputString_Parameter2, m2n2);
Scierror(999, _("%s: Wrong size for input argument #%d: Non-empty matrix of strings expected.\n"), fname, 2);
return 0;
}
else
{
int j = 0;
if ( ((m1 == m2) && (n1 == n2)) || (m2n2 == 1) )
{
char **OutputStrings = NULL;
OutputStrings = (char**)CALLOC(m1n1, sizeof(char*));
if (OutputStrings == NULL)
{
freeArrayOfString(InputString_Parameter1, m1n1);
freeArrayOfString(InputString_Parameter2, m2n2);
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
for (j = 0; j < m1n1; j++)
{
int i = 0;
if (m2n2 == 1)
{
i = 0; /* Second input argument is one dimensional */
}
else
{
i = j; /* First and second input arguments have same size */
}
if (strlen(InputString_Parameter1[j]) < strlen(InputString_Parameter2[i]))
{
OutputStrings[j] = strdup("");
if (OutputStrings[j] == NULL)
{
freeArrayOfString(OutputStrings, m1n1);
freeArrayOfString(InputString_Parameter1, m1n1);
freeArrayOfString(InputString_Parameter2, m2n2);
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
}
else
{
char *ptrstrstr = strstr(InputString_Parameter1[j], InputString_Parameter2[i]);
if (ptrstrstr)
{
OutputStrings[j] = strdup(ptrstrstr);
if (OutputStrings[j] == NULL)
{
freeArrayOfString(OutputStrings, m1n1);
freeArrayOfString(InputString_Parameter1, m1n1);
freeArrayOfString(InputString_Parameter2, m2n2);
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
}
else
{
OutputStrings[j] = strdup("");
if (OutputStrings[j] == NULL)
{
freeArrayOfString(OutputStrings, m1n1);
freeArrayOfString(InputString_Parameter1, m1n1);
freeArrayOfString(InputString_Parameter2, m2n2);
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
}
}
}
CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, OutputStrings);
freeArrayOfString(OutputStrings, m1n1);
freeArrayOfString(InputString_Parameter1, m1n1);
freeArrayOfString(InputString_Parameter2, m2n2);
LhsVar(1) = Rhs + 1 ;
PutLhsVar();
}
else
{
freeArrayOfString(InputString_Parameter1, m1n1);
freeArrayOfString(InputString_Parameter2, m2n2);
Scierror(999, _("%s: Wrong size for input argument #%d.\n"), fname, 2);
return 0;
}
}
}
else
{
if (GetType(1) != sci_strings)
{
Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 1);
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 2);
}
}
return 0;
}
