/*--------------------------------------------------------------------------*/
int sci_fscanfMat(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
int m1 = 0, n1 = 0;
int iType1 = 0;
char *filename = NULL;
char *expandedFilename = NULL;
char *Format = NULL;
char *separator = NULL;
BOOL bIsDefaultSeparator = TRUE;
fscanfMatResult *results = NULL;
CheckRhs(1, 3);
CheckLhs(1, 2);
if (Rhs == 3)
{
int *piAddressVarThree = NULL;
int m3 = 0, n3 = 0;
int iType3 = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
return 0;
}
if (isStringType(pvApiCtx, piAddressVarThree) == 0 || isScalar(pvApiCtx, piAddressVarThree) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 3);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarThree, &separator))
{
freeVar(&filename, &expandedFilename, &Format, &separator);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
bIsDefaultSeparator = FALSE;
}
if (Rhs >= 2)
{
int *piAddressVarTwo = NULL;
int m2 = 0, n2 = 0;
int iType2 = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if (sciErr.iErr)
{
freeVar(&filename, &expandedFilename, &Format, &separator);
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarTwo, &iType2);
if (sciErr.iErr)
{
freeVar(&filename, &expandedFilename, &Format, &separator);
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
if (isStringType(pvApiCtx, piAddressVarTwo) == 0 || isScalar(pvApiCtx, piAddressVarTwo) == 0)
{
freeVar(&filename, &expandedFilename, &Format, &separator);
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarTwo, &Format))
{
freeVar(&filename, &expandedFilename, &Format, &separator);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
Format = os_strdup(DEFAULT_FSCANFMAT_FORMAT);
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
freeVar(&filename, &expandedFilename, &Format, &separator);
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (isStringType(pvApiCtx, piAddressVarOne) == 0 || isScalar(pvApiCtx, piAddressVarOne) == 0)
{
freeVar(&filename, &expandedFilename, &Format, &separator);
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &filename))
{
freeVar(&filename, &expandedFilename, &Format, &separator);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
expandedFilename = expandPathVariable(filename);
if (bIsDefaultSeparator)
{
#define NB_DEFAULT_SUPPORTED_SEPARATORS 2
/* bug 8148 */
/* default separator can be a space or a tabulation */
char *supportedSeparators[NB_DEFAULT_SUPPORTED_SEPARATORS] = {DEFAULT_FSCANFMAT_SEPARATOR, "\t"};
int i = 0;
for (i = 0; i < NB_DEFAULT_SUPPORTED_SEPARATORS; i++)
{
results = fscanfMat(expandedFilename, Format, supportedSeparators[i]);
if (results && results->err == FSCANFMAT_NO_ERROR)
{
break;
}
freeFscanfMatResult(results);
}
}
else
{
results = fscanfMat(expandedFilename, Format, separator);
}
if (results == NULL)
{
freeVar(&filename, &expandedFilename, &Format, &separator);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
freeVar(NULL, &expandedFilename, &Format, &separator);
switch (results->err)
{
case FSCANFMAT_NO_ERROR:
{
if ( (results->values) && (results->m > 0) && (results->n > 0))
{
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, results->m, results->n, results->values);
if (sciErr.iErr)
{
FREE(filename);
freeFscanfMatResult(results);
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
if (createEmptyMatrix(pvApiCtx, Rhs + 1))
{
FREE(filename);
freeFscanfMatResult(results);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
LhsVar(1) = Rhs + 1;
if (Lhs == 2)
{
if (results->text)
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 2, results->sizeText, 1, (char const * const*) results->text);
if (sciErr.iErr)
{
FREE(filename);
freeFscanfMatResult(results);
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
if (createSingleString(pvApiCtx, Rhs + 2, ""))
{
FREE(filename);
freeFscanfMatResult(results);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
LhsVar(2) = Rhs + 2;
}
freeFscanfMatResult(results);
FREE(filename);
PutLhsVar();
return 0;
}
case FSCANFMAT_MOPEN_ERROR:
{
Scierror(999, _("%s: can not open file %s.\n"), fname, filename);
FREE(filename);
return 0;
}
case FSCANFMAT_READLINES_ERROR:
{
Scierror(999, _("%s: can not read file %s.\n"), fname, filename);
FREE(filename);
return 0;
}
case FSCANFMAT_FORMAT_ERROR:
{
Scierror(999, _("%s: Invalid format.\n"), fname);
FREE(filename);
return 0;
}
case FSCANFMAT_MEMORY_ALLOCATION:
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
FREE(filename);
return 0;
}
default:
case FSCANFMAT_ERROR:
{
Scierror(999, _("%s: error.\n"), fname);
FREE(filename);
return 0;
}
}
FREE(filename);
freeFscanfMatResult(results);
return 0;
}
// =============================================================================
// csvWrite(M, filename[, separator, decimal, precision]) */
// with M string or double (not complex)
// =============================================================================
int sci_csvWrite(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int iErr = 0;
csvWriteError csvError = CSV_WRITE_ERROR;
char *separator = NULL;
char *decimal = NULL;
char *filename = NULL;
char *precisionFormat = NULL;
char **pHeadersLines = NULL;
int nbHeadersLines = 0;
char **pStringValues = NULL;
double *pDoubleValuesReal = NULL;
double *pDoubleValuesImag = NULL;
int bIsComplex = 0;
int mValues = 0;
int nValues = 0;
int *piAddressVarTwo = NULL;
int m2 = 0, n2 = 0;
int iType2 = 0;
int *piAddressVarOne = NULL;
int m1 = 0, n1 = 0;
int iType1 = 0;
CheckRhs(2, 6);
CheckLhs(1, 1);
if (Rhs > 5)
{
int isOnlyRowOrCol = 0;
int m6 = 0;
int n6 = 0;
pHeadersLines = csv_getArgumentAsMatrixOfString(pvApiCtx, 6, fname, &m6, &n6, &iErr);
if (iErr)
{
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
return 0;
}
isOnlyRowOrCol = ((m6 > 1) && (n6 == 1)) || ((m6 == 1) && (n6 > 1)) || ((m6 == 1) && (n6 == 1));
if (!isOnlyRowOrCol)
{
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
Scierror(999, _("%s: Wrong size for input argument #%d: A 1-by-n or m-by-1 array of strings expected.\n"), fname, 6);
return 0;
}
nbHeadersLines = m6 * n6;
}
if (Rhs > 4)
{
if (csv_isDoubleScalar(pvApiCtx, 5))
{
#define FORMAT_FIELDVALUESTR "%%.%dlg"
int iFormatValue = (int) csv_getArgumentAsScalarDouble(pvApiCtx, 5, fname, &iErr);
if (iErr)
{
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
return 0;
}
if ((iFormatValue < 1) || (iFormatValue > 17))
{
Scierror(999, _("%s: Wrong value for input argument #%d: A double (value 1 to 17) expected.\n"), fname, 5);
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
return 0;
}
precisionFormat = (char*)MALLOC(sizeof(char) * ((int)strlen(FORMAT_FIELDVALUESTR) + 1));
if (precisionFormat == NULL)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
return 0;
}
sprintf(precisionFormat, FORMAT_FIELDVALUESTR, iFormatValue);
}
else
{
precisionFormat = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 5, fname, getCsvDefaultPrecision(), &iErr);
if (iErr)
{
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
return 0;
}
if (checkCsvWriteFormat(precisionFormat))
{
Scierror(999, _("%s: Not supported format %s.\n"), fname, precisionFormat);
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
return 0;
}
}
}
else
{
precisionFormat = os_strdup(getCsvDefaultPrecision());
}
if (Rhs > 3)
{
decimal = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 4, fname, getCsvDefaultDecimal(), &iErr);
if (iErr)
{
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
return 0;
}
if (strcmp(decimal, ".") && strcmp(decimal, ","))
{
//invalid value
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), "write_csv", 4, ".", ",");
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
return 1;
}
}
else
{
decimal = os_strdup(getCsvDefaultDecimal());
}
if (Rhs > 2)
{
separator = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 3, fname, getCsvDefaultSeparator(), &iErr);
if (iErr)
{
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
return 0;
}
}
else
{
separator = os_strdup(getCsvDefaultSeparator());
}
filename = csv_getArgumentAsString(pvApiCtx, 2, fname, &iErr);
if (iErr)
{
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
printError(&sciErr, 0);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType1);
if (sciErr.iErr)
{
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
printError(&sciErr, 0);
return 0;
}
if (iType1 == sci_strings)
{
pStringValues = csv_getArgumentAsMatrixOfString(pvApiCtx, 1, fname, &m1, &n1, &iErr);
if (iErr)
{
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
return 0;
}
}
else if (iType1 == sci_matrix)
{
if (isVarComplex(pvApiCtx, piAddressVarOne))
{
bIsComplex = 1;
sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddressVarOne, &m1, &n1, &pDoubleValuesReal, &pDoubleValuesImag);
}
else
{
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &m1, &n1, &pDoubleValuesReal);
}
if (sciErr.iErr)
{
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
printError(&sciErr, 0);
return 0;
}
}
else
{
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
Scierror(999, _("%s: Wrong type for input argument #%d: A matrix of string or a matrix of real expected.\n"), fname, 1);
return 0;
}
if (pStringValues)
{
csvError = csvWrite_string(filename,
(const char**)pStringValues, m1, n1,
separator,
decimal,
(const char**)pHeadersLines, nbHeadersLines);
}
else
{
if (bIsComplex)
{
csvError = csvWrite_complex(filename,
pDoubleValuesReal,
pDoubleValuesImag,
m1, n1,
separator,
decimal,
precisionFormat,
(const char**)pHeadersLines, nbHeadersLines);
}
else
{
csvError = csvWrite_double(filename,
pDoubleValuesReal, m1, n1,
separator,
decimal,
precisionFormat,
(const char**)pHeadersLines, nbHeadersLines);
}
}
switch (csvError)
{
case CSV_WRITE_SEPARATOR_DECIMAL_EQUAL:
{
Scierror(999, _("%s: separator and decimal must have different values.\n"), fname);
}
break;
case CSV_WRITE_NO_ERROR:
{
LhsVar(1) = 0;
PutLhsVar();
}
break;
case CSV_WRITE_FOPEN_ERROR:
{
Scierror(999, _("%s: can not open file %s.\n"), fname, filename);
}
break;
default:
case CSV_WRITE_ERROR:
{
Scierror(999, _("%s: error.\n"), fname);
}
break;
}
freeVar(&separator, &decimal, &filename, &precisionFormat, &pHeadersLines, nbHeadersLines);
return 0;
}
// =============================================================================
static int sci_csvDefault_two_rhs(char *fname, void* pvApiCtx)
{
int iErr = 0;
int resultSet = 0;
char *fieldname = NULL;
char *fieldvalue = NULL;
int ifieldvalue = 0;
fieldname = csv_getArgumentAsString(pvApiCtx, 1, fname, &iErr);
if (iErr)
{
freeVar(&fieldname, &fieldvalue);
return 0;
}
if (strcmp(fieldname, PRECISION_FIELDNAME) == 0)
{
if (csv_isEmpty(pvApiCtx, 2))
{
freeVar(&fieldname, &fieldvalue);
Scierror(999, _("%s: Wrong type for input argument #%d: A double expected.\n"), fname, 2);
return 0;
}
if (csv_isDoubleScalar(pvApiCtx, 2))
{
#define FORMAT_FIELDVALUESTR "%%.%dlg"
ifieldvalue = (int) csv_getArgumentAsScalarDouble(pvApiCtx, 2, fname, &iErr);
if (iErr)
{
freeVar(&fieldname, &fieldvalue);
return 0;
}
if ((ifieldvalue < 1) || (ifieldvalue > 17))
{
freeVar(&fieldname, &fieldvalue);
Scierror(999, _("%s: Wrong value for input argument #%d: A double (value %d to %d) expected.\n"), fname, 2, 1, 17);
return 0;
}
fieldvalue = (char*)MALLOC(sizeof(char) * ((int)strlen(FORMAT_FIELDVALUESTR) + 1));
if (fieldvalue == NULL)
{
freeVar(&fieldname, &fieldvalue);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
sprintf(fieldvalue, FORMAT_FIELDVALUESTR, ifieldvalue);
}
else
{
fieldvalue = csv_getArgumentAsString(pvApiCtx, 2, fname, &iErr);
if (iErr)
{
freeVar(&fieldname, &fieldvalue);
return 0;
}
}
}
else
{
fieldvalue = csv_getArgumentAsString(pvApiCtx, 2, fname, &iErr);
if (iErr)
{
freeVar(&fieldname, &fieldvalue);
return 0;
}
}
if (strcmp(fieldname, SEPARATOR_FIELDNAME) == 0)
{
resultSet = setCsvDefaultSeparator(fieldvalue);
}
else if (strcmp(fieldname, DECIMAL_FIELDNAME) == 0)
{
resultSet = setCsvDefaultDecimal(fieldvalue);
}
else if (strcmp(fieldname, CONVERSION_FIELDNAME) == 0)
{
resultSet = setCsvDefaultConversion(fieldvalue);
}
else if (strcmp(fieldname, PRECISION_FIELDNAME) == 0)
{
resultSet = setCsvDefaultPrecision(fieldvalue);
}
else if (strcmp(fieldname, COMMENTSREGEXP_FIELDNAME) == 0)
{
resultSet = setCsvDefaultCommentsRegExp(fieldvalue);
}
else if (strcmp(fieldname, EOL_FIELDNAME) == 0)
{
if (strcmp(fieldvalue, MACOS9_EOL_STRING) == 0)
{
resultSet = setCsvDefaultEOL(MACOS9_EOL);
}
else if (strcmp(fieldvalue, WINDOWS_EOL_STRING) == 0)
{
resultSet = setCsvDefaultEOL(WINDOWS_EOL);
}
else if (strcmp(fieldvalue, LINUX_EOL_STRING) == 0)
{
resultSet = setCsvDefaultEOL(LINUX_EOL);
}
else
{
resultSet = 1;
}
}
else if (strcmp(fieldname, ENCODING_FIELDNAME) == 0)
{
resultSet = setCsvDefaultEncoding(fieldvalue);
}
else if (strcmp(fieldname, BLANK_FIELDNAME) == 0)
{
resultSet = setCsvDefaultCsvIgnoreBlankLine(fieldvalue);
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d: '%s', '%s', '%s' , '%s', '%s', '%s', '%s' or '%s' expected.\n"), fname, 1, SEPARATOR_FIELDNAME, DECIMAL_FIELDNAME, CONVERSION_FIELDNAME, PRECISION_FIELDNAME, COMMENTSREGEXP_FIELDNAME, EOL_FIELDNAME, ENCODING_FIELDNAME, BLANK_FIELDNAME);
freeVar(&fieldname, &fieldvalue);
return 0;
}
createScalarBoolean(pvApiCtx, Rhs + 1, (resultSet == 0));
freeVar(&fieldname, &fieldvalue);
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
// =============================================================================
static int sci_csvDefault_one_rhs(char *fname, void* pvApiCtx)
{
int iErr = 0;
char *fieldname = NULL;
char *fieldvalue = NULL;
fieldname = csv_getArgumentAsString(pvApiCtx, 1, fname, &iErr);
if (iErr)
{
freeVar(&fieldname, &fieldvalue);
return 0;
}
if (strcmp(fieldname, SEPARATOR_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultSeparator());
}
else if (strcmp(fieldname, DECIMAL_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultDecimal());
}
else if (strcmp(fieldname, CONVERSION_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultConversion());
}
else if (strcmp(fieldname, PRECISION_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultPrecision());
}
else if (strcmp(fieldname, COMMENTSREGEXP_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultCommentsRegExp());
}
else if (strcmp(fieldname, EOL_FIELDNAME) == 0)
{
const char *currentEol = getCsvDefaultEOL();
if (currentEol)
{
if (strcmp(currentEol, MACOS9_EOL) == 0)
{
fieldvalue = os_strdup(MACOS9_EOL_STRING);
}
else if (strcmp(currentEol, WINDOWS_EOL) == 0)
{
fieldvalue = os_strdup(WINDOWS_EOL_STRING);
}
else if (strcmp(currentEol, LINUX_EOL) == 0)
{
fieldvalue = os_strdup(LINUX_EOL_STRING);
}
else
{
fieldvalue = os_strdup("ERROR");
}
}
else
{
fieldvalue = os_strdup("ERROR");
}
}
else if (strcmp(fieldname, ENCODING_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultEncoding());
}
else if (strcmp(fieldname, BLANK_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultCsvIgnoreBlankLine());
}
else if (strcmp(fieldname, RESET_PARAMATERS) == 0)
{
freeVar(&fieldname, &fieldvalue);
setCsvDefaultReset();
createEmptyMatrix(pvApiCtx, Rhs + 1);
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d: '%s', '%s', '%s', '%s', '%s' or '%s' expected.\n"), fname, 1, SEPARATOR_FIELDNAME, DECIMAL_FIELDNAME, CONVERSION_FIELDNAME, COMMENTSREGEXP_FIELDNAME, EOL_FIELDNAME, BLANK_FIELDNAME);
freeVar(&fieldname, &fieldvalue);
return 0;
}
createSingleString(pvApiCtx, Rhs + 1, fieldvalue);
freeVar(&fieldname, &fieldvalue);
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
int main(int argc, char *argv[])
{
char *line;
char *prompt = "myshell>";
char *envPrompt = "DASH_PROMPT";
char *args[2048];
char *str;
char *multiCmd[2048];
int i=0;
int flag;
int jobid;
int code;
int fd1,fd2;
tcpid = getpgrp();
ObjectPtr myObj;
NodePtr node;
lst = createList(getKey,toString,freeObject); // Creating a List
prompt = getenv(envPrompt);
if(prompt == NULL)
prompt = "myshell>";
using_history();
if(signal(SIGINT,signalHandling) == SIG_ERR){}
if(signal(SIGTSTP,signalHandling) == SIG_ERR){}
if(signal(SIGTTOU,SIG_IGN)==SIG_ERR){}
if(signal(SIGCHLD,SIG_DFL)==SIG_ERR){}
if((argc == 2) && (strcmp(argv[1],"-v")==0))
{
printf("%s\n",svn_version());
exit(0);
}
code = sigsetjmp(env,TRUE);
while ((line=readline(prompt))) // Reading Input
{
if(line==NULL)
{
printf("\n read line failed \n");
continue;
}
add_history(line);
str = (char *)mymalloc(sizeof(char)*(strlen(line)+1));
strcpy(str,line);
if(str[0] == '&' || str[0] == ';')
{
printf("dash: syntax error near unexpected token %c \n",str[0]);
freeVar(line,str,args);
continue;
}
while((pid = waitpid(-1,NULL,WNOHANG)) > 0)
{
node = search(lst,pid);
((ObjectPtr)(node->obj))->jobStatus = 0;
printf("%s\n",(*toString)(node->obj));
removeNode(lst,node);
}
if(checkMultiCmd(str, multiCmd)== -1)
continue;
while(multiCmd[i])
{
flag = searchAmp(multiCmd[i]); // Function to check if there is an '&' in the Command
struct IORedirect *ior = tokenize(multiCmd[i],args);
if((int)ior == -1)
break; // Parsing the Command that needs to be executed
if(exitLogout(multiCmd[i])) // Function to check Exit and Logout Commands
{
if(checkStoppedJobs())
{
//memset(multiCmd,0,sizeof(multiCmd));
break;
}
else
{
freeVar(line,str,args);
freeList(lst);
memset(multiCmd,'\0',sizeof(multiCmd));
myfree(ior);
exit(0);
}
}
if(checkEOF(multiCmd[i])) // Function to check EOF
{
freeVar(line,str,args);
memset(multiCmd,'\0',sizeof(multiCmd));
freeList(lst);
myfree(ior);
exit(0);
}
if(checkEmptyCmd(multiCmd[i])) // Function to Check if Enter Key is pressed
break;
if((strcmp(args[0],"cd")==0) && (flag == FALSE)) // Function to check if 'cd' command is used
{
chgDir(args);
break;
}
if((strcmp(args[0],"jobs")==0) && (flag == FALSE)) // Function to check if 'jobs' command is used
{
jobsCmd();
break;
}
if(strcmp(args[0],"history")==0)
{
printHistory(args, str, flag);
break;
}
if((strcmp(args[0],"bg") == 0) && (flag == FALSE))
{
bgCmd(args);
break;
}
if((strcmp(args[0],"fg")==0) && (flag == FALSE))
{
fgCmd(args);
break;
}
if(ampCount(multiCmd[i]))
{
printf(" dash: syntax error near unexpected token '&' \n");
break;
}
if ( (pid = fork()) < 0) // Forking a Process
err_sys("fork error");
else if (pid == 0)
{
struct stat buf;
/* child */
if(flag == TRUE)
{
if(setpgid(0,0)!=0)
perror("setpid() error");
if(tcsetpgrp(0,tcpid)!=0)
perror("tcsetpgrp() error");
}
if(ior->input != NULL)
{
if((fd1 = stat(ior->input,&buf))==-1){
printf("dash: %s file does not exist\n",ior->input);
break;
}
if((fd1= access(ior->input,R_OK))==-1){
printf("dash: %s permission denied\n",ior->input);
break;
}
if((fd1 = open(ior->input,O_RDONLY))==-1){
printf("dash: %s inpRedirect opening failed\n",ior->input);
break;
}
else {
close(0);
dup(fd1);
}
}
if(ior->output != NULL)
{
/*if((fd1= access(ior->output,W_OK))==-1){
printf("dash: %s permission denied",ior->output);
break;}*/
if((fd2=open(ior->output,O_WRONLY|O_TRUNC|O_CREAT,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH ))==-1){
printf("dash: %s outRedirect opening failed\n",ior->output);
break;}
else{
close(1);
dup(fd2);
}
}
if (setpgid(0,0) != 0)
perror("setpgid() error");
if (tcsetpgrp(0, getpid()) != 0)
perror("tcsetpgrp() error");
execvp(args[0],args);
err_ret("couldn't execute: %s", line);
exit(127);
}
if(flag == TRUE && (*args[0] !='\0'))
{
jobid = assignJobId();
myObj = createObject(pid,multiCmd[i],jobid,1);
node = createNode(myObj);
addAtRear(lst,node);
printf("[%d] %d %s &\n",((ObjectPtr)(node->obj))->jobId, ((ObjectPtr)(node->obj))->key, ((ObjectPtr)(node->obj))->data);
if ( (pid = waitpid(pid, &status, WNOHANG)) < 0)
err_sys("waitpid error");
if((tcsetpgrp(0,tcpid))!=0)
perror("tcsetgroup error");
}
else
{
if ( (pid = waitpid(pid, &status, 0|WUNTRACED)) < 0)
err_sys("waitpid error");
if((tcsetpgrp(0,tcpid))!=0)
perror("tcsetgroup error");
if(WIFSTOPPED(status))
{
jobid = assignJobId();
myObj = createObject(pid,line,jobid,2);
node = createNode(myObj);
addAtRear(lst,node);
printf("%s\n",(*toString)(node->obj));
}
}
i++;
}
freeVar(line,str,args);
memset(multiCmd,'\0',sizeof(multiCmd));
i=0;
}
freeList(lst);
exit(0);
}
/* ==================================================================== */
int sci_csvRead(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int iErr = 0;
int iErrEmpty = 0;
char *filename = NULL;
char *separator = NULL;
char *decimal = NULL;
char *conversion = NULL;
int *iRange = NULL;
int haveRange = 0;
int header = 0;
char **toreplace = NULL;
int nbElementsToReplace = 0;
char *regexp = NULL;
int haveRegexp = 0;
csvResult *result = NULL;
double *dRealValues = NULL;
sciErr.iErr = 0;
CheckRhs(1, 8);
CheckLhs(1, 2);
if (Rhs == 8)
{
header = (int) csv_getArgumentAsScalarDouble(pvApiCtx, 8, fname, &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, 0, ®exp);
return 0;
}
}
if (Rhs == 7)
{
int m7 = 0, n7 = 0;
iRange = csv_getArgumentAsMatrixofIntFromDouble(pvApiCtx, 7, fname, &m7, &n7, &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, 0, ®exp);
return 0;
}
if ((m7 * n7 != SIZE_RANGE_SUPPORTED) )
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, 0, ®exp);
Scierror(999, _("%s: Wrong size for input argument #%d: Four entries expected.\n"), fname, 7);
return 0;
}
if ((m7 != 1) && (n7 != 1))
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, 0, ®exp);
Scierror(999, _("%s: Wrong size for input argument #%d: A column or row vector expected.\n"), fname, 7);
return 0;
}
if (isValidRange(iRange, m7 * n7))
{
haveRange = 1;
}
else
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, 0, ®exp);
Scierror(999, _("%s: Wrong value for input argument #%d: Inconsistent range.\n"), fname, 7);
return 0;
}
}
if (Rhs >= 6)
{
regexp = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 6, fname, getCsvDefaultCommentsRegExp(), &iErr);
if (regexp)
{
if (strcmp(regexp, "") == 0)
{
FREE(regexp);
regexp = NULL;
}
else
{
haveRegexp = 1;
}
}
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, 0, ®exp);
return 0;
}
}
else
{
regexp = strdup(getCsvDefaultCommentsRegExp());
if (regexp)
{
if (strcmp(regexp, "") == 0)
{
FREE(regexp);
regexp = NULL;
}
}
}
if (Rhs >= 5)
{
if (csv_isEmpty(pvApiCtx, 5))
{
toreplace = NULL;
nbElementsToReplace = 0;
}
else
{
int m5 = 0, n5 = 0;
toreplace = csv_getArgumentAsMatrixOfString(pvApiCtx, 5, fname, &m5, &n5, &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, m5 * n5, ®exp);
return 0;
}
if (n5 != 2)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, m5 * n5, ®exp);
Scierror(999, _("%s: Wrong size for input argument #%d.\n"), fname, 5);
return 0;
}
nbElementsToReplace = m5;
}
}
else
{
toreplace = NULL;
nbElementsToReplace = 0;
}
if (Rhs >= 4)
{
int iErr = 0;
conversion = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 4, fname, getCsvDefaultConversion(), &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
if (!((strcmp(conversion, CONVTOSTR) == 0) || (strcmp(conversion, CONVTODOUBLE) == 0)))
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' string expected.\n"), fname, 4, "double", "string");
return 0;
}
}
else
{
/* read_csv is using a 'string' conversion while csvRead is doing
a 'double' conversion */
if (strcmp(fname, "read_csv") == 0)
{
conversion = (char*)MALLOC((strlen("string") + 1) * sizeof(char));
strcpy(conversion, "string");
}
else
{
conversion = strdup(getCsvDefaultConversion());
}
}
if (Rhs >= 3)
{
int iErr = 0;
decimal = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 3, fname, getCsvDefaultDecimal(), &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
}
else
{
decimal = strdup(getCsvDefaultDecimal());
}
if (Rhs >= 2)
{
int iErr = 0;
separator = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 2, fname, getCsvDefaultSeparator(), &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
}
else
{
separator = strdup(getCsvDefaultSeparator());
}
if (strcmp(separator, "\\t") == 0)
{
/* In Scilab, if the user is providing \t as separator, transform it to a real
tab. Example: read_csv(filename,"\t");
*/
strcpy(separator, "\t");
}
filename = csv_getArgumentAsString(pvApiCtx, 1, fname, &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
result = csvRead(filename, separator, decimal, (const char**)toreplace, nbElementsToReplace * 2, regexp, header);
freeVar(NULL, &separator, &decimal, NULL, NULL, &toreplace, nbElementsToReplace, ®exp);
if (result)
{
switch (result->err)
{
case CSV_READ_REGEXP_ERROR:
{
Scierror(999, _("%s: Wrong value for input argument #%d.\n"), fname, 6);
}
break;
case CSV_READ_SEPARATOR_DECIMAL_EQUAL:
{
Scierror(999, _("%s: separator and decimal must have different values.\n"), fname);
}
break;
case CSV_READ_NO_ERROR:
{
if (strcmp(conversion, CONVTOSTR) == 0)
{
if (haveRange)
{
int newM = 0;
int newN = 0;
char **pStrRange = getRangeAsString((const char**)result->pstrValues, result->m, result->n, iRange, &newM, &newN);
if (pStrRange)
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, newM, newN, pStrRange);
freeArrayOfString(pStrRange, newM * newN);
}
else
{
if ((newM == 0) || (newN == 0))
{
Scierror(999, _("%s: Range row or/and column left indice(s) out of bounds.\n"), fname);
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
}
else
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, result->m, result->n, result->pstrValues);
}
}
else /* to double */
{
stringToComplexError ierr = STRINGTOCOMPLEX_ERROR;
complexArray *ptrComplexArray = stringsToComplexArray((const char**)result->pstrValues, result->m * result->n, decimal, TRUE, &ierr);
if (ptrComplexArray == NULL)
{
freeCsvResult(result);
if (ierr == STRINGTOCOMPLEX_ERROR)
{
Scierror(999, _("%s: can not convert data.\n"), fname);
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
switch (ierr)
{
case STRINGTOCOMPLEX_NOT_A_NUMBER:
case STRINGTOCOMPLEX_NO_ERROR:
{
if (haveRange)
{
int newM = 0;
int newN = 0;
complexArray *complexRange = getRangeAsComplexArray(ptrComplexArray, result->m, result->n, iRange, &newM, &newN);
if (complexRange)
{
if (complexRange->isComplex)
{
sciErr = createComplexMatrixOfDouble(pvApiCtx, Rhs + 1, newM, newN, ptrComplexArray->realPart, ptrComplexArray->imagPart);
}
else
{
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, newM, newN, complexRange->realPart);
}
freeComplexArray(complexRange);
complexRange = NULL;
}
else
{
if ((newM == 0) || (newN == 0))
{
Scierror(999, _("%s: Range row or/and column left indice(s) out of bounds.\n"), fname);
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
}
else
{
if (ptrComplexArray->isComplex)
{
sciErr = createComplexMatrixOfDouble(pvApiCtx, Rhs + 1, result->m, result->n, ptrComplexArray->realPart, ptrComplexArray->imagPart);
}
else
{
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, result->m, result->n, ptrComplexArray->realPart);
}
freeComplexArray(ptrComplexArray);
ptrComplexArray = NULL;
}
}
break;
case STRINGTOCOMPLEX_MEMORY_ALLOCATION:
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
default:
case STRINGTOCOMPLEX_ERROR:
{
Scierror(999, _("%s: can not convert data.\n"), fname);
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
}
}
if (sciErr.iErr)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
else
{
LhsVar(1) = Rhs + 1;
if (Lhs == 2)
{
if (haveRegexp == 0)
{
char **emptyStringMatrix = NULL;
emptyStringMatrix = (char**) malloc(sizeof(char*));
emptyStringMatrix[0] = "";
sciErr = createMatrixOfString(pvApiCtx, Rhs + 2, 1, 1, emptyStringMatrix);
free(emptyStringMatrix);
}
else
{
if (result->nbComments > 0)
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 2, result->nbComments, 1, result->pstrComments);
}
else
{
iErrEmpty = createEmptyMatrix(pvApiCtx, Rhs+2);
sciErr.iErr = iErrEmpty;
}
}
if (sciErr.iErr)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
LhsVar(2) = Rhs + 2;
}
PutLhsVar();
}
}
break;
case CSV_READ_FILE_NOT_EXIST:
{
Scierror(999, _("%s: %s does not exist.\n"), fname, filename);
}
break;
case CSV_READ_MOPEN_ERROR:
{
Scierror(999, _("%s: can not open file %s.\n"), fname, filename);
}
break;
case CSV_READ_MEMORY_ALLOCATION:
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
break;
case CSV_READ_COLUMNS_ERROR:
{
Scierror(999, _("%s: can not read file %s: Error in the column structure\n"), fname, filename);
}
break;
case CSV_READ_READLINES_ERROR:
case CSV_READ_ERROR:
{
Scierror(999, _("%s: can not read file %s.\n"), fname, filename);
}
break;
}
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
// =============================================================================
int sci_csvTextScan(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int iErr = 0;
int i = 0;
int *piAddressVarOne = NULL;
int m1 = 0, n1 = 0;
int iType1 = 0;
char **text = NULL;
int *lengthText = NULL;
int nbLines = 0;
char *separator = NULL;
char *decimal = NULL;
char *conversion = NULL;
double * dRealValues = NULL;
int *iRange = NULL;
int haveRange = 0;
csvResult *result = NULL;
CheckRhs(1, 5);
CheckLhs(1, 1);
if (Rhs == 5)
{
int m5 = 0, n5 = 0;
iRange = csv_getArgumentAsMatrixofIntFromDouble(pvApiCtx, 5, fname, &m5, &n5, &iErr);
if (iErr)
{
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
return 0;
}
if ((m5 * n5 != SIZE_RANGE_SUPPORTED) )
{
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
Scierror(999, _("%s: Wrong size for input argument #%d: Four entries expected.\n"), fname, 5);
return 0;
}
if ((m5 != 1) && (n5 != 1))
{
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
Scierror(999, _("%s: Wrong size for input argument #%d: A column or row vector expected.\n"), fname, 5);
return 0;
}
if (isValidRange(iRange, m5 * n5))
{
haveRange = 1;
}
else
{
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
Scierror(999, _("%s: Wrong value for input argument #%d: Inconsistent range.\n"), fname, 5);
return 0;
}
}
if (Rhs >= 4)
{
conversion = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 4, fname, getCsvDefaultConversion(), &iErr);
if (iErr)
{
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
return 0;
}
if (!((strcmp(conversion, CONVTOSTR) == 0) || (strcmp(conversion, CONVTODOUBLE) == 0)))
{
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' string expected.\n"), fname, 4, "double", "string");
return 0;
}
}
else
{
conversion = os_strdup(getCsvDefaultConversion());
}
if (Rhs >= 3)
{
decimal = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 3, fname, getCsvDefaultDecimal(), &iErr);
if (iErr)
{
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
return 0;
}
if (decimal[0] != '.' && decimal[0] != ',')
{
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' string expected.\n"), fname, 3, ",", ".");
return 0;
}
}
else
{
decimal = os_strdup(getCsvDefaultDecimal());
}
if (Rhs >= 2)
{
separator = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 2, fname, getCsvDefaultSeparator(), &iErr);
if (iErr)
{
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
return 0;
}
}
else
{
separator = os_strdup(getCsvDefaultSeparator());
}
if (!csv_isRowVector(pvApiCtx, 1) &&
!csv_isColumnVector(pvApiCtx, 1) &&
!csv_isScalar(pvApiCtx, 1))
{
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
Scierror(999, _("%s: Wrong size for input argument #%d: String vector expected.\n"), fname, 1);
return 0;
}
text = csv_getArgumentAsMatrixOfString(pvApiCtx, 1, fname, &m1, &n1, &iErr);
if (iErr)
{
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
return 0;
}
nbLines = m1 * n1;
result = csvTextScan((const char**)text, nbLines, separator, decimal);
if (result)
{
switch (result->err)
{
case CSV_READ_SEPARATOR_DECIMAL_EQUAL:
{
Scierror(999, _("%s: separator and decimal must have different values.\n"), fname);
}
break;
case CSV_READ_NO_ERROR:
{
if (strcmp(conversion, CONVTOSTR) == 0)
{
if (haveRange)
{
int newM = 0;
int newN = 0;
char **pStrRange = getRangeAsString((const char**)result->pstrValues, result->m, result->n, iRange, &newM, &newN);
if (pStrRange)
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, newM, newN, pStrRange);
freeArrayOfString(pStrRange, newM * newN);
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
}
else
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, result->m, result->n, result->pstrValues);
}
}
else /* to double */
{
stringToComplexError ierr = STRINGTOCOMPLEX_ERROR;
complexArray *ptrComplexArray = stringsToComplexArray((const char**)result->pstrValues, result->m * result->n, decimal, TRUE, &ierr);
if (ptrComplexArray == NULL)
{
if (ierr == STRINGTOCOMPLEX_ERROR)
{
Scierror(999, _("%s: can not convert data.\n"), fname);
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
freeCsvResult(result);
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
return 0;
}
switch (ierr)
{
case STRINGTOCOMPLEX_NOT_A_NUMBER:
case STRINGTOCOMPLEX_NO_ERROR:
{
if (haveRange)
{
int newM = 0;
int newN = 0;
complexArray *csvComplexRange = getRangeAsComplexArray(ptrComplexArray, result->m, result->n, iRange, &newM, &newN);
if (csvComplexRange)
{
if (csvComplexRange->isComplex)
{
sciErr = createComplexMatrixOfDouble(pvApiCtx, Rhs + 1, newM, newN, ptrComplexArray->realPart, ptrComplexArray->imagPart);
}
else
{
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, newM, newN, csvComplexRange->realPart);
}
freeComplexArray(csvComplexRange);
csvComplexRange = NULL;
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
}
else
{
if (ptrComplexArray->isComplex)
{
sciErr = createComplexMatrixOfDouble(pvApiCtx, Rhs + 1, result->m, result->n, ptrComplexArray->realPart, ptrComplexArray->imagPart);
}
else
{
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, result->m, result->n, ptrComplexArray->realPart);
}
}
freeComplexArray(ptrComplexArray);
ptrComplexArray = NULL;
}
break;
case STRINGTOCOMPLEX_MEMORY_ALLOCATION:
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
break;
default:
case STRINGTOCOMPLEX_ERROR:
{
Scierror(999, _("%s: can not convert data.\n"), fname);
}
break;
}
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(17, _("%s: Memory allocation error.\n"), fname);
freeCsvResult(result);
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
return 0;
}
else
{
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
}
break;
case CSV_READ_MEMORY_ALLOCATION:
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
break;
case CSV_READ_COLUMNS_ERROR:
{
Scierror(999, _("%s: can not read text: Error in the column structure\n"), fname);
}
break;
case CSV_READ_READLINES_ERROR:
case CSV_READ_ERROR:
case CSV_READ_MOPEN_ERROR:
case CSV_READ_FILE_NOT_EXIST:
case CSV_READ_REGEXP_ERROR:
{
Scierror(999, _("%s: can not read text.\n"), fname);
}
break;
}
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
freeVar(&text, nbLines, &lengthText, &separator, &decimal, &conversion, &iRange);
freeCsvResult(result);
return 0;
}
