/*------------------------------------------------------------------------*/
errorLoadHistoryCode HistoryFile::loadFromFile(std::string filename)
{
errorLoadHistoryCode returnedError = ERROR_HISTORY_NOT_LOADED;
int fd = 0;
int f_swap = 0;
double res = 0.0;
int errMOPEN = MOPEN_INVALID_STATUS;
double dErrClose = 0.;
C2F(mopen)(&fd, (char*)filename.c_str(), "rt", &f_swap, &res, &errMOPEN);
if (errMOPEN == MOPEN_NO_ERROR)
{
int errMGETL = MGETL_ERROR;
int nblines = 0;
char **lines = mgetl(fd, -1, &nblines, &errMGETL);
C2F(mclose)(&fd, &dErrClose);
if (errMGETL == MGETL_NO_ERROR)
{
if (lines)
{
int iStart = 0;
int iEnd = 0;
if (nblines > getDefaultMaxNbLines())
{
iStart = nblines - getDefaultMaxNbLines();
returnedError = HISTORY_TRUNCATED;
}
else
{
iStart = 0;
returnedError = NO_ERROR_HISTORY_LOADED;
}
iEnd = nblines;
for (int i = iStart; i < iEnd; i++)
{
CommandLine Line(lines[i]);
this->Commands.push_back(Line);
}
freeArrayOfString(lines, nblines);
lines = NULL;
}
}
}
return returnedError;
}
// =============================================================================
csvResult* csvRead(const char *filename, const char *separator, const char *decimal, const char **toreplace, int sizetoreplace, const char *regexpcomments, int header)
{
wchar_t *expandedFilename = NULL;
wchar_t *wideFilename = NULL;
csvResult *result = NULL;
int fd = 0;
int f_swap = 0;
double res = 0.0;
int errMOPEN = MOPEN_INVALID_STATUS;
int errMGETL = MGETL_ERROR;
wchar_t **pwstLines = NULL;
char **pstLines = NULL;
int nblines = 0;
char **replacedInLines = NULL;
char **pComments = NULL;
int nbComments = 0;
if ((filename == NULL) || (separator == NULL) || (decimal == NULL))
{
return NULL;
}
wideFilename = to_wide_string((char*)filename);
expandedFilename = expandPathVariableW(wideFilename);
FREE(wideFilename);
if (!FileExistW(expandedFilename))
{
result = (csvResult*)(MALLOC(sizeof(csvResult)));
if (result)
{
result->err = CSV_READ_FILE_NOT_EXIST;
result->m = 0;
result->n = 0;
result->pstrValues = NULL;
result->pstrComments = NULL;
result->nbComments = 0;
}
FREE(expandedFilename);
return result;
}
errMOPEN = mopen(expandedFilename, L"rt", f_swap, &fd); // rt = read only
if (expandedFilename)
{
FREE(expandedFilename);
expandedFilename = NULL;
}
if (errMOPEN != MOPEN_NO_ERROR)
{
result = (csvResult*)(MALLOC(sizeof(csvResult)));
if (result)
{
result->err = CSV_READ_MOPEN_ERROR;
result->m = 0;
result->n = 0;
result->pstrValues = NULL;
result->pstrComments = NULL;
result->nbComments = 0;
}
return result;
}
if (header != 0)
{
mgetl(fd, header, &nblines, &errMGETL);
}
pwstLines = mgetl(fd, -1, &nblines, &errMGETL);
pstLines = (char**)MALLOC(sizeof(char*) * nblines);
{
int i = 0;
for (i = 0 ; i < nblines ; i++)
{
pstLines[i] = wide_string_to_UTF8(pwstLines[i]);
}
}
mclose(fd);
if (errMGETL != MGETL_NO_ERROR)
{
if (pwstLines)
{
freeArrayOfWideString(pwstLines, nblines);
pwstLines = NULL;
}
result = (csvResult*)(MALLOC(sizeof(csvResult)));
if (result)
{
result->err = CSV_READ_READLINES_ERROR;
result->m = 0;
result->n = 0;
result->pstrValues = NULL;
result->pstrComments = NULL;
result->nbComments = 0;
}
return result;
}
if (regexpcomments)
{
int iErr = 0;
pComments = extractComments((const char**)pstLines, nblines, regexpcomments, &nbComments, &iErr);
if ((iErr == CAN_NOT_COMPILE_PATTERN) || (iErr == DELIMITER_NOT_ALPHANUMERIC))
{
result = (csvResult*)(MALLOC(sizeof(csvResult)));
if (result)
{
if ((iErr == CAN_NOT_COMPILE_PATTERN) || (iErr == DELIMITER_NOT_ALPHANUMERIC))
{
iErr = CSV_READ_REGEXP_ERROR;
}
result->err = (csvReadError)iErr;
result->m = 0;
result->n = 0;
result->pstrValues = NULL;
result->pstrComments = NULL;
result->nbComments = 0;
}
return result;
}
if (pComments)
{
char **pCleanedLines = NULL;
int nbCleanedLines = 0;
int i = 0;
pCleanedLines = removeComments((const char**)pstLines, nblines, (const char*)regexpcomments, &nbCleanedLines, &iErr);
if (pCleanedLines)
{
if (pwstLines)
{
freeArrayOfWideString(pwstLines, nblines);
pwstLines = NULL;
}
FREE(pstLines);
pstLines = pCleanedLines;
nblines = nbCleanedLines;
}
}
}
if (toreplace && (sizetoreplace > 0))
{
replacedInLines = replaceStrings((const char**)pstLines, nblines, toreplace, sizetoreplace);
if (replacedInLines)
{
freeArrayOfString(pstLines, nblines);
pstLines = replacedInLines;
}
}
result = csvTextScan((const char**)pstLines, nblines, (const char*)separator, (const char*)decimal);
freeArrayOfString(pstLines, nblines);
freeArrayOfWideString(pwstLines, nblines);
if (result)
{
result->pstrComments = pComments;
result->nbComments = nbComments;
}
else
{
freeArrayOfString(pComments, nbComments);
}
return result;
}
/*--------------------------------------------------------------------------*/
int sci_mgetl(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
int numberOfLinesToRead = -1;
Rhs = Max(0, Rhs);
CheckRhs(1, 2);
CheckLhs(1, 1);
if (Rhs == 2)
{
int *piAddressVarTwo = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
if ( isDoubleType(pvApiCtx, piAddressVarTwo) )
{
double dValue = 0.;
if (!isScalar(pvApiCtx, piAddressVarTwo))
{
Scierror(999, _("%s: Wrong size for input argument #%d: Integer expected.\n"), fname, 2);
return 0;
}
if ( getScalarDouble(pvApiCtx, piAddressVarTwo, &dValue) == 0)
{
numberOfLinesToRead = (int)dValue;
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Integer expected.\n"), fname, 2);
return 0;
}
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if ( isStringType(pvApiCtx, piAddressVarOne) || isDoubleType(pvApiCtx, piAddressVarOne) )
{
char **wcReadedStrings = NULL;
int numberOfLinesReaded = 0;
int fileDescriptor = -1;
int iErrorMgetl = 0;
BOOL bCloseFile = FALSE;
if (!isScalar(pvApiCtx, piAddressVarOne))
{
Scierror(999, _("%s: Wrong size for input argument #%d: String or logical unit expected.\n"), fname, 1);
return 0;
}
if (isStringType(pvApiCtx, piAddressVarOne))
{
char *fileName = NULL;
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &fileName) == 0)
{
char *expandedFileName = expandPathVariable(fileName);
freeAllocatedSingleString(fileName);
fileName = NULL;
if (IsAlreadyOpenedInScilab(expandedFileName))
{
int fd = GetIdFromFilename(expandedFileName);
fileDescriptor = fd;
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
bCloseFile = FALSE;
}
else
{
#define READ_ONLY_TEXT_MODE "rt"
int fd = 0;
int f_swap = 0;
double res = 0.0;
int ierr = 0;
C2F(mopen)(&fd, expandedFileName, READ_ONLY_TEXT_MODE, &f_swap, &res, &ierr);
bCloseFile = TRUE;
switch (ierr)
{
case MOPEN_NO_ERROR:
fileDescriptor = fd;
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
break;
case MOPEN_NO_MORE_LOGICAL_UNIT:
{
Scierror(66, _("%s: Too many files opened!\n"), fname);
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
return 0;
}
break;
case MOPEN_CAN_NOT_OPEN_FILE:
{
Scierror(999, _("%s: Cannot open file %s.\n"), fname, expandedFileName);
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
return 0;
}
break;
case MOPEN_NO_MORE_MEMORY:
{
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
break;
case MOPEN_INVALID_FILENAME:
{
Scierror(999, _("%s: invalid filename %s.\n"), fname, expandedFileName);
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
return 0;
}
break;
case MOPEN_INVALID_STATUS:
default:
{
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
Scierror(999, _("%s: invalid status.\n"), fname);
return 0;
}
break;
}
}
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else /* double */
{
double dValue = 0.;
if ( !getScalarDouble(pvApiCtx, piAddressVarOne, &dValue) )
{
FILE *fd = NULL;
fileDescriptor = (int)dValue;
if ((fileDescriptor == STDIN_ID) || (fileDescriptor == STDOUT_ID))
{
SciError(244);
return 0;
}
fd = GetFileOpenedInScilab(fileDescriptor);
if (fd == NULL)
{
Scierror(245, _("%s: No input file associated to logical unit %d.\n"), fname, fileDescriptor);
return 0;
}
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
wcReadedStrings = mgetl(fileDescriptor, numberOfLinesToRead, &numberOfLinesReaded, &iErrorMgetl);
if (bCloseFile)
{
double dErrClose = 0.;
C2F(mclose)(&fileDescriptor, &dErrClose);
}
switch (iErrorMgetl)
{
case MGETL_NO_ERROR:
{
if (numberOfLinesReaded == 0)
{
if (createEmptyMatrix(pvApiCtx, Rhs + 1) != 0)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
int m = numberOfLinesReaded;
int n = 1;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, m, n, wcReadedStrings);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(17, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
freeArrayOfString(wcReadedStrings, numberOfLinesReaded);
wcReadedStrings = NULL;
}
break;
case MGETL_EOF:
{
if (numberOfLinesReaded == 0)
{
if (createEmptyMatrix(pvApiCtx, Rhs + 1) != 0)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
int m = numberOfLinesReaded;
int n = 1;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, m, n, wcReadedStrings);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(17, _("%s: Memory allocation error.\n"), fname);
return 0;
}
freeArrayOfString(wcReadedStrings, numberOfLinesReaded);
wcReadedStrings = NULL;
}
}
break;
case MGETL_MEMORY_ALLOCATION_ERROR:
{
if (wcReadedStrings)
{
freeArrayOfString(wcReadedStrings, numberOfLinesReaded);
wcReadedStrings = NULL;
}
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
break;
case MGETL_ERROR:
{
if (wcReadedStrings)
{
freeArrayOfString(wcReadedStrings, numberOfLinesReaded);
wcReadedStrings = NULL;
}
Scierror(999, _("%s: error.\n"), fname);
return 0;
}
break;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: String or logical unit expected.\n"), fname, 1);
}
return 0;
}
/*--------------------------------------------------------------------------*/
int LineRead(int fd, char buf[], int n, int *cnt, int *nr)
{
int returnedInfo = READNEXTLINE_ERROR_ERROR_UNMANAGED;
int nbLinesToRead = 1;
int nbLinesReaded = 0;
int mgetIerr = MGETL_ERROR;
char **lines = mgetl(fd, nbLinesToRead, &nbLinesReaded, &mgetIerr);
*cnt = 0;
*nr = 0;
memset(buf, 0, n);
strcpy(buf, EMPTYSTR);
switch(mgetIerr)
{
case MGETL_NO_ERROR:
{
if ((lines[0]) && (lines) && (nbLinesReaded == 1))
{
/* current limitation (bsiz) of line readed by scilab */
if ((int)strlen(lines[0]) < bsiz)
{
strcpy(buf, lines[0]);
returnedInfo = READNEXTLINE_ERROR_EOL;
}
else
{
strncpy(buf, lines[0], bsiz);
returnedInfo = READNEXTLINE_ERROR_BUFFER_FULL;
}
}
else
{
returnedInfo = READNEXTLINE_ERROR_EOF_REACHED;
}
}
break;
case MGETL_EOF:
{
if (lines)
{
if (nbLinesReaded == 0)
{
returnedInfo = READNEXTLINE_ERROR_EOF_REACHED;
}
else
{
/* current limitation (bsiz) of line readed by scilab */
if ((int)strlen(lines[0]) >= bsiz)
{
strcpy(buf, lines[0]);
returnedInfo = READNEXTLINE_ERROR_EOF_REACHED_AFTER_EOL;
}
else
{
strncpy(buf, lines[0], bsiz);
returnedInfo = READNEXTLINE_ERROR_BUFFER_FULL;
}
}
}
else
{
returnedInfo = READNEXTLINE_ERROR_EOF_REACHED_BEFORE_EOL;
}
}
break;
case MGETL_MEMORY_ALLOCATION_ERROR:
case MGETL_ERROR:
default:
{
returnedInfo = READNEXTLINE_ERROR_ERROR_UNMANAGED;
}
break;
}
*cnt = (int)strlen(buf) + 1;
*nr = *cnt;
if (lines)
{
freeArrayOfString(lines, nbLinesReaded);
lines = NULL;
}
return returnedInfo;
}
/*--------------------------------------------------------------------------*/
fscanfMatResult *fscanfMat(char *filename, char *format, char *separator)
{
int fd = 0;
int f_swap = 0;
double res = 0.0;
int errMOPEN = MOPEN_INVALID_STATUS;
int errMGETL = MGETL_ERROR;
int i = 0;
int nbLinesTextDetected = 0;
int nbColumns = 0;
int nbRows = 0;
fscanfMatResult *resultFscanfMat = NULL;
wchar_t **pwsLines = NULL;
char **lines = NULL;
int nblines = 0;
double *dValues = NULL;
wchar_t* filenameW = NULL;
if ((filename == NULL) || (format == NULL) || (separator == NULL))
{
return NULL;
}
if (!checkFscanfMatFormat(format))
{
resultFscanfMat = (fscanfMatResult*)(MALLOC(sizeof(fscanfMatResult)));
if (resultFscanfMat)
{
resultFscanfMat->err = FSCANFMAT_FORMAT_ERROR;
resultFscanfMat->m = 0;
resultFscanfMat->n = 0;
resultFscanfMat->sizeText = 0;
resultFscanfMat->text = NULL;
resultFscanfMat->values = NULL;
}
return resultFscanfMat;
}
filenameW = to_wide_string(filename);
errMOPEN = mopen(filenameW, READ_ONLY_TEXT_MODE, f_swap, &fd);
FREE(filenameW);
if (errMOPEN != MOPEN_NO_ERROR)
{
resultFscanfMat = (fscanfMatResult*)(MALLOC(sizeof(fscanfMatResult)));
if (resultFscanfMat)
{
resultFscanfMat->err = FSCANFMAT_MOPEN_ERROR;
resultFscanfMat->m = 0;
resultFscanfMat->n = 0;
resultFscanfMat->sizeText = 0;
resultFscanfMat->text = NULL;
resultFscanfMat->values = NULL;
}
return resultFscanfMat;
}
pwsLines = mgetl(fd, -1, &nblines, &errMGETL);
mclose(fd);
if (errMGETL != MGETL_NO_ERROR)
{
resultFscanfMat = (fscanfMatResult*)(MALLOC(sizeof(fscanfMatResult)));
if (resultFscanfMat)
{
resultFscanfMat->err = FSCANFMAT_READLINES_ERROR;
resultFscanfMat->m = 0;
resultFscanfMat->n = 0;
resultFscanfMat->sizeText = 0;
resultFscanfMat->text = NULL;
resultFscanfMat->values = NULL;
}
return resultFscanfMat;
}
lines = (char**)MALLOC(sizeof(char*) * nblines);
for (i = 0; i < nblines; i++)
{
lines[i] = wide_string_to_UTF8(pwsLines[i]);
}
freeArrayOfWideString(pwsLines, nblines);
lines = removeEmptyLinesAtTheEnd(lines, &nblines);
lines = removeTextLinesAtTheEnd(lines, &nblines, format, separator);
nbLinesTextDetected = getNumbersLinesOfText(lines, nblines, format, separator);
nbRows = nblines - nbLinesTextDetected;
nbColumns = getNumbersColumnsInLines(lines, nblines, nbLinesTextDetected, format, separator);
dValues = getDoubleValuesFromLines(lines, nblines,
nbLinesTextDetected,
format, separator,
nbColumns, nbRows);
if (dValues)
{
resultFscanfMat = (fscanfMatResult*)(MALLOC(sizeof(fscanfMatResult)));
if (resultFscanfMat)
{
if (nbLinesTextDetected > 0)
{
if (lines)
{
for (i = nbLinesTextDetected; i < nblines; i++)
{
if (lines[i])
{
FREE(lines[i]);
lines[i] = NULL;
}
}
}
resultFscanfMat->text = lines;
}
else
{
freeArrayOfString(lines, nblines);
resultFscanfMat->text = NULL;
}
resultFscanfMat->sizeText = nbLinesTextDetected;
resultFscanfMat->m = nbRows;
resultFscanfMat->n = nbColumns;
resultFscanfMat->values = dValues;
resultFscanfMat->err = FSCANFMAT_NO_ERROR;
}
else
{
FREE(dValues);
freeArrayOfString(lines, nblines);
}
}
else
{
freeArrayOfString(lines, nblines);
if (nbColumns == 0 || nbRows == 0)
{
resultFscanfMat = (fscanfMatResult*)(MALLOC(sizeof(fscanfMatResult)));
if (resultFscanfMat)
{
resultFscanfMat->err = FSCANFMAT_READLINES_ERROR;
resultFscanfMat->m = 0;
resultFscanfMat->n = 0;
resultFscanfMat->sizeText = 0;
resultFscanfMat->text = NULL;
resultFscanfMat->values = NULL;
}
}
}
return resultFscanfMat;
}
/*--------------------------------------------------------------------------*/
types::Function::ReturnValue sci_mgetl(types::typed_list &in, int _iRetCount, types::typed_list &out)
{
int iFileID = 0;
int iErr = 0;
bool bCloseFile = false;
int iLinesExcepted = -1;
int iLinesRead = -1;
wchar_t** wcReadedStrings = NULL;
if (in.size() < 1 || in.size() > 2)
{
Scierror(77, _("%s: Wrong number of input arguments: %d to %d expected.\n"), "mgetl" , 1, 2);
return types::Function::OK;
}
if (in.size() == 2)
{
//number of lines
if (in[1]->isDouble() == false)
{
Scierror(999, _("%s: Wrong type for input argument #%d: An integer value expected.\n"), "mgetl", 2);
return types::Function::Error;
}
if (in[1]->getAs<types::Double>()->isScalar() == false)
{
Scierror(999, _("%s: Wrong size for input argument #%d: An integer value expected.\n"), "mgetl", 2);
return types::Function::Error;
}
if (in[1]->getAs<types::Double>()->get(0) != (int)in[1]->getAs<types::Double>()->get(0))
{
Scierror(999, _("%s: Wrong value for input argument #%d: An integer value expected.\n"), "mgetl", 2);
return types::Function::Error;
}
iLinesExcepted = static_cast<int>(in[1]->getAs<types::Double>()->get(0));
}
if (in[0]->isDouble() && in[0]->getAs<types::Double>()->getSize() == 1)
{
iFileID = static_cast<int>(in[0]->getAs<types::Double>()->get(0));
}
else if (in[0]->isString() && in[0]->getAs<types::String>()->getSize() == 1)
{
wchar_t *expandedFileName = expandPathVariableW(in[0]->getAs<types::String>()->get(0));
iErr = mopen(expandedFileName, L"rt", 0, &iFileID);
if (iErr)
{
char* pst = wide_string_to_UTF8(expandedFileName);
switch (iErr)
{
case MOPEN_NO_MORE_LOGICAL_UNIT:
Scierror(66, _("%s: Too many files opened!\n"), "mgetl");
break;
case MOPEN_CAN_NOT_OPEN_FILE:
Scierror(999, _("%s: Cannot open file %s.\n"), "mgetl", pst);
break;
case MOPEN_NO_MORE_MEMORY:
Scierror(999, _("%s: No more memory.\n"), "mgetl");
break;
case MOPEN_INVALID_FILENAME:
Scierror(999, _("%s: invalid filename %s.\n"), "mgetl", pst);
break;
default: //MOPEN_INVALID_STATUS
Scierror(999, _("%s: invalid status.\n"), "mgetl");
break;
}
FREE(pst);
FREE(expandedFileName);
return types::Function::Error;
}
FREE(expandedFileName);
bCloseFile = true;
}
else
{
//Error
Scierror(999, _("%s: Wrong type for input argument #%d: a String or Integer expected.\n"), "mgetl", 1);
return types::Function::Error;
}
switch (iFileID)
{
case 0: // stderr
case 6: // stdout
Scierror(999, _("%s: Wrong file descriptor: %d.\n"), "mgetl", iFileID);
return types::Function::Error;
default :
{
types::File* pFile = FileManager::getFile(iFileID);
// file opened with fortran open function
if (pFile == NULL || pFile->getFileType() == 1)
{
Scierror(999, _("%s: Wrong file descriptor: %d.\n"), "mgetl", iFileID);
return types::Function::Error;
}
wcReadedStrings = mgetl(iFileID, iLinesExcepted, &iLinesRead, &iErr);
switch (iErr)
{
case MGETL_MEMORY_ALLOCATION_ERROR :
break;
}
}
}
if (wcReadedStrings && iLinesRead > 0)
{
types::String *pS = new types::String(iLinesRead, 1);
pS->set(wcReadedStrings);
out.push_back(pS);
freeArrayOfWideString(wcReadedStrings, iLinesRead);
}
else
{
out.push_back(types::Double::Empty());
if (wcReadedStrings)
{
FREE(wcReadedStrings);
}
}
if (bCloseFile)
{
mclose(iFileID);
}
return types::Function::OK;
}
// =============================================================================
csvResult* csvRead(const char *filename, const char *separator, const char *decimal, const char **toreplace, int sizetoreplace, const char *regexpcomments)
{
char *expandedFilename = NULL;
csvResult *result = NULL;
int fd = 0;
int f_swap = 0;
double res = 0.0;
int errMOPEN = MOPEN_INVALID_STATUS;
int errMGETL = MGETL_ERROR;
double dErrClose = 0.;
char **lines = NULL;
int nblines = 0;
char **replacedInLines = NULL;
char **pComments = NULL;
int nbComments = 0;
if ((filename == NULL) || (separator == NULL) || (decimal == NULL))
{
return NULL;
}
expandedFilename = expandPathVariable((char*)filename);
if (!FileExist(expandedFilename))
{
result = (csvResult*)(MALLOC(sizeof(csvResult)));
if (result)
{
result->err = CSV_READ_FILE_NOT_EXIST;
result->m = 0;
result->n = 0;
result->pstrValues = NULL;
result->pstrComments = NULL;
result->nbComments = 0;
}
if (expandedFilename)
{
FREE(expandedFilename);
expandedFilename = NULL;
}
return result;
}
C2F(mopen)(&fd, expandedFilename, (char*)READ_ONLY_TEXT_MODE, &f_swap, &res, &errMOPEN);
if (expandedFilename)
{
FREE(expandedFilename);
expandedFilename = NULL;
}
if (errMOPEN != MOPEN_NO_ERROR)
{
result = (csvResult*)(MALLOC(sizeof(csvResult)));
if (result)
{
result->err = CSV_READ_MOPEN_ERROR;
result->m = 0;
result->n = 0;
result->pstrValues = NULL;
result->pstrComments = NULL;
result->nbComments = 0;
}
return result;
}
lines = mgetl(fd, -1, &nblines, &errMGETL);
C2F(mclose)(&fd, &dErrClose);
if (errMGETL != MGETL_NO_ERROR)
{
if (lines)
{
freeArrayOfString(lines, nblines);
lines = NULL;
}
result = (csvResult*)(MALLOC(sizeof(csvResult)));
if (result)
{
result->err = CSV_READ_READLINES_ERROR;
result->m = 0;
result->n = 0;
result->pstrValues = NULL;
result->pstrComments = NULL;
result->nbComments = 0;
}
return result;
}
if (regexpcomments)
{
int iErr = 0;
pComments = extractComments((const char**)lines, nblines, (const char*)regexpcomments, &nbComments, &iErr);
if ((iErr == CAN_NOT_COMPILE_PATTERN) || (iErr == DELIMITER_NOT_ALPHANUMERIC))
{
result = (csvResult*)(MALLOC(sizeof(csvResult)));
if (result)
{
if ((iErr == CAN_NOT_COMPILE_PATTERN) || (iErr == DELIMITER_NOT_ALPHANUMERIC))
{
iErr = CSV_READ_REGEXP_ERROR;
}
result->err = (csvReadError)iErr;
result->m = 0;
result->n = 0;
result->pstrValues = NULL;
result->pstrComments = NULL;
result->nbComments = 0;
}
return result;
}
if (pComments)
{
char **pCleanedLines = NULL;
int nbCleanedLines = 0;
int i = 0;
pCleanedLines = removeComments((const char**)lines, nblines, (const char*)regexpcomments, &nbCleanedLines, &iErr);
if (pCleanedLines)
{
FREE(lines);
lines = pCleanedLines;
nblines = nbCleanedLines;
}
}
}
if (toreplace && (sizetoreplace > 0))
{
replacedInLines = replaceStrings((const char**)lines, nblines, toreplace, sizetoreplace);
if (replacedInLines)
{
freeArrayOfString(lines, nblines);
lines = replacedInLines;
}
}
result = csvTextScan((const char**)lines, nblines, (const char*)separator, (const char*)decimal);
if (lines)
{
freeArrayOfString(lines, nblines);
lines = NULL;
}
if (result)
{
result->pstrComments = pComments;
result->nbComments = nbComments;
}
return result;
}
char org_load(int songno)
{
static const char *magic = "Org-02";
char buf[8];
char *f;
char **fp;
int i, j;
f = org_data[songno];
fp = &f;
if (!fp) {
NX_WARN("org_load: no such file: '%d'\n", songno);
return 1;
}
for(i=0;i<6;i++) { buf[i] = mgetc(fp); } buf[i] = 0;
if (strcmp(buf, magic)) {
NX_WARN("org-load: not an org file (got '%s')\n", buf);
//fclose(fp);
return 1;
}
NX_LOG("%d: %s detected\n", songno, magic);
//fseek(fp, 0x06, SEEK_SET);
song.ms_per_beat = mgeti(fp);
song.steps_per_bar = mgetc(fp);
song.beats_per_step = mgetc(fp);
song.loop_start = mgetl(fp);
song.loop_end = mgetl(fp);
//song.ms_per_beat = 500;
//song.loop_start = 64;
if (song.loop_end < song.loop_start)
{
visible_warning("org_load: loop end is before loop start");
//fclose(fp);
return 1;
}
// compute how long the last beat of a note should be (it should not use up the whole beat)
song.ms_of_last_beat_of_note = song.ms_per_beat - (int)((double)song.ms_per_beat * 0.1);
// not actually used in this module, but the larger program might want to know this
song.beats_per_bar = (song.beats_per_step * song.steps_per_bar);
/*lprintf("tempo: %d ms/beat\n", song.ms_per_beat);
lprintf("beats_per_step: %d\n", song.beats_per_step);
lprintf("steps_per_bar: %d\n", song.steps_per_bar);
lprintf("loop begins on beat %d\n", song.loop_start);
lprintf("loop ends on beat %d\n", song.loop_end);*/
for(i=0;i<16;i++)
{
song.instrument[i].pitch = mgeti(fp);
song.instrument[i].wave = mgetc(fp);
song.instrument[i].pi = mgetc(fp);
song.instrument[i].nnotes = mgeti(fp);
if (song.instrument[i].nnotes >= MAX_SONG_LENGTH)
{
visible_warning(" * org_load: instrument %d has too many notes! (has %d, max %d)", i, song.instrument[i].nnotes, MAX_SONG_LENGTH);
//fclose(fp);
return 1;
}
/*if (song.instrument[i].nnotes)
{
lprintf("Instrument %d: ", i);
lprintf(" Pitch: %d, ", song.instrument[i].pitch);
lprintf(" Wave: %d, ", song.instrument[i].wave);
lprintf(" Pi: %d, ", song.instrument[i].pi);
lprintf(" Nnotes: %d\n", song.instrument[i].nnotes);
}*/
// substitute unavailable drums
// credits track for one, has Per02 set which CS didn't actually have, I don't think
if (i >= 8)
{
switch(song.instrument[i].wave)
{
case 9: song.instrument[i].wave = 8; break;
}
}
}
for(i=0;i<16;i++)
{
for(j=0;j<song.instrument[i].nnotes;j++) song.instrument[i].note[j].beat = mgetl(fp);
for(j=0;j<song.instrument[i].nnotes;j++) song.instrument[i].note[j].note = mgetc(fp);
for(j=0;j<song.instrument[i].nnotes;j++) song.instrument[i].note[j].length = mgetc(fp);
for(j=0;j<song.instrument[i].nnotes;j++) song.instrument[i].note[j].volume = mgetc(fp);
for(j=0;j<song.instrument[i].nnotes;j++) song.instrument[i].note[j].panning = mgetc(fp);
}
//fclose(fp);
return init_buffers();
}
