/*--------------------------------------------------------------------------*/ SciErr createNamedMatrixOfString(void* _pvCtx, const char* _pstName, int _iRows, int _iCols, const char* const* _pstStrings) { SciErr sciErr = sciErrInit(); // check variable name if (checkNamedVarFormat(_pvCtx, _pstName) == 0) { addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Invalid variable name: %s."), "createNamedMatrixOfString", _pstName); return sciErr; } //return empty matrix if (_iRows == 0 && _iCols == 0) { if (createNamedEmptyMatrix(_pvCtx, _pstName)) { addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix"); return sciErr; } return sciErr; } types::String* pS = new types::String(_iRows, _iCols); if (pS == NULL) { addErrorMessage(&sciErr, API_ERROR_INVALID_NAME, _("%s: Invalid variable name: %s."), "createNamedMatrixOfString", _pstName); return sciErr; } for (int i = 0 ; i < pS->getSize() ; i++) { wchar_t* pstTemp = to_wide_string(_pstStrings[i]); pS->set(i, pstTemp); FREE(pstTemp); } wchar_t* pwstName = to_wide_string(_pstName); symbol::Context* ctx = symbol::Context::getInstance(); symbol::Symbol sym = symbol::Symbol(pwstName); FREE(pwstName); if (ctx->isprotected(sym) == false) { ctx->put(sym, pS); } else { delete pS; addErrorMessage(&sciErr, API_ERROR_REDEFINE_PERMANENT_VAR, _("Redefining permanent variable.\n")); } return sciErr; }
/*--------------------------------------------------------------------------*/ wchar_t* computeTMPDIRW(void) { char* pstTemp = computeTMPDIR(); wchar_t* pstReturn = to_wide_string(pstTemp); FREE(pstTemp); return pstReturn; }
/*--------------------------------------------------------------------------*/ wchar_t* getenvTMPDIRW() { char *SciTemp = getenvTMPDIR(); wchar_t* pstTemp = to_wide_string(SciTemp); delete[] SciTemp; return pstTemp; }
const mxArray *mexGetVariablePtr(const char *workspace, const char *name) { symbol::Context *context = symbol::Context::getInstance(); wchar_t *key = to_wide_string(name); types::InternalType *value = NULL; symbol::Symbol sym = symbol::Symbol(key); if (strcmp(workspace, "base") == 0) { value = context->get(sym); } else if (strcmp(workspace, "caller") == 0) { if (context->isGlobalVisible(sym) == false) { value = context->get(sym); } } else if (strcmp(workspace, "global") == 0) { if (context->isGlobalVisible(sym)) { value = context->getGlobalValue(sym); } } FREE(key); return (mxArray *)value; }
String* String::set(int _iPos, const char* _pcData) { wchar_t* w = to_wide_string(_pcData); String* ret = set(_iPos, w); FREE(w); return ret; }
int mexPutVariable(const char *workspace, const char *varname, const mxArray *pm) { symbol::Context *context = symbol::Context::getInstance(); wchar_t *dest = to_wide_string(varname); if (strcmp(workspace, "base") == 0) { context->putInPreviousScope(context->getOrCreate(symbol::Symbol(dest)), (types::InternalType *)pm); } else if (strcmp(workspace, "caller") == 0) { context->put(symbol::Symbol(dest), (types::InternalType *)pm); } else if (strcmp(workspace, "global") == 0) { context->setGlobalVisible(symbol::Symbol(dest), true); context->put(symbol::Symbol(dest), (types::InternalType *)pm); } else { FREE(dest); return 1; } FREE(dest); return 0; }
static bool import_variable(int file, std::string& name) { int dataset = getDataSetIdFromName(file, name.data()); if (dataset <= 0) { return false; } types::InternalType* data = import_data(dataset); if (data != nullptr) { wchar_t* var = to_wide_string(name.data()); //update macro name if (data->isMacro()) { types::Macro* macro = data->getAs<types::Macro>(); macro->setName(var); symbol::Context::getInstance()->addMacro(macro); } else { //add to context symbol::Context::getInstance()->put(symbol::Symbol(var), data); } FREE(var); return true; } return false; }
/*--------------------------------------------------------------------------*/ char *getlongpathname(char *shortpathname,BOOL *convertok) { char *LongName = NULL; wchar_t *wcshortpathname = to_wide_string(shortpathname); if (wcshortpathname) { wchar_t *wcLongName = getlongpathnameW(wcshortpathname, convertok); if (wcLongName) { LongName = wide_string_to_UTF8(wcLongName); FREE(wcLongName); wcLongName = NULL; } else { LongName = strdup(shortpathname); *convertok = FALSE; } } else { LongName = strdup(shortpathname); *convertok = FALSE; } return LongName; }
static int CopyLineAtPrompt(char **wk_buf, char *line, unsigned int *cursor, unsigned int *cursor_max) { FREE(*wk_buf); if (line) { wchar_t *wtmp = NULL; //** Copy line to current command buffer, usefull in completion case. *wk_buf = MALLOC(sizeof(char) * strlen(line) + 1); strcpy(*wk_buf, line); backspace(*cursor); /* backspace to beginning of line */ printf("%s", *wk_buf); /* copy to screen */ wtmp = to_wide_string(*wk_buf); *cursor = wcslen(wtmp); /* cursor set at end of line */ FREE(wtmp); /* erase extra characters left over if any */ erase_nchar(GET_MAX(0, (*cursor_max - *cursor))); *cursor_max = *cursor; return 1; } else { *wk_buf = (char*) MALLOC(sizeof(char)); (*wk_buf)[0] = '\0'; } return 0; }
/*--------------------------------------------------------------------------*/ BOOL FileExist(char *filename) { #ifdef _MSC_VER wchar_t *wcFilename = to_wide_string(filename); if (wcFilename) { BOOL bOK = FileExistW(wcFilename); FREE(wcFilename); return bOK; } return FALSE; #else FILE* tmpFile=fopen(filename,"r"); if(tmpFile) { fclose(tmpFile); return TRUE; } else { return FALSE; } #endif }
/*--------------------------------------------------------------------------*/ BOOL Set_HOME_PATH(char *DefaultPath) { wchar_t *wHOME = _wgetenv(L"HOME"); if (wHOME == NULL) { wchar_t *wUserProfile = _wgetenv(L"USERPROFILE"); if (wUserProfile) { return SetEnvironmentVariableW(L"HOME", wUserProfile); } else { /* if USERPROFILE is not defined , we use default profile */ wchar_t *wAllUsersProfile = _wgetenv(L"ALLUSERSPROFILE"); if (wAllUsersProfile) { return SetEnvironmentVariableW(L"HOME", wUserProfile); } else { BOOL bRes = FALSE; wchar_t *wDefault = to_wide_string(DefaultPath); if (wDefault) { bRes = SetEnvironmentVariableW(L"HOME", wDefault); FREE(wDefault); wDefault = NULL; } return bRes; } } } return TRUE; }
static int mexCallSCILAB(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs, const char *name) { wchar_t* pwst = to_wide_string(name); symbol::Context *context = symbol::Context::getInstance(); symbol::Symbol *symbol = new symbol::Symbol(pwst); FREE(pwst); types::InternalType *value = context->get(*symbol); types::Function *func = value->getAs<types::Function>(); if (func == NULL) { return 1; } types::typed_list in; types::typed_list out; types::optional_list opt; for (int i = 0; i < nrhs; i++) { in.push_back((types::InternalType*)prhs[i]); } func->call(in, opt, nlhs, out); for (int i = 0; i < nlhs; i++) { plhs[i] = (mxArray *) (out[i]); } return 0; }
/*--------------------------------------------------------------------------*/ static void printf_scilab(char *buffer) { if (buffer) { wchar_t *wcBuffer = NULL; if (getScilabMode() == SCILAB_STD) { ConsolePrintf(buffer); } else { #ifdef _MSC_VER TermPrintf_Windows(buffer); #else printf("%s",buffer); #endif } wcBuffer = to_wide_string(buffer); if (wcBuffer) { diaryWrite(wcBuffer, FALSE); FREE(wcBuffer); wcBuffer = NULL; } } }
/*--------------------------------------------------------------------------*/ int Scierror(int iv, const char *fmt, ...) { int retval = 0; wchar_t* pwstError = NULL; char s_buf[bsiz]; va_list ap; va_start(ap, fmt); #if defined (vsnprintf) || defined (linux) retval = vsnprintf(s_buf, bsiz - 1, fmt, ap ); #else retval = vsnprintf(s_buf, bsiz - 1, fmt, ap); #endif if (retval < 0) { s_buf[bsiz - 1] = '\0'; } va_end(ap); pwstError = to_wide_string(s_buf); setLastError(iv, pwstError, 0, NULL); FREE(pwstError); return retval; }
/*--------------------------------------------------------------------------*/ char *get_full_path(char *_FullPath, const char *_Path, size_t _SizeInBytes) { #if defined(_MSC_VER) char *returnedFullPath = NULL; wchar_t *wPath = to_wide_string((char *)_Path); wchar_t *wFullPath = (wchar_t *) MALLOC(sizeof(wchar_t) * _SizeInBytes); _wfullpath(wFullPath, wPath, _SizeInBytes); returnedFullPath = wide_string_to_UTF8(wFullPath); if (returnedFullPath) { strcpy(_FullPath, returnedFullPath); FREE(returnedFullPath); returnedFullPath = NULL; } if (wPath) { FREE(wPath); wPath = NULL; } if (wFullPath) { FREE(wFullPath); wFullPath = NULL; } return _FullPath; #else char *rp = NULL; int lenPath = (int)strlen(_Path); rp = realpath(_Path, _FullPath); int lenFullPath = 0; int haveFileSep = ((lenPath > 1) && isDirSeparator(_Path[lenPath - 1])); int addFileSep = 0; if (!rp) { strcpy(_FullPath, _Path); normalizePath(_FullPath); } lenFullPath = (int)strlen(_FullPath); addFileSep = ((lenFullPath > 1) && (!isDirSeparator(_FullPath[lenFullPath - 1])) && haveFileSep); if (addFileSep) { char *bufTmp = (char *)MALLOC(sizeof(char) * (lenFullPath + strlen(DIR_SEPARATOR) + 1)); if (bufTmp) { sprintf(bufTmp, "%s%s", _FullPath, DIR_SEPARATOR); strcpy(_FullPath, bufTmp); FREE(bufTmp); bufTmp = NULL; } } return _FullPath; #endif }
/*--------------------------------------------------------------------------*/ char *FindFileExtension(char *filename) { char *extension = NULL; if (filename) { #ifndef _MSC_VER int lengthfilename = (int) strlen(filename); int i = lengthfilename; while(filename[i] != '.' && i > 0) i--; if(i > 0) { int lengthextension = lengthfilename - i; extension = (char*)MALLOC(sizeof(char)*(lengthextension+1)); if (extension) sprintf(extension,"%s",&filename[i]); } #else { wchar_t *wcFilename = to_wide_string(filename); if (wcFilename) { extension = wide_string_to_UTF8(PathFindExtensionW(wcFilename)); FREE(wcFilename); wcFilename = NULL; } } #endif } return extension; }
/*--------------------------------------------------------------------------*/ char *createtempfilename(const char *prefix, BOOL bShortFormat) { char *tempfilename = NULL; #ifdef _MSC_VER wchar_t *wcprefix = to_wide_string(prefix); wchar_t *wcresult = createtempfilenameW(wcprefix, bShortFormat); tempfilename = wide_string_to_UTF8(wcresult); if (wcresult) { FREE(wcresult); wcresult = NULL; } if (wcresult) { FREE(wcresult); wcresult = NULL; } #else char *TmpDir = getTMPDIR(); if (TmpDir) { char TempFileName[PATH_MAX]; sprintf(TempFileName, "%s/%sXXXXXX", TmpDir, prefix); int fd = mkstemp(TempFileName); if (fd != -1) { close(fd); } tempfilename = strdup(TempFileName); } #endif return tempfilename; }
SciErr createComplexHypermatOfPoly(void *_pvCtx, int _iVar, char* _pstVarName, int * _dims, int _ndims, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg) { SciErr sciErr = sciErrInit(); types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx; types::typed_list in = *pStr->m_pIn; types::InternalType** out = pStr->m_pOut; int rhs = _iVar - *getNbInputArgument(_pvCtx); wchar_t* w = to_wide_string(_pstVarName); types::Polynom* p = new types::Polynom(w, _ndims, _dims, _piNbCoef); p->setComplex(true); int size = p->getSize(); if (size == 0) { delete p; out[rhs - 1] = types::Double::Empty(); FREE(w); return sciErr; } types::SinglePoly** s = p->get(); for (int i = 0; i < size; ++i) { s[i]->setCoef(_pdblReal[i], _pdblImg[i]); } out[rhs - 1] = p; FREE(w); return sciErr; }
SciErr createHypermatOfString(void *_pvCtx, int _iVar, int * _dims, int _ndims, const char* const* _pstStrings) { SciErr sciErr = sciErrInit(); types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx; types::typed_list in = *pStr->m_pIn; types::InternalType** out = pStr->m_pOut; int rhs = _iVar - *getNbInputArgument(_pvCtx); types::String* p = new types::String(_ndims, _dims); int size = p->getSize(); if (size == 0) { delete p; out[rhs - 1] = types::Double::Empty(); return sciErr; } for (int i = 0; i < size; ++i) { wchar_t* w = to_wide_string(_pstStrings[i]); p->set(i, w); FREE(w); } out[rhs - 1] = p; return sciErr; }
/*--------------------------------------------------------------------------*/ int wcstat(char* filename, struct _stat *st) { int stat_result = 0; wchar_t *wfilename = to_wide_string(filename); stat_result = _wstat(wfilename, st); FREE(wfilename); return stat_result; }
SciErr createCommonMatrixOfPoly(void* _pvCtx, int _iVar, int _iComplex, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg) { SciErr sciErr = sciErrInit(); if (_pvCtx == NULL) { addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "createComplexMatrixOfPoly" : "createMatrixOfPoly"); return sciErr; } types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx; types::InternalType** out = pStr->m_pOut; int rhs = _iVar - *getNbInputArgument(_pvCtx); //return empty matrix if (_iRows == 0 && _iCols == 0) { types::Double *pDbl = new types::Double(_iRows, _iCols); if (pDbl == NULL) { addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix"); return sciErr; } out[rhs - 1] = pDbl; return sciErr; } wchar_t* pstTemp = to_wide_string(_pstVarName); std::wstring wstTemp(pstTemp); types::Polynom* pP = new types::Polynom(wstTemp, _iRows, _iCols, _piNbCoef); FREE(pstTemp); if (pP == NULL) { addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocated variable"), _iComplex ? "createComplexMatrixOfPoly" : "createMatrixOfPoly"); return sciErr; } if (_iComplex) { pP->setComplex(true); } out[rhs - 1] = pP; for (int i = 0 ; i < pP->getSize() ; i++) { types::Double* pD = new types::Double(_piNbCoef[i], 1, _iComplex == 1); pD->set(_pdblReal[i]); if (_iComplex) { pD->setImg(_pdblImg[i]); } pP->setCoef(i, pD); delete pD; } return sciErr; }
wchar_t *getLocaleUserInfo(void) { char *cUserLanguage = NULL; CFLocaleRef userLocaleRef = CFLocaleCopyCurrent(); CFStringRef userLanguage = CFLocaleGetIdentifier(userLocaleRef); if (getenv( "LANG" )) { /* Mac OS X does not respect the LANG variable. We do it ourself. */ return to_wide_string(getenv("LANG")); } else { cUserLanguage = (char *) malloc(((int) CFStringGetLength(userLanguage) + 1) * sizeof(char)); CFStringGetCString(userLanguage, cUserLanguage, ((int) CFStringGetLength(userLanguage)) + 1, kCFStringEncodingUTF8); } return to_wide_string(cUserLanguage); }
/*--------------------------------------------------------------------------*/ static int GetIndexLastModifiedFileInList(char **ListFilename, int numberelemnts) { #ifdef _MSC_VER struct _stat buf; #else struct stat buf; #endif int i = 0; int RetVal = 0; int RetIndex = 1; long int MaxTime = 0; for (i = 0; i < numberelemnts ; i++) { int resultstat = 0; char *FileName = NULL; FileName = expandPathVariable(ListFilename[i]); #ifdef _MSC_VER if (FileName) { if ( (FileName[strlen(FileName) - 1] == '/') || (FileName[strlen(FileName) - 1] == '\\') ) { FileName[strlen(FileName) - 1] = '\0'; } } { wchar_t *pszFileName = to_wide_string(FileName); resultstat = _wstat(pszFileName, &buf ); FREE(pszFileName); } #else resultstat = stat(FileName, &buf ); #endif if (resultstat == 0) { if ((long int)buf.st_mtime > MaxTime) { MaxTime = (long int)buf.st_mtime; RetIndex = i + 1; } } FREE(FileName); FileName = NULL; } RetVal = RetIndex; return RetVal; }
void ConfigVariable::setCommandLineArgs(int _iArgs, char** _pstArgs) { m_Args.clear(); for (int i = 0 ; i < _iArgs ; i++) { wchar_t * ws = to_wide_string(_pstArgs[i]); m_Args.push_back(ws); FREE(ws); } }
/*--------------------------------------------------------------------------*/ BOOL setenvc(const char *stringIn, const char *valueIn) { #ifdef _MSC_VER wchar_t* wstringIn = to_wide_string(stringIn); wchar_t* wvalueIn = to_wide_string(valueIn); if (setenvcW(wstringIn, wvalueIn) == 0) { FREE(wstringIn); FREE(wvalueIn); return FALSE; } FREE(wstringIn); FREE(wvalueIn); #else /* linux and Mac OS X */ /* setenv() function is strongly preferred to putenv() */ /* http://developer.apple.com/documentation/Darwin/Reference/ManPages/man3/setenv.3.html */ #ifndef _MAX_ENV #define _MAX_ENV 32767 #endif int len_env = (int)(strlen(stringIn) + strlen(valueIn) + 1); if (len_env < _MAX_ENV) { if ( setenv(stringIn, valueIn, 1) ) { return FALSE; } } else { return FALSE; } setenvtcl(stringIn, valueIn); #endif return TRUE; }
int mxAddField(mxArray *ptr, const char *fieldname) { if (!mxIsStruct(ptr)) { return -1; } Struct *pa = (Struct *)ptr; wchar_t *wfieldname = to_wide_string(fieldname); pa->addField(wfieldname); return mxGetFieldNumber(ptr, fieldname); }
static char *getLineBeforeCaret(char *wk_buf, unsigned int *cursor) { char *line = NULL; wchar_t * wtmp = to_wide_string(wk_buf); wtmp[*cursor] = 0; line = wide_string_to_UTF8(wtmp); FREE(wtmp); return line; }
mxArray *mxCreateStructArray(int ndim, const int *dims, int nfields, const char **field_names) { types::Struct *ptr = new types::Struct(ndim, (int *)dims); for (int i = 0; i < nfields; i++) { wchar_t *name = to_wide_string(field_names[i]); ptr->addField(name); FREE(name); } return (mxArray *)ptr; }
FILE *fdopen(int handle, const char *mode) { WCHAR *wmode = to_wide_string(mode); FILE *result; if(wmode != NULL) result = _wfdopen((void *)handle, wmode); else result = NULL; free(wmode); return result; }
String::String(const char *_pstData) { wchar_t** pwsData = NULL; int piDims[] = {1, 1}; create(piDims, 2, &pwsData, NULL); wchar_t* data = to_wide_string(const_cast<char*>(_pstData)); set(0, 0, data); FREE(data); #ifndef NDEBUG Inspector::addItem(this); #endif }