atria-soft/etk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] rewirk Regular expression to be Unicode complient and add backtrace in debug

Browse Source
This commit is contained in:
Edouard DUPIN 2013-05-16 21:24:27 +02:00
parent 5f8b094486
commit b75f2ea698
9 changed files with 751 additions and 1175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
etk/Debug.h
View File

@ -34,7 +34,10 @@ void GeneralDebugSetLevel(etk::logLevel_te ccc);
}while(0) }while(0)
#define ETK_CRITICAL(libName, data) ETK_DBG_COMMON(libName, etk::LOG_LEVEL_CRITICAL, data) #define ETK_CRITICAL(libName, data) do { \
ETK_DBG_COMMON(libName, etk::LOG_LEVEL_CRITICAL, data); \
etk::DisplayBacktrace(); \
}while(0)
#if DEBUG_LEVEL > 0 #if DEBUG_LEVEL > 0
# define ETK_WARNING(libName, data) ETK_DBG_COMMON(libName, etk::LOG_LEVEL_WARNING, data) # define ETK_WARNING(libName, data) ETK_DBG_COMMON(libName, etk::LOG_LEVEL_WARNING, data)

168
etk/RegExp.cpp
View File

@ -64,21 +64,11 @@ const etk::convertionTable_ts etk::constConvertionTable[] = {
}; };
const int32_t etk::constConvertionTableSize = sizeof(etk::constConvertionTable) / sizeof(etk::convertionTable_ts) ; const int32_t etk::constConvertionTableSize = sizeof(etk::constConvertionTable) / sizeof(etk::convertionTable_ts) ;
void etk::DisplayElem(const etk::Vector<etk::UniChar>& _data, int32_t _start, int32_t _stop)
void etk::DisplayData(etk::Vector<char> &data)
{ {
int32_t i;
for (i=0; i<(int32_t)data.Size() ; i++) {
etk::cout<< (char)(data[i]&0x00FF );
}
}
void etk::DisplayElem(etk::Vector<int16_t> &data, int32_t start, int32_t stop)
{
int32_t i;
etk::cout<< ETK_BASH_COLOR_NORMAL; etk::cout<< ETK_BASH_COLOR_NORMAL;
for (i=start; i<(int32_t)data.Size() && i<stop ; i++) { for (int32_t iii=_start; iii<_data.Size() && iii<_stop ; iii++) {
switch(data[i]) switch(_data[iii].Get())
{ {
case REGEXP_OPCODE_PTHESE_IN: etk::cout<<ETK_BASH_COLOR_RED << (char*)"(" << ETK_BASH_COLOR_NORMAL; break; case REGEXP_OPCODE_PTHESE_IN: etk::cout<<ETK_BASH_COLOR_RED << (char*)"(" << ETK_BASH_COLOR_NORMAL; break;
case REGEXP_OPCODE_PTHESE_OUT: etk::cout<<ETK_BASH_COLOR_RED << (char*)")" << ETK_BASH_COLOR_NORMAL; break; case REGEXP_OPCODE_PTHESE_OUT: etk::cout<<ETK_BASH_COLOR_RED << (char*)")" << ETK_BASH_COLOR_NORMAL; break;
@ -105,13 +95,13 @@ void etk::DisplayElem(etk::Vector<int16_t> &data, int32_t start, int32_t stop)
case REGEXP_OPCODE_WORD_NOT: etk::cout<<ETK_BASH_COLOR_MAGENTA << (char*)"\\W" << ETK_BASH_COLOR_NORMAL; break; case REGEXP_OPCODE_WORD_NOT: etk::cout<<ETK_BASH_COLOR_MAGENTA << (char*)"\\W" << ETK_BASH_COLOR_NORMAL; break;
case '\n': etk::cout<<ETK_BASH_COLOR_MAGENTA << (char*)"\\n" << ETK_BASH_COLOR_NORMAL; break; case '\n': etk::cout<<ETK_BASH_COLOR_MAGENTA << (char*)"\\n" << ETK_BASH_COLOR_NORMAL; break;
case '\t': etk::cout<<ETK_BASH_COLOR_MAGENTA << (char*)"\\t" << ETK_BASH_COLOR_NORMAL; break; case '\t': etk::cout<<ETK_BASH_COLOR_MAGENTA << (char*)"\\t" << ETK_BASH_COLOR_NORMAL; break;
default: etk::cout<< (char)(data[i]&0x00FF ); break; default: etk::cout<< (char)(_data[iii].Get()&0x00FF ); break;
} }
} }
} }
char * etk::levelSpace(int32_t level) char * etk::levelSpace(int32_t _level)
{ {
switch(level) switch(_level)
{ {
case 0: return (char*)""; case 0: return (char*)"";
case 1: return (char*)" "; case 1: return (char*)" ";
@ -135,79 +125,74 @@ char * etk::levelSpace(int32_t level)
} }
int32_t etk::GetLenOfPTheseElem(etk::Vector<int16_t> &data, int32_t startPos) int32_t etk::GetLenOfPTheseElem(const etk::Vector<etk::UniChar>& _data, int32_t _startPos)
{ {
if (startPos>=data.Size()){ if (_startPos>=_data.Size()){
return 0; return 0;
} }
int32_t pos = startPos; int32_t pos = _startPos;
int32_t nbOpen = 0; int32_t nbOpen = 0;
// special case of the (...) or | ==> we search '|' or ')' // special case of the (...) or | ==> we search '|' or ')'
if( REGEXP_OPCODE_PTHESE_OUT == data[pos] if( _data[pos] == REGEXP_OPCODE_PTHESE_OUT
|| REGEXP_OPCODE_PIPE == data[pos]) { || _data[pos] == REGEXP_OPCODE_PIPE) {
return 0; return 0;
} }
// find size ... // find size ...
while (pos < (int32_t)data.Size() ) { while (pos < (int32_t)_data.Size() ) {
if(REGEXP_OPCODE_PTHESE_IN == data[pos]) { if(_data[pos] == REGEXP_OPCODE_PTHESE_IN) {
// find a sub section : // find a sub section :
nbOpen++; nbOpen++;
} else if(0 < nbOpen) { } else if(0 < nbOpen) {
if (REGEXP_OPCODE_PTHESE_OUT == data[pos]) if (_data[pos] == REGEXP_OPCODE_PTHESE_OUT) {
{
nbOpen--; nbOpen--;
if (0 > nbOpen) { if (0 > nbOpen) {
TK_ERROR("Error in the (...) find element at "<< pos); TK_ERROR("Error in the (...) find element at "<< pos);
return -1; return -1;
} }
} }
} else if( REGEXP_OPCODE_PTHESE_OUT == data[pos] } else if( _data[pos] == REGEXP_OPCODE_PTHESE_OUT
|| REGEXP_OPCODE_PIPE == data[pos]) || _data[pos] == REGEXP_OPCODE_PIPE) {
{
// Find the end of the (...) // Find the end of the (...)
// just return the size inside // just return the size inside
int32_t sizeInside = pos - startPos; int32_t sizeInside = pos - _startPos;
if (0 >= sizeInside) { if (0 >= sizeInside) {
TK_ERROR("Error in the (...) no data at "<< pos-1); TK_ERROR("Error in the (...) no data at "<< pos-1);
return -1; return -1;
} else { } else {
return sizeInside; return sizeInside;
} }
} }
pos++; pos++;
} }
return pos - startPos; return pos - _startPos;
} }
int32_t etk::GetLenOfPThese(etk::Vector<int16_t> &data, int32_t startPos) int32_t etk::GetLenOfPThese(const etk::Vector<etk::UniChar>& _data, int32_t _startPos)
{ {
int32_t pos = startPos; int32_t pos = _startPos;
int32_t nbOpen = 0; int32_t nbOpen = 0;
// special case of the (...) or | ==> we search '|' or ')' // special case of the (...) or | ==> we search '|' or ')'
if( REGEXP_OPCODE_PTHESE_OUT == data[pos]) { if(_data[pos]==REGEXP_OPCODE_PTHESE_OUT) {
return 0; return 0;
} else if( REGEXP_OPCODE_PTHESE_IN == data[pos]) } else if(_data[pos]==REGEXP_OPCODE_PTHESE_IN) {
{
pos++; pos++;
// find size ... // find size ...
while (pos < (int32_t)data.Size() ) { while (pos < _data.Size() ) {
if(REGEXP_OPCODE_PTHESE_IN == data[pos]) { if(_data[pos]==REGEXP_OPCODE_PTHESE_IN) {
// find a sub section : // find a sub section :
nbOpen++; nbOpen++;
} else if(0 < nbOpen) { } else if(0 < nbOpen) {
if (REGEXP_OPCODE_PTHESE_OUT == data[pos]) if (_data[pos]==REGEXP_OPCODE_PTHESE_OUT) {
{
nbOpen--; nbOpen--;
if (0 > nbOpen) { if (0 > nbOpen) {
TK_ERROR("Error in the (...) find element at "<< pos); TK_ERROR("Error in the (...) find element at "<< pos);
return -1; return -1;
} }
} }
} else if( REGEXP_OPCODE_PTHESE_OUT == data[pos]) } else if(_data[pos]==REGEXP_OPCODE_PTHESE_OUT) {
{
// Find the end of the (...) // Find the end of the (...)
// just return the size inside // just return the size inside
int32_t sizeInside = pos - startPos-1; int32_t sizeInside = pos - _startPos-1;
if (0 >= sizeInside) { if (0 >= sizeInside) {
TK_ERROR("Error in the (...) no data at "<< pos-1); TK_ERROR("Error in the (...) no data at "<< pos-1);
return -1; return -1;
@ -224,31 +209,29 @@ int32_t etk::GetLenOfPThese(etk::Vector<int16_t> &data, int32_t startPos)
} }
int32_t etk::GetLenOfBracket(etk::Vector<int16_t> &data, int32_t startPos) int32_t etk::GetLenOfBracket(const etk::Vector<etk::UniChar>& _data, int32_t _startPos)
{ {
int32_t pos = startPos; int32_t pos = _startPos;
// special case of the (...) or | ==> we search '|' or ')' // special case of the (...) or | ==> we search '|' or ')'
if( REGEXP_OPCODE_BRACKET_OUT == data[pos]) { if(_data[pos]==REGEXP_OPCODE_BRACKET_OUT) {
return 0; return 0;
} else if( REGEXP_OPCODE_BRACKET_IN == data[pos]) { } else if(_data[pos] == REGEXP_OPCODE_BRACKET_IN) {
pos++; pos++;
// find size ... // find size ...
while (pos < (int32_t)data.Size() ) { while (pos < _data.Size() ) {
if(REGEXP_OPCODE_BRACKET_OUT == data[pos]) { if(_data[pos]==REGEXP_OPCODE_BRACKET_OUT) {
// Find the end of the [...] // Find the end of the [...]
// just return the size inside // just return the size inside
int32_t sizeInside = pos - startPos -1 ; int32_t sizeInside = pos - _startPos -1 ;
if (0 >= sizeInside) { if (0 >= sizeInside) {
TK_ERROR("Error in the [...] no data at "<< pos-1); TK_ERROR("Error in the [...] no data at "<< pos-1);
return sizeInside; return sizeInside;
} else { } else {
return sizeInside; return sizeInside;
} }
} else if( REGEXP_OPCODE_TO != data[pos] } else if( _data[pos] != REGEXP_OPCODE_TO
&& ( 0 > data[pos] && _data[pos] > 0xFF ) {
|| 0xFF < data[pos]) ) TK_ERROR("Error in the [...] not permited element at "<< pos << " '" << (char)_data[pos].Get() << "'");
{
TK_ERROR("Error in the [...] not permited element at "<< pos << " '" << (char)data[pos] << "'");
return false; return false;
} }
pos++; pos++;
@ -260,31 +243,30 @@ int32_t etk::GetLenOfBracket(etk::Vector<int16_t> &data, int32_t startPos)
} }
int32_t etk::GetLenOfBrace(etk::Vector<int16_t> &data, int32_t startPos) int32_t etk::GetLenOfBrace(const etk::Vector<etk::UniChar>& _data, int32_t _startPos)
{ {
int32_t pos = startPos; int32_t pos = _startPos;
// special case of the (...) or | ==> we search '|' or ')' // special case of the (...) or | ==> we search '|' or ')'
if( REGEXP_OPCODE_BRACE_OUT == data[pos]) { if(_data[pos]==REGEXP_OPCODE_BRACE_OUT) {
return 0; return 0;
} else if( REGEXP_OPCODE_BRACE_IN == data[pos]) { } else if(_data[pos]==REGEXP_OPCODE_BRACE_IN) {
pos++; pos++;
// find size ... // find size ...
while (pos < (int32_t)data.Size() ) { while (pos < _data.Size() ) {
if(REGEXP_OPCODE_BRACE_OUT == data[pos]) { if(_data[pos]==REGEXP_OPCODE_BRACE_OUT) {
// Find the end of the [...] // Find the end of the [...]
// just return the size inside // just return the size inside
int32_t sizeInside = pos - startPos -1 ; int32_t sizeInside = pos - _startPos -1 ;
if (0 >= sizeInside) { if (0 >= sizeInside) {
TK_ERROR("Error in the {...} no data at "<< pos-1); TK_ERROR("Error in the {...} no data at "<< pos-1);
return sizeInside; return sizeInside;
} else { } else {
return sizeInside; return sizeInside;
} }
} else if( ',' != data[pos] } else if( _data[pos] != ','
&& ( '0' > data[pos] && ( _data[pos] < '0'
|| '9' < data[pos]) ) || _data[pos] > '9') ) {
{ TK_ERROR("Error in the {...} not permited element at "<< pos << " '" << _data[pos].Get() << "'");
TK_ERROR("Error in the {...} not permited element at "<< pos << " '" << (char)data[pos] << "'");
return false; return false;
} }
pos++; pos++;
@ -296,13 +278,13 @@ int32_t etk::GetLenOfBrace(etk::Vector<int16_t> &data, int32_t startPos)
} }
int32_t etk::GetLenOfNormal(etk::Vector<int16_t> &data, int32_t startPos) int32_t etk::GetLenOfNormal(const etk::Vector<etk::UniChar>& _data, int32_t _startPos)
{ {
int32_t pos = startPos; int32_t pos = _startPos;
// find size ... // find size ...
while (pos < (int32_t)data.Size() ) { while (pos < _data.Size() ) {
switch(data[pos]) switch(_data[pos].Get())
{ {
case REGEXP_OPCODE_PTHESE_IN: case REGEXP_OPCODE_PTHESE_IN:
case REGEXP_OPCODE_PTHESE_OUT: case REGEXP_OPCODE_PTHESE_OUT:
@ -328,7 +310,7 @@ int32_t etk::GetLenOfNormal(etk::Vector<int16_t> &data, int32_t startPos)
case REGEXP_OPCODE_WORD_NOT: case REGEXP_OPCODE_WORD_NOT:
{ {
// just return the size inside // just return the size inside
int32_t sizeInside = pos - startPos; int32_t sizeInside = pos - _startPos;
if (0 >= sizeInside) { if (0 >= sizeInside) {
TK_ERROR("Error in the normal data : no data ..."); TK_ERROR("Error in the normal data : no data ...");
} }
@ -341,11 +323,11 @@ int32_t etk::GetLenOfNormal(etk::Vector<int16_t> &data, int32_t startPos)
} }
pos++; pos++;
} }
return pos - startPos ; return pos - _startPos ;
} }
bool etk::ParseBrace(etk::Vector<int16_t> &data, int32_t &min, int32_t &max) bool etk::ParseBrace(const etk::Vector<etk::UniChar>& _data, int32_t& _min, int32_t& _max)
{ {
//TK_INFO("parse {...} in "; DisplayElem(data); ); //TK_INFO("parse {...} in "; DisplayElem(data); );
int32_t k=0; int32_t k=0;
@ -353,36 +335,36 @@ bool etk::ParseBrace(etk::Vector<int16_t> &data, int32_t &min, int32_t &max)
int32_t firstElement = 0; int32_t firstElement = 0;
int32_t SecondElement = 0; int32_t SecondElement = 0;
while(k<data.Size()) { while(k<_data.Size()) {
if (',' == (char)data[k]) { if (_data[k]==',') {
k++; k++;
break; break;
} if ('}' == (char)data[k]) { } if (_data[k]=='}') {
SecondElement = firstElement; SecondElement = firstElement;
goto allIsSet; goto allIsSet;
} else if ('0' <= (char)data[k] && '9' >= (char)data[k]) { } else if(true==_data[k].IsInteger()) {
firstElement *=10; firstElement *=10;
firstElement += (char)data[k] - '0'; firstElement += _data[k].ToInt32();
} else { } else {
TK_ERROR("Can not parse this element " << (char)data[k] << " at pos " << k); TK_ERROR("Can not parse this element " << (char)_data[k].Get() << " at pos " << k);
return false; return false;
} }
k++; k++;
} }
if (k==data.Size()) { if (k==_data.Size()) {
SecondElement = firstElement; SecondElement = firstElement;
} }
while(k<data.Size()) { while(k<_data.Size()) {
if (',' == (char)data[k]) { if (_data[k]==',') {
TK_ERROR("Can not find a second , in {} at pos " << k); TK_ERROR("Can not find a second , in {} at pos " << k);
return false; return false;
} if ('}' == (char)data[k]) { } if (_data[k]=='}') {
goto allIsSet; goto allIsSet;
} else if ('0' <= (char)data[k] && '9' >= (char)data[k]) { } else if (true==_data[k].IsInteger()) {
SecondElement *=10; SecondElement *=10;
SecondElement += (char)data[k] - '0'; SecondElement += _data[k].ToInt32();
} else { } else {
TK_ERROR("Can not parse this element " << (char)data[k] << " at pos " << k); TK_ERROR("Can not parse this element " << _data[k] << " at pos " << k);
return false; return false;
} }
k++; k++;
@ -390,14 +372,14 @@ bool etk::ParseBrace(etk::Vector<int16_t> &data, int32_t &min, int32_t &max)
allIsSet: allIsSet:
if (SecondElement == 0 && firstElement != 0) { if (SecondElement == 0 && firstElement != 0) {
min = 0; _min = 0;
max = firstElement; _max = firstElement;
} else { } else {
min = firstElement; _min = firstElement;
max = SecondElement; _max = SecondElement;
} }
if (min > max) { if (_min > _max) {
TK_ERROR("Minimum=" << min << " can not be < maximum=" << max ); TK_ERROR("Minimum=" << _min << " can not be < maximum=" << _max );
return false; return false;
} }
return true; return true;

1474
etk/RegExp.h
View File

File diff suppressed because it is too large Load Diff

102
etk/Stream.cpp
View File

@ -8,18 +8,53 @@
#include <etk/types.h> #include <etk/types.h>
#include <etk/Stream.h> #include <etk/Stream.h>
#include <etk/DebugInternal.h>
#if defined(__TARGET_OS__Linux) && DEBUG_LEVEL > 2
#include <execinfo.h>
#include <cxxabi.h>
#include <dlfcn.h>
#define MAX_DEPTH (256)
void etk::DisplayBacktrace(void)
{
// retrieve call-stack
void * trace[MAX_DEPTH];
int stack_depth = backtrace(trace, MAX_DEPTH);
TK_ERROR("Back-trace : ");
for (int32_t i = 1; i < stack_depth; i++) {
Dl_info dlinfo;
if(!dladdr(trace[i], &dlinfo)) {
break;
}
const char * symname = dlinfo.dli_sname;
int status;
char * demangled = abi::__cxa_demangle(symname, NULL, 0, &status);
if(status == 0 && demangled) {
symname = demangled;
}
TK_WARNING(" " << dlinfo.dli_fname << ": ");
TK_ERROR(" " << symname);
if(NULL != demangled) {
free(demangled);
}
}
//assert(false);
}
#else
void etk::DisplayBacktrace(void)
{
}
#endif
etk::CCout etk::cout; etk::CCout etk::cout;
etk::CEndl etk::endl; etk::CEndl etk::endl;
etk::CHex etk::hex;
etk::CStart etk::cstart; etk::CStart etk::cstart;
#if defined(__TARGET_OS__Android) #if defined(__TARGET_OS__Android)
# include <android/log.h> # include <android/log.h>
# define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "EWOL", __VA_ARGS__))
# define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "EWOL", __VA_ARGS__))
# define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "EWOL", __VA_ARGS__))
#endif #endif
etk::CCout& etk::operator <<(etk::CCout &os, const etk::logLevel_te obj) etk::CCout& etk::operator <<(etk::CCout &os, const etk::logLevel_te obj)
@ -30,36 +65,54 @@ etk::CCout& etk::operator <<(etk::CCout &os, const etk::logLevel_te obj)
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_BOLD_RED; os << ETK_BASH_COLOR_BOLD_RED;
#endif #endif
#if defined(__TARGET_OS__Android)
m_levelAndroid = ANDROID_LOG_FATAL;
#endif
os << "[C]"; os << "[C]";
break; break;
case LOG_LEVEL_ERROR: case LOG_LEVEL_ERROR:
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_RED; os << ETK_BASH_COLOR_RED;
#endif #endif
#if defined(__TARGET_OS__Android)
m_levelAndroid = ANDROID_LOG_ERROR;
#endif
os << "[E]"; os << "[E]";
break; break;
case LOG_LEVEL_WARNING: case LOG_LEVEL_WARNING:
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_MAGENTA; os << ETK_BASH_COLOR_MAGENTA;
#endif #endif
#if defined(__TARGET_OS__Android)
m_levelAndroid = ANDROID_LOG_WARN;
#endif
os << "[W]"; os << "[W]";
break; break;
case LOG_LEVEL_INFO: case LOG_LEVEL_INFO:
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_CYAN; os << ETK_BASH_COLOR_CYAN;
#endif #endif
#if defined(__TARGET_OS__Android)
m_levelAndroid = ANDROID_LOG_INFO;
#endif
os << "[I]"; os << "[I]";
break; break;
case LOG_LEVEL_DEBUG: case LOG_LEVEL_DEBUG:
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_YELLOW; os << ETK_BASH_COLOR_YELLOW;
#endif #endif
#if defined(__TARGET_OS__Android)
m_levelAndroid = ANDROID_LOG_DEBUG;
#endif
os << "[D]"; os << "[D]";
break; break;
case LOG_LEVEL_VERBOSE: case LOG_LEVEL_VERBOSE:
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_WHITE; os << ETK_BASH_COLOR_WHITE;
#endif #endif
#if defined(__TARGET_OS__Android)
m_levelAndroid = ANDROID_LOG_VERBOSE;
#endif
os << "[V]"; os << "[V]";
break; break;
default: default:
@ -73,7 +126,9 @@ etk::CCout& etk::operator <<(etk::CCout &os, const etk::logLevel_te obj)
etk::CCout::CCout() etk::CCout::CCout()
{ {
hex=false; #if defined(__TARGET_OS__Android)
m_levelAndroid = 0;
#endif
memset(m_tmpChar, 0, (MAX_LOG_SIZE+1)*sizeof(char)); memset(m_tmpChar, 0, (MAX_LOG_SIZE+1)*sizeof(char));
}; };
@ -84,18 +139,10 @@ etk::CCout::~CCout()
}; };
etk::CCout& etk::CCout::operator << (CHex t)
{
hex = true;
return *this;
}
etk::CCout& etk::CCout::operator << (int t) etk::CCout& etk::CCout::operator << (int t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%d", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%d", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this; return *this;
} }
@ -104,7 +151,6 @@ etk::CCout& etk::CCout::operator << (const etk::UniChar& t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%u", t.Get()); snprintf(tmp, MAX_LOG_SIZE_TMP, "%u", t.Get());
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this; return *this;
} }
@ -112,35 +158,22 @@ etk::CCout& etk::CCout::operator << (unsigned int t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%u", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%u", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (long t) etk::CCout& etk::CCout::operator << (long t)
{ {
if (true == hex) { snprintf(tmp, MAX_LOG_SIZE_TMP, "%ld", t);
snprintf(tmp, MAX_LOG_SIZE_TMP, "0x%08X", (unsigned int)t); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
} else {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%ld", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
}
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (long long t) etk::CCout& etk::CCout::operator << (long long t)
{ {
if (true == hex) { snprintf(tmp, MAX_LOG_SIZE_TMP, "%lld", t);
snprintf(tmp, MAX_LOG_SIZE_TMP, "0x%08X%08X", (unsigned int)(t>>32), (unsigned int)(t)); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
} else {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%lld", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
}
return *this; return *this;
} }
@ -149,7 +182,6 @@ etk::CCout& etk::CCout::operator << (double t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%f", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%f", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this; return *this;
} }
@ -158,7 +190,6 @@ etk::CCout& etk::CCout::operator << (float t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%f", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%f", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this; return *this;
} }
@ -167,7 +198,6 @@ etk::CCout& etk::CCout::operator << (char * t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%s", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%s", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this; return *this;
} }
@ -176,7 +206,6 @@ etk::CCout& etk::CCout::operator << (const char * t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%s", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%s", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this; return *this;
} }
@ -185,7 +214,6 @@ etk::CCout& etk::CCout::operator << (char t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%c", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%c", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this; return *this;
} }
@ -214,7 +242,7 @@ etk::CCout& etk::CCout::operator << (etk::CEndl t)
strncat(m_tmpChar, "\n", MAX_LOG_SIZE); strncat(m_tmpChar, "\n", MAX_LOG_SIZE);
m_tmpChar[MAX_LOG_SIZE] = '\0'; m_tmpChar[MAX_LOG_SIZE] = '\0';
#if defined(__TARGET_OS__Android) #if defined(__TARGET_OS__Android)
LOGI("%s", m_tmpChar); __android_log_print(m_levelAndroid, "EWOL", "%s", m_tmpChar);
#else #else
printf("%s", m_tmpChar); printf("%s", m_tmpChar);
#endif #endif

9
etk/Stream.h
View File

@ -18,19 +18,19 @@ namespace etk
#define MAX_LOG_SIZE_TMP (512) #define MAX_LOG_SIZE_TMP (512)
class CEndl{}; class CEndl{};
class CHex{};
class CStart{}; class CStart{};
class CCout{ class CCout{
private: private:
bool hex;
char m_tmpChar[MAX_LOG_SIZE+1]; char m_tmpChar[MAX_LOG_SIZE+1];
char tmp[MAX_LOG_SIZE_TMP]; char tmp[MAX_LOG_SIZE_TMP];
#if defined(__TARGET_OS__Android)
int8_t m_levelAndroid; //!< specific level for Android
#endif
etk::Mutex m_mutex; etk::Mutex m_mutex;
public: public:
CCout(void); CCout(void);
~CCout(void); ~CCout(void);
CCout& operator << (CHex t);
CCout& operator << (const etk::UniChar& t);; CCout& operator << (const etk::UniChar& t);;
CCout& operator << (int t); CCout& operator << (int t);
CCout& operator << (unsigned int t); CCout& operator << (unsigned int t);
@ -47,7 +47,6 @@ namespace etk
}; };
extern etk::CCout cout; extern etk::CCout cout;
extern etk::CEndl endl; extern etk::CEndl endl;
extern etk::CHex hex;
extern etk::CStart cstart; extern etk::CStart cstart;
typedef enum { typedef enum {
@ -64,6 +63,8 @@ namespace etk
* @brief Debug operator To display the curent element in a Human redeable information * @brief Debug operator To display the curent element in a Human redeable information
*/ */
etk::CCout& operator <<(etk::CCout &os, const etk::logLevel_te obj); etk::CCout& operator <<(etk::CCout &os, const etk::logLevel_te obj);
void DisplayBacktrace(void);
}; };
//regular colors //regular colors

132
etk/UString.cpp
View File

@ -139,9 +139,14 @@ void etk::UString::Set(const int64_t& _inputData, etk::UString::printMode_te _mo
Set((uint64_t)_inputData, _mode, _preset); Set((uint64_t)_inputData, _mode, _preset);
return; return;
} }
int64_t tmpData = _inputData * (int64_t)(-1); uint64_t tmpData;
if (_inputData < 0) { if (_inputData < 0) {
if (_mode != etk::UString::printModeString) { tmpData = (uint64_t)((int64_t)_inputData * (int64_t)(-1));
} else {
tmpData = _inputData;
}
if (_inputData < 0) {
if (_mode == etk::UString::printModeString) {
m_data.PushBack('l'); m_data.PushBack('l');
m_data.PushBack('e'); m_data.PushBack('e');
m_data.PushBack('s'); m_data.PushBack('s');
@ -177,84 +182,49 @@ void etk::UString::Set(const uint64_t& _inputData, etk::UString::printMode_te _m
break; break;
} }
} }
bool startDisplay=false; if (_mode == etk::UString::printModeString) {
switch(_mode) { m_data.PushBack('T');
case etk::UString::printModeBinary : m_data.PushBack('O');
for(int32_t iii=63; iii>=0; iii--) { m_data.PushBack('D');
if ((_inputData & (1<<iii)) != 0) { m_data.PushBack('O');
m_data.PushBack('1'); m_data.PushBack('.');
startDisplay = true; m_data.PushBack('.');
} else { m_data.PushBack('.');
if (true == startDisplay) { } else {
m_data.PushBack('0'); int32_t base=8;
} //char ploppp[256]="";
} switch(_mode) {
} case etk::UString::printModeBinary :
break; base=2;
case etk::UString::printModeOctal : break;
// special strt case ... case etk::UString::printModeOctal :
if ((_inputData & 0x80000000000000LL) != 0) { //sprintf(ploppp, "%llo", _inputData);
m_data.PushBack('1'); base=8;
startDisplay = true; break;
} else { default:
if (true == startDisplay) { case etk::UString::printModeDecimal :
m_data.PushBack('0'); //sprintf(ploppp, "%llu", _inputData);
} base=10;
} break;
for(int32_t iii=59; iii>=0; iii-=3) { case etk::UString::printModeHexadecimal :
uint64_t tmpVal = (_inputData & (((uint64_t)7)<<iii)) >> iii; //sprintf(ploppp, "%llx", _inputData);
base=16;
if (tmpVal != 0) { break;
startDisplay = true; }
} uint64_t tmpVal = _inputData;
if (true == startDisplay) { etk::UString tmpString;
tmpVal += '0'; while (tmpVal>0) {
m_data.PushBack(tmpVal); uint64_t quotient = tmpVal / base;
} uint64_t rest = tmpVal - quotient*base;
} tmpString.Add(0,(rest+'0'));
break; tmpVal = quotient;
case etk::UString::printModeDecimal : }
{ if (tmpString.Size() == 0) {
uint64_t tmpVal = _inputData; m_data.PushBack('0');
etk::UString tmpString; } else {
while (tmpVal>0) { *this += tmpString;
int32_t val = tmpVal % 10; }
tmpString.Add(0,(val+'0')); //TK_ERROR (" " << ploppp);
tmpVal /= 10;
}
if (tmpString.Size() == 0) {
m_data.PushBack('0');
} else {
*this += tmpString;
}
}
break;
case etk::UString::printModeHexadecimal :
for(int32_t iii=59; iii>=0; iii-=4) {
uint64_t tmpVal = (_inputData & (((uint64_t)0xF)<<iii)) >> iii;
if (tmpVal != 0) {
startDisplay = true;
}
if (true == startDisplay) {
if (tmpVal < 10) {
tmpVal += '0';
} else {
tmpVal += 'A'-10;
}
m_data.PushBack(tmpVal);
}
}
break;
default:
case etk::UString::printModeString :
m_data.PushBack('T');
m_data.PushBack('O');
m_data.PushBack('D');
m_data.PushBack('O');
m_data.PushBack('.');
m_data.PushBack('.');
m_data.PushBack('.');
break;
} }
m_data.PushBack('\0'); m_data.PushBack('\0');
} }
@ -708,7 +678,7 @@ bool etk::UString::EndWith(const etk::UString& _data, bool _caseSensitive) const
for( int32_t iii=Size()-1, jjj=_data.Size()-1; for( int32_t iii=Size()-1, jjj=_data.Size()-1;
iii>=0 && jjj>=0; iii>=0 && jjj>=0;
iii--, jjj--) { iii--, jjj--) {
if (false==m_data[iii].CompareNoCase(_data[iii])) { if (false==m_data[iii].CompareNoCase(_data[jjj])) {
return false; return false;
} }
} }

32
etk/UniChar.h
View File

@ -11,6 +11,35 @@
namespace etk namespace etk
{ {
//in the unicode section we have : [E000..F8FF] private area ==> we will store element in this area:
// internal define to permit to have all needed system
typedef enum {
REGEXP_OPCODE_PTHESE_IN=0xE000, /* ( */
REGEXP_OPCODE_PTHESE_OUT,/* ) */
REGEXP_OPCODE_BRACKET_IN,/* [ */
REGEXP_OPCODE_BRACKET_OUT,/* ] */
REGEXP_OPCODE_BRACE_IN,/* { */
REGEXP_OPCODE_BRACE_OUT,/* } */
REGEXP_OPCODE_TO,/* - */
REGEXP_OPCODE_STAR,/* * */
REGEXP_OPCODE_DOT,/* . */
REGEXP_OPCODE_QUESTION,/* ? */
REGEXP_OPCODE_PLUS,/* + */
REGEXP_OPCODE_PIPE,/* | */
REGEXP_OPCODE_START_OF_LINE,/* ^ this is also NOT, but not manage */
REGEXP_OPCODE_END_OF_LINE,/* $ */
REGEXP_OPCODE_DIGIT,/* \d */
REGEXP_OPCODE_DIGIT_NOT,/* \D */
REGEXP_OPCODE_LETTER,/* \l */
REGEXP_OPCODE_LETTER_NOT,/* \L */
REGEXP_OPCODE_SPACE,/* \s */
REGEXP_OPCODE_SPACE_NOT,/* \S */
REGEXP_OPCODE_WORD,/* \w */
REGEXP_OPCODE_WORD_NOT,/* \W */
REGEXP_OPCODE_NO_CHAR,/* \@ */
} regExpPrivateSection_te;
class UniChar class UniChar
{ {
private: private:
@ -24,6 +53,9 @@ namespace etk
UniChar(const char _obj) : UniChar(const char _obj) :
m_value((uint32_t)_obj) m_value((uint32_t)_obj)
{ }; { };
UniChar(const regExpPrivateSection_te _obj) :
m_value((uint32_t)_obj)
{ };
~UniChar(void) {} ~UniChar(void) {}
/***************************************************** /*****************************************************

2
etk/math/Vector2D.cpp
View File

@ -85,7 +85,7 @@ namespace etk
tmpStr.Remove(0,posComa+1); tmpStr.Remove(0,posComa+1);
m_floats[1] = tmpStr.ToBool(); m_floats[1] = tmpStr.ToBool();
} }
TK_VERBOSE("Parse : \"" << _str << "\" ==> " << *this); TK_DEBUG("Parse : \"" << _str << "\" ==> " << *this);
} }
template<> Vector2D<int32_t>::operator etk::UString(void) const template<> Vector2D<int32_t>::operator etk::UString(void) const

2
lutin_etk.py
View File

@ -56,6 +56,8 @@ def Create(target):
else: else:
myModule.AddExportFlag_CC("-DDEBUG_LEVEL=3") myModule.AddExportFlag_CC("-DDEBUG_LEVEL=3")
myModule.AddExportFlag_CC("-DDEBUG=1") myModule.AddExportFlag_CC("-DDEBUG=1")
# Bor backtrace display :
myModule.AddExportflag_LD("-ldl -rdynamic")
if target.name=="Windows": if target.name=="Windows":
None None