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)
#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
# 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) ;
void etk::DisplayData(etk::Vector<char> &data)
void etk::DisplayElem(const etk::Vector<etk::UniChar>& _data, int32_t _start, int32_t _stop)
{
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;
for (i=start; i<(int32_t)data.Size() && i<stop ; i++) {
switch(data[i])
for (int32_t iii=_start; iii<_data.Size() && iii<_stop ; iii++) {
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_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 '\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;
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 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;
}
int32_t pos = startPos;
int32_t pos = _startPos;
int32_t nbOpen = 0;
// special case of the (...) or | ==> we search '|' or ')'
if( REGEXP_OPCODE_PTHESE_OUT == data[pos]
|| REGEXP_OPCODE_PIPE == data[pos]) {
if( _data[pos] == REGEXP_OPCODE_PTHESE_OUT
|| _data[pos] == REGEXP_OPCODE_PIPE) {
return 0;
}
// find size ...
while (pos < (int32_t)data.Size() ) {
if(REGEXP_OPCODE_PTHESE_IN == data[pos]) {
while (pos < (int32_t)_data.Size() ) {
if(_data[pos] == REGEXP_OPCODE_PTHESE_IN) {
// find a sub section :
nbOpen++;
} else if(0 < nbOpen) {
if (REGEXP_OPCODE_PTHESE_OUT == data[pos])
{
if (_data[pos] == REGEXP_OPCODE_PTHESE_OUT) {
nbOpen--;
if (0 > nbOpen) {
TK_ERROR("Error in the (...) find element at "<< pos);
return -1;
}
}
} else if( REGEXP_OPCODE_PTHESE_OUT == data[pos]
|| REGEXP_OPCODE_PIPE == data[pos])
{
} else if( _data[pos] == REGEXP_OPCODE_PTHESE_OUT
|| _data[pos] == REGEXP_OPCODE_PIPE) {
// Find the end of the (...)
// just return the size inside
int32_t sizeInside = pos - startPos;
int32_t sizeInside = pos - _startPos;
if (0 >= sizeInside) {
TK_ERROR("Error in the (...) no data at "<< pos-1);
return -1;
} else {
return sizeInside;
return sizeInside;
}
}
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;
// special case of the (...) or | ==> we search '|' or ')'
if( REGEXP_OPCODE_PTHESE_OUT == data[pos]) {
if(_data[pos]==REGEXP_OPCODE_PTHESE_OUT) {
return 0;
} else if( REGEXP_OPCODE_PTHESE_IN == data[pos])
{
} else if(_data[pos]==REGEXP_OPCODE_PTHESE_IN) {
pos++;
// find size ...
while (pos < (int32_t)data.Size() ) {
if(REGEXP_OPCODE_PTHESE_IN == data[pos]) {
while (pos < _data.Size() ) {
if(_data[pos]==REGEXP_OPCODE_PTHESE_IN) {
// find a sub section :
nbOpen++;
} else if(0 < nbOpen) {
if (REGEXP_OPCODE_PTHESE_OUT == data[pos])
{
if (_data[pos]==REGEXP_OPCODE_PTHESE_OUT) {
nbOpen--;
if (0 > nbOpen) {
TK_ERROR("Error in the (...) find element at "<< pos);
return -1;
}
}
} else if( REGEXP_OPCODE_PTHESE_OUT == data[pos])
{
} else if(_data[pos]==REGEXP_OPCODE_PTHESE_OUT) {
// Find the end of the (...)
// just return the size inside
int32_t sizeInside = pos - startPos-1;
int32_t sizeInside = pos - _startPos-1;
if (0 >= sizeInside) {
TK_ERROR("Error in the (...) no data at "<< pos-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 ')'
if( REGEXP_OPCODE_BRACKET_OUT == data[pos]) {
if(_data[pos]==REGEXP_OPCODE_BRACKET_OUT) {
return 0;
} else if( REGEXP_OPCODE_BRACKET_IN == data[pos]) {
} else if(_data[pos] == REGEXP_OPCODE_BRACKET_IN) {
pos++;
// find size ...
while (pos < (int32_t)data.Size() ) {
if(REGEXP_OPCODE_BRACKET_OUT == data[pos]) {
while (pos < _data.Size() ) {
if(_data[pos]==REGEXP_OPCODE_BRACKET_OUT) {
// Find the end of the [...]
// just return the size inside
int32_t sizeInside = pos - startPos -1 ;
int32_t sizeInside = pos - _startPos -1 ;
if (0 >= sizeInside) {
TK_ERROR("Error in the [...] no data at "<< pos-1);
return sizeInside;
} else {
return sizeInside;
}
} else if( REGEXP_OPCODE_TO != data[pos]
&& ( 0 > data[pos]
|| 0xFF < data[pos]) )
{
TK_ERROR("Error in the [...] not permited element at "<< pos << " '" << (char)data[pos] << "'");
} else if( _data[pos] != REGEXP_OPCODE_TO
&& _data[pos] > 0xFF ) {
TK_ERROR("Error in the [...] not permited element at "<< pos << " '" << (char)_data[pos].Get() << "'");
return false;
}
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 ')'
if( REGEXP_OPCODE_BRACE_OUT == data[pos]) {
if(_data[pos]==REGEXP_OPCODE_BRACE_OUT) {
return 0;
} else if( REGEXP_OPCODE_BRACE_IN == data[pos]) {
} else if(_data[pos]==REGEXP_OPCODE_BRACE_IN) {
pos++;
// find size ...
while (pos < (int32_t)data.Size() ) {
if(REGEXP_OPCODE_BRACE_OUT == data[pos]) {
while (pos < _data.Size() ) {
if(_data[pos]==REGEXP_OPCODE_BRACE_OUT) {
// Find the end of the [...]
// just return the size inside
int32_t sizeInside = pos - startPos -1 ;
int32_t sizeInside = pos - _startPos -1 ;
if (0 >= sizeInside) {
TK_ERROR("Error in the {...} no data at "<< pos-1);
return sizeInside;
} else {
return sizeInside;
}
} else if( ',' != data[pos]
&& ( '0' > data[pos]
|| '9' < data[pos]) )
{
TK_ERROR("Error in the {...} not permited element at "<< pos << " '" << (char)data[pos] << "'");
} else if( _data[pos] != ','
&& ( _data[pos] < '0'
|| _data[pos] > '9') ) {
TK_ERROR("Error in the {...} not permited element at "<< pos << " '" << _data[pos].Get() << "'");
return false;
}
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 ...
while (pos < (int32_t)data.Size() ) {
switch(data[pos])
while (pos < _data.Size() ) {
switch(_data[pos].Get())
{
case REGEXP_OPCODE_PTHESE_IN:
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:
{
// just return the size inside
int32_t sizeInside = pos - startPos;
int32_t sizeInside = pos - _startPos;
if (0 >= sizeInside) {
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++;
}
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); );
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 SecondElement = 0;
while(k<data.Size()) {
if (',' == (char)data[k]) {
while(k<_data.Size()) {
if (_data[k]==',') {
k++;
break;
} if ('}' == (char)data[k]) {
} if (_data[k]=='}') {
SecondElement = firstElement;
goto allIsSet;
} else if ('0' <= (char)data[k] && '9' >= (char)data[k]) {
} else if(true==_data[k].IsInteger()) {
firstElement *=10;
firstElement += (char)data[k] - '0';
firstElement += _data[k].ToInt32();
} 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;
}
k++;
}
if (k==data.Size()) {
if (k==_data.Size()) {
SecondElement = firstElement;
}
while(k<data.Size()) {
if (',' == (char)data[k]) {
while(k<_data.Size()) {
if (_data[k]==',') {
TK_ERROR("Can not find a second , in {} at pos " << k);
return false;
} if ('}' == (char)data[k]) {
} if (_data[k]=='}') {
goto allIsSet;
} else if ('0' <= (char)data[k] && '9' >= (char)data[k]) {
} else if (true==_data[k].IsInteger()) {
SecondElement *=10;
SecondElement += (char)data[k] - '0';
SecondElement += _data[k].ToInt32();
} 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;
}
k++;
@ -390,14 +372,14 @@ bool etk::ParseBrace(etk::Vector<int16_t> &data, int32_t &min, int32_t &max)
allIsSet:
if (SecondElement == 0 && firstElement != 0) {
min = 0;
max = firstElement;
_min = 0;
_max = firstElement;
} else {
min = firstElement;
max = SecondElement;
_min = firstElement;
_max = SecondElement;
}
if (min > max) {
TK_ERROR("Minimum=" << min << " can not be < maximum=" << max );
if (_min > _max) {
TK_ERROR("Minimum=" << _min << " can not be < maximum=" << _max );
return false;
}
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/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::CEndl etk::endl;
etk::CHex etk::hex;
etk::CStart etk::cstart;
#if defined(__TARGET_OS__Android)
# 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
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)
os << ETK_BASH_COLOR_BOLD_RED;
#endif
#if defined(__TARGET_OS__Android)
m_levelAndroid = ANDROID_LOG_FATAL;
#endif
os << "[C]";
break;
case LOG_LEVEL_ERROR:
#if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_RED;
#endif
#if defined(__TARGET_OS__Android)
m_levelAndroid = ANDROID_LOG_ERROR;
#endif
os << "[E]";
break;
case LOG_LEVEL_WARNING:
#if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_MAGENTA;
#endif
#if defined(__TARGET_OS__Android)
m_levelAndroid = ANDROID_LOG_WARN;
#endif
os << "[W]";
break;
case LOG_LEVEL_INFO:
#if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_CYAN;
#endif
#if defined(__TARGET_OS__Android)
m_levelAndroid = ANDROID_LOG_INFO;
#endif
os << "[I]";
break;
case LOG_LEVEL_DEBUG:
#if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_YELLOW;
#endif
#if defined(__TARGET_OS__Android)
m_levelAndroid = ANDROID_LOG_DEBUG;
#endif
os << "[D]";
break;
case LOG_LEVEL_VERBOSE:
#if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_WHITE;
#endif
#if defined(__TARGET_OS__Android)
m_levelAndroid = ANDROID_LOG_VERBOSE;
#endif
os << "[V]";
break;
default:
@ -73,7 +126,9 @@ etk::CCout& etk::operator <<(etk::CCout &os, const etk::logLevel_te obj)
etk::CCout::CCout()
{
hex=false;
#if defined(__TARGET_OS__Android)
m_levelAndroid = 0;
#endif
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)
{
snprintf(tmp, MAX_LOG_SIZE_TMP, "%d", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this;
}
@ -104,7 +151,6 @@ etk::CCout& etk::CCout::operator << (const etk::UniChar& t)
{
snprintf(tmp, MAX_LOG_SIZE_TMP, "%u", t.Get());
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this;
}
@ -112,35 +158,22 @@ etk::CCout& etk::CCout::operator << (unsigned int t)
{
snprintf(tmp, MAX_LOG_SIZE_TMP, "%u", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this;
}
etk::CCout& etk::CCout::operator << (long t)
{
if (true == hex) {
snprintf(tmp, MAX_LOG_SIZE_TMP, "0x%08X", (unsigned int)t);
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);
}
snprintf(tmp, MAX_LOG_SIZE_TMP, "%ld", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this;
}
etk::CCout& etk::CCout::operator << (long long t)
{
if (true == hex) {
snprintf(tmp, MAX_LOG_SIZE_TMP, "0x%08X%08X", (unsigned int)(t>>32), (unsigned int)(t));
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);
}
snprintf(tmp, MAX_LOG_SIZE_TMP, "%lld", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this;
}
@ -149,7 +182,6 @@ etk::CCout& etk::CCout::operator << (double t)
{
snprintf(tmp, MAX_LOG_SIZE_TMP, "%f", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this;
}
@ -158,7 +190,6 @@ etk::CCout& etk::CCout::operator << (float t)
{
snprintf(tmp, MAX_LOG_SIZE_TMP, "%f", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this;
}
@ -167,7 +198,6 @@ etk::CCout& etk::CCout::operator << (char * t)
{
snprintf(tmp, MAX_LOG_SIZE_TMP, "%s", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this;
}
@ -176,7 +206,6 @@ etk::CCout& etk::CCout::operator << (const char * t)
{
snprintf(tmp, MAX_LOG_SIZE_TMP, "%s", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this;
}
@ -185,7 +214,6 @@ etk::CCout& etk::CCout::operator << (char t)
{
snprintf(tmp, MAX_LOG_SIZE_TMP, "%c", t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
hex = false;
return *this;
}
@ -214,7 +242,7 @@ etk::CCout& etk::CCout::operator << (etk::CEndl t)
strncat(m_tmpChar, "\n", MAX_LOG_SIZE);
m_tmpChar[MAX_LOG_SIZE] = '\0';
#if defined(__TARGET_OS__Android)
LOGI("%s", m_tmpChar);
__android_log_print(m_levelAndroid, "EWOL", "%s", m_tmpChar);
#else
printf("%s", m_tmpChar);
#endif

9
etk/Stream.h
View File

@ -18,19 +18,19 @@ namespace etk
#define MAX_LOG_SIZE_TMP (512)
class CEndl{};
class CHex{};
class CStart{};
class CCout{
private:
bool hex;
char m_tmpChar[MAX_LOG_SIZE+1];
char tmp[MAX_LOG_SIZE_TMP];
#if defined(__TARGET_OS__Android)
int8_t m_levelAndroid; //!< specific level for Android
#endif
etk::Mutex m_mutex;
public:
CCout(void);
~CCout(void);
CCout& operator << (CHex t);
CCout& operator << (const etk::UniChar& t);;
CCout& operator << (int t);
CCout& operator << (unsigned int t);
@ -47,7 +47,6 @@ namespace etk
};
extern etk::CCout cout;
extern etk::CEndl endl;
extern etk::CHex hex;
extern etk::CStart cstart;
typedef enum {
@ -64,6 +63,8 @@ namespace etk
* @brief Debug operator To display the curent element in a Human redeable information
*/
etk::CCout& operator <<(etk::CCout &os, const etk::logLevel_te obj);
void DisplayBacktrace(void);
};
//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);
return;
}
int64_t tmpData = _inputData * (int64_t)(-1);
uint64_t tmpData;
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('e');
m_data.PushBack('s');
@ -177,84 +182,49 @@ void etk::UString::Set(const uint64_t& _inputData, etk::UString::printMode_te _m
break;
}
}
bool startDisplay=false;
switch(_mode) {
case etk::UString::printModeBinary :
for(int32_t iii=63; iii>=0; iii--) {
if ((_inputData & (1<<iii)) != 0) {
m_data.PushBack('1');
startDisplay = true;
} else {
if (true == startDisplay) {
m_data.PushBack('0');
}
}
}
break;
case etk::UString::printModeOctal :
// special strt case ...
if ((_inputData & 0x80000000000000LL) != 0) {
m_data.PushBack('1');
startDisplay = true;
} else {
if (true == startDisplay) {
m_data.PushBack('0');
}
}
for(int32_t iii=59; iii>=0; iii-=3) {
uint64_t tmpVal = (_inputData & (((uint64_t)7)<<iii)) >> iii;
if (tmpVal != 0) {
startDisplay = true;
}
if (true == startDisplay) {
tmpVal += '0';
m_data.PushBack(tmpVal);
}
}
break;
case etk::UString::printModeDecimal :
{
uint64_t tmpVal = _inputData;
etk::UString tmpString;
while (tmpVal>0) {
int32_t val = tmpVal % 10;
tmpString.Add(0,(val+'0'));
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;
if (_mode == 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('.');
} else {
int32_t base=8;
//char ploppp[256]="";
switch(_mode) {
case etk::UString::printModeBinary :
base=2;
break;
case etk::UString::printModeOctal :
//sprintf(ploppp, "%llo", _inputData);
base=8;
break;
default:
case etk::UString::printModeDecimal :
//sprintf(ploppp, "%llu", _inputData);
base=10;
break;
case etk::UString::printModeHexadecimal :
//sprintf(ploppp, "%llx", _inputData);
base=16;
break;
}
uint64_t tmpVal = _inputData;
etk::UString tmpString;
while (tmpVal>0) {
uint64_t quotient = tmpVal / base;
uint64_t rest = tmpVal - quotient*base;
tmpString.Add(0,(rest+'0'));
tmpVal = quotient;
}
if (tmpString.Size() == 0) {
m_data.PushBack('0');
} else {
*this += tmpString;
}
//TK_ERROR (" " << ploppp);
}
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;
iii>=0 && jjj>=0;
iii--, jjj--) {
if (false==m_data[iii].CompareNoCase(_data[iii])) {
if (false==m_data[iii].CompareNoCase(_data[jjj])) {
return false;
}
}

32
etk/UniChar.h
View File

@ -11,6 +11,35 @@
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
{
private:
@ -24,6 +53,9 @@ namespace etk
UniChar(const char _obj) :
m_value((uint32_t)_obj)
{ };
UniChar(const regExpPrivateSection_te _obj) :
m_value((uint32_t)_obj)
{ };
~UniChar(void) {}
/*****************************************************

2
etk/math/Vector2D.cpp
View File

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

2
lutin_etk.py
View File

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