QString KateTemplateScript::invoke(KateView* view, const QString& functionName, const QString &srcText) {
if(!setView(view))
return QString();
clearExceptions();
QScriptValue myFunction = function(functionName);
if(!myFunction.isValid()) {
return QString();
}
QScriptValueList arguments;
arguments << QScriptValue(m_engine, srcText);
QScriptValue result = myFunction.call(QScriptValue(), arguments);
if(m_engine->hasUncaughtException()) {
displayBacktrace(result, "Error while calling helper function");
return QString();
}
if (result.isNull()) {
return QString();
}
return result.toString();
}
bool KateScript::hasException(const QScriptValue& object, const QString& file)
{
if(m_engine->hasUncaughtException()) {
displayBacktrace(object, i18n("Error loading script %1\n", file));
m_errorMessage = i18n("Error loading script %1", file);
delete m_engine;
m_engine = 0;
m_loadSuccessful = false;
return true;
}
return false;
}
void elog::logChar(int32_t _id, int32_t _level, int32_t _ligne, const char* _funcName, const char* _log) {
// special callback mode:
if (callbackUserLog != nullptr) {
const char* libName = "";
if (_id >= 0) {
libName = getList()[_id].first.c_str();
}
g_lock.lock();
if (callbackUserLog != nullptr) {
callbackUserLog(libName, elog::level(_level), _ligne, _funcName, _log);
}
g_lock.unlock();
return;
}
char handle[LENGHT_MAX_LOG] = "";
memset(handle, ' ', LENGHT_MAX_LOG);
handle[0] = '\0';
char* pointer = handle;
if(getColor() == true) {
switch(_level) {
default:
// nothing to do ...
break;
case elog::level_critical:
strcat(pointer, ETK_BASH_COLOR_BOLD_RED);
break;
case elog::level_error:
strcat(pointer, ETK_BASH_COLOR_RED);
break;
case elog::level_warning:
strcat(pointer, ETK_BASH_COLOR_MAGENTA);
break;
case elog::level_info:
strcat(pointer, ETK_BASH_COLOR_CYAN);
break;
case elog::level_debug:
strcat(pointer, ETK_BASH_COLOR_YELLOW);
break;
case elog::level_verbose:
strcat(pointer, ETK_BASH_COLOR_WHITE);
break;
case elog::level_print:
strcat(pointer, ETK_BASH_COLOR_WHITE);
break;
}
pointer = handle+strlen(handle);
}
if(getTime() == true) {
getDisplayTime(pointer);
pointer = handle+strlen(handle);
}
#ifndef __TARGET_OS__Android
switch(_level) {
default:
strcat(pointer, "[?] ");
break;
case elog::level_print:
strcat(pointer, "[P] ");
break;
case elog::level_critical:
strcat(pointer, "[C] ");
break;
case elog::level_error:
strcat(pointer, "[E] ");
break;
case elog::level_warning:
strcat(pointer, "[W] ");
break;
case elog::level_info:
strcat(pointer, "[I] ");
break;
case elog::level_debug:
strcat(pointer, "[D] ");
break;
case elog::level_verbose:
strcat(pointer, "[V] ");
break;
}
pointer = handle+strlen(handle);
#endif
if (getLibName() == true) {
if (_id >= 0) {
int32_t len = strlen(handle);
strcat(pointer, getList()[_id].first.c_str());
pointer = handle+strlen(handle);
while (strlen(handle) - len < getNameSizeLog()) {
*pointer++ = ' ';
*pointer = '\0';
}
*pointer++ = '|';
*pointer++ = ' ';
*pointer = '\0';
}
}
#ifdef ELOG_BUILD_ETHREAD
if(getThreadId() == true) {
// display thread ID
uint32_t iddd = ethread::getId();
sprintf(pointer, "%3d", iddd);
pointer = handle+strlen(handle);
*pointer++ = ' ';
*pointer++ = '|';
*pointer++ = ' ';
*pointer = '\0';
}
if(getThreadNameEnable() == true) {
// display thread ID
std::string name = ethread::getName();
if (name.size() >= getThreadSizeLog() ) {
getThreadSizeLog() = name.size() + 1;
}
sprintf(pointer, "%s", name.c_str());
pointer = handle+strlen(handle);
size_t nbSpaceToAdd = getThreadSizeLog()-name.size();
for (size_t iii=0; iii<nbSpaceToAdd; ++iii) {
*pointer++ = ' ';
*pointer = '\0';
}
*pointer++ = '|';
*pointer++ = ' ';
*pointer = '\0';
}
#endif
if(getLine() == true) {
if (_ligne >= 0) {
sprintf(pointer, "(l=%5d)", _ligne);
pointer = handle+strlen(handle);
*pointer++ = ' ';
*pointer = '\0';
}
}
// TODO :Maybe optimize this one ...
if(getFunction() == true) {
int32_t len = strlen(handle);
char tmpName[1024];
char *tmpPointer = tmpName;
if (_funcName != nullptr) {
// cleen for android :
char* startPos = strchr((char*)_funcName, ' ');
char* stopPos = strchr((char*)_funcName, '(');
if (startPos != nullptr) {
if (stopPos != nullptr) {
char* startPos2 = strchr(startPos+1, ' ');
while ( startPos2 != nullptr
&& startPos2 < stopPos) {
startPos = startPos2;
startPos2 = strchr(startPos+1, ' ');
}
if(uint64_t(stopPos) < uint64_t(startPos)) {
snprintf(tmpPointer, std::min(uint64_t(1024), uint64_t(stopPos)-uint64_t(_funcName)), "%s", _funcName);
} else {
snprintf(tmpPointer, std::min(uint64_t(1024), uint64_t(stopPos)-uint64_t(startPos)), "%s", startPos+1);
}
} else {
snprintf(tmpPointer, 1024, "%s", startPos);
}
} else {
if (stopPos != nullptr) {
snprintf(tmpPointer, std::min(uint64_t(1024), uint64_t(stopPos)-uint64_t(_funcName)+1), "%s", _funcName);
} else {
snprintf(tmpPointer, 1024, "%s", _funcName);
}
}
tmpPointer = tmpPointer+strlen(tmpPointer);
}
size_t lenFunc = strlen(tmpName);
if (lenFunc >= getFunctionSizeLog()) {
getFunctionSizeLog() = lenFunc+1;
}
size_t nbSpaceToAdd = getFunctionSizeLog() - lenFunc;
for (size_t iii=0; iii<nbSpaceToAdd; ++iii) {
*tmpPointer++ = ' ';
*tmpPointer = '\0';
}
*tmpPointer++ = '|';
*tmpPointer++ = ' ';
*tmpPointer = '\0';
strcat(pointer, tmpName);
pointer += strlen(tmpName);
}
if (strlen(_log) > LENGHT_MAX_LOG - strlen(handle)-20) {
memcpy(pointer, _log, LENGHT_MAX_LOG - strlen(handle)-21);
handle[1024-25] = ' ';
handle[1024-24] = '.';
handle[1024-23] = '.';
handle[1024-22] = '.';
handle[1024-21] = '\0';
} else {
strcat(pointer, _log);
}
pointer = handle+strlen(handle);
if(getColor() == true) {
strcat(pointer, ETK_BASH_COLOR_NORMAL);
}
g_lock.lock();
{
FILE*& file = getLogFile();
// close file only if needed ...
if (file != nullptr) {
*pointer++ = '\n';
*pointer = '\0';
fprintf(file, handle);
switch(_level) {
default:
break;
case elog::level_critical:
case elog::level_error:
fflush(file);
break;
}
// if we log in file, we have no need to log otherwise ... just "tail -f log.txt"
g_lock.unlock();
return;
}
}
#if defined(__TARGET_OS__Android)
switch(_level) {
default:
__android_log_print(ANDROID_LOG_VERBOSE, "EWOL", "%s", handle);
break;
case elog::level_print:
__android_log_print(ANDROID_LOG_INFO, "EWOL", "%s", handle);
break;
case elog::level_critical:
__android_log_print(ANDROID_LOG_FATAL, "EWOL", "%s", handle);
break;
case elog::level_error:
__android_log_print(ANDROID_LOG_ERROR, "EWOL", "%s", handle);
break;
case elog::level_warning:
__android_log_print(ANDROID_LOG_WARN, "EWOL", "%s", handle);
break;
case elog::level_info:
__android_log_print(ANDROID_LOG_INFO, "EWOL", "%s", handle);
break;
case elog::level_debug:
__android_log_print(ANDROID_LOG_DEBUG, "EWOL", "%s", handle);
break;
case elog::level_verbose:
__android_log_print(ANDROID_LOG_VERBOSE, "EWOL", "%s", handle);
break;
}
#elif defined(__TARGET_OS__IOs)
iosNSLog(handle);
#else
std::cout << handle << std::endl;
#endif
g_lock.unlock();
if (_level == level_critical) {
std::this_thread::sleep_for(std::chrono::milliseconds(700));
displayBacktrace(true, 2);
}
// Display backtrace to facilitate the error problems
if ( _level == level_error
&& getDisplayBackTrace() == true) {
displayBacktrace(false, 2);
}
}
