HeeroYui/edn
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Mise en place des RegExp en Template ==> OK

Browse Source
This commit is contained in:
Edouard Dupin 2011-07-29 10:44:12 +02:00
parent f9418d665e
commit 45aad6b2e2
4 changed files with 149 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Sources/Highlight/Highlight.h
View File

@ -61,11 +61,11 @@ class Highlight {
void Parse2(int32_t start, int32_t stop, std::vector<colorInformation_ts> &metaData, EdnVectorBuf &buffer, int32_t elementID=0); void Parse2(int32_t start, int32_t stop, std::vector<colorInformation_ts> &metaData, EdnVectorBuf &buffer, int32_t elementID=0);
private: private:
void ParseRules(TiXmlNode *child, std::vector<HighlightPattern*> &mListPatern, int32_t level); void ParseRules(TiXmlNode *child, std::vector<HighlightPattern*> &mListPatern, int32_t level);
Edn::String m_styleName; //!< curent style name (like "c++" or "c" or "script Bash") Edn::String m_styleName; //!< curent style name (like "c++" or "c" or "script Bash")
std::vector<Edn::String> m_listExtentions; //!< List of possible extention for this high-light, like : ".c", ".cpp", ".h" std::vector<Edn::String> m_listExtentions; //!< List of possible extention for this high-light, like : ".c", ".cpp", ".h"
std::vector<HighlightPattern*> m_listHighlightPass1; //!< List of ALL hightlight modules (pass 1 ==> when we load and wride data on the buffer) std::vector<HighlightPattern*> m_listHighlightPass1; //!< List of ALL hightlight modules (pass 1 ==> when we load and wride data on the buffer)
std::vector<HighlightPattern*> m_listHighlightPass2; //!< List of ALL hightlight modules (pass 2 ==> When we display the buffer( only the display area (100 lines)) ) std::vector<HighlightPattern*> m_listHighlightPass2; //!< List of ALL hightlight modules (pass 2 ==> When we display the buffer( only the display area (100 lines)) )
}; };

4
Sources/Highlight/HighlightPattern.cpp
View File

@ -39,8 +39,8 @@ HighlightPattern::HighlightPattern(void)
m_multiline = false; m_multiline = false;
ColorizeManager *myColorManager = ColorizeManager::getInstance(); ColorizeManager *myColorManager = ColorizeManager::getInstance();
m_color = myColorManager->Get("normal"); m_color = myColorManager->Get("normal");
m_regExpStart = new EdnRegExp(); m_regExpStart = new EdnRegExp<EdnVectorBuf>();
m_regExpStop = new EdnRegExp(); m_regExpStop = new EdnRegExp<EdnVectorBuf>();
m_escapeChar = 0; m_escapeChar = 0;
} }

27
Sources/Highlight/HighlightPattern.h
View File

@ -22,7 +22,9 @@
* *
******************************************************************************* *******************************************************************************
*/ */
#include "Highlight.h"
#ifndef __HIGHLIGHT_PATTERN_H__ #ifndef __HIGHLIGHT_PATTERN_H__
#define __HIGHLIGHT_PATTERN_H__ #define __HIGHLIGHT_PATTERN_H__
@ -33,6 +35,7 @@ class HighlightPattern;
#include "Colorize.h" #include "Colorize.h"
#include "EdnVectorBin.h" #include "EdnVectorBin.h"
#include "tinyxml.h" #include "tinyxml.h"
#include "EdnVectorBuf.h"
typedef enum { typedef enum {
HLP_FIND_ERROR, HLP_FIND_ERROR,
@ -67,17 +70,17 @@ class HighlightPattern {
void ParseRules(TiXmlNode *child, int32_t level); void ParseRules(TiXmlNode *child, int32_t level);
private: private:
int32_t m_level; //!< Level of the pattern ==> this is to overwrite next pattern when we create an higher .... int32_t m_level; //!< Level of the pattern ==> this is to overwrite next pattern when we create an higher ....
Edn::String m_paternName; //!< Current style name (like "c++" or "c" or "script Bash") Edn::String m_paternName; //!< Current style name (like "c++" or "c" or "script Bash")
Edn::String m_colorName; //!< Current color name Edn::String m_colorName; //!< Current color name
Colorize * m_color; //!< Link to the color manager Colorize * m_color; //!< Link to the color manager
EdnRegExp * m_regExpStart; //!< Start of Regular expression EdnRegExp<EdnVectorBuf> * m_regExpStart; //!< Start of Regular expression
EdnRegExp * m_regExpStop; //!< Stop of Regular Expression EdnRegExp<EdnVectorBuf> * m_regExpStop; //!< Stop of Regular Expression
bool m_haveStopPatern; //!< Stop patern presence bool m_haveStopPatern; //!< Stop patern presence
bool m_multiline; //!< The patern is multiline bool m_multiline; //!< The patern is multiline
char m_escapeChar; //!< Escape char to prevent exeit of patern .... char m_escapeChar; //!< Escape char to prevent exeit of patern ....
EdnVectorBin<HighlightPattern *> m_subPatern; //!< Under patern of this one EdnVectorBin<HighlightPattern *> m_subPatern; //!< Under patern of this one
// EdnVectorBin<HighlightPattern *> m_subColor; //!< Under Color in the start RegExp ... // EdnVectorBin<HighlightPattern *> m_subColor; //!< Under Color in the start RegExp ...
}; };
#endif #endif

251
Sources/tools/NameSpaceEdn/RegExp.h
View File

@ -26,6 +26,7 @@
#define __EDN_REG_EXP_H__ #define __EDN_REG_EXP_H__
#include "EdnVectorBin.h" #include "EdnVectorBin.h"
#include "Edn.h"
/* /*
normal mode : normal mode :
@ -85,7 +86,7 @@ typedef struct {
int16_t newValue; int16_t newValue;
}convertionTable_ts; }convertionTable_ts;
extern const convertionTable_ts constConvertionTable; extern const convertionTable_ts constConvertionTable[];
extern const int32_t constConvertionTableSize; extern const int32_t constConvertionTableSize;
void DisplayData(EdnVectorBin<char> &data); void DisplayData(EdnVectorBin<char> &data);
@ -229,11 +230,11 @@ template<class CLASS_TYPE> class RegExpNodeValue : public RegExpNode<CLASS_TYPE>
*/ */
int32_t Generate(EdnVectorBin<int16_t> &data) int32_t Generate(EdnVectorBin<int16_t> &data)
{ {
m_RegExpData = data; RegExpNode<CLASS_TYPE>::m_RegExpData = data;
//EDN_DEBUG("Request Parse \"Value\" data="; DisplayElem(m_RegExpData);); //EDN_DEBUG("Request Parse \"Value\" data="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
m_data.Clear(); m_data.Clear();
for (int32_t i=0; i<m_RegExpData.Size(); i++) { for (int32_t i=0; i<RegExpNode<CLASS_TYPE>::m_RegExpData.Size(); i++) {
m_data.PushBack((char)m_RegExpData[i]); m_data.PushBack((char)RegExpNode<CLASS_TYPE>::m_RegExpData[i]);
} }
return data.Size(); return data.Size();
}; };
@ -246,7 +247,7 @@ template<class CLASS_TYPE> class RegExpNodeValue : public RegExpNode<CLASS_TYPE>
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
//EDN_INFO("Parse node : Value{" << m_multipleMin << "," << m_multipleMax << "}"); //EDN_INFO("Parse node : Value{" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
if (0==m_data.Size()) { if (0==m_data.Size()) {
EDN_ERROR("No data inside type elemTypeValue"); EDN_ERROR("No data inside type elemTypeValue");
return false; return false;
@ -254,7 +255,7 @@ template<class CLASS_TYPE> class RegExpNodeValue : public RegExpNode<CLASS_TYPE>
//EDN_DEBUG("check element value : '" << m_data[0] << "'"); //EDN_DEBUG("check element value : '" << m_data[0] << "'");
bool tmpFind = true; bool tmpFind = true;
int32_t j; int32_t j;
for (j=0; j<m_multipleMax && tmpFind == true; j++) { for (j=0; j<RegExpNode<CLASS_TYPE>::m_multipleMax && tmpFind == true; j++) {
int32_t ofset = 0; int32_t ofset = 0;
int32_t k; int32_t k;
for (k=0; findLen+k<lenMax && k < m_data.Size(); k++) { for (k=0; findLen+k<lenMax && k < m_data.Size(); k++) {
@ -273,13 +274,13 @@ template<class CLASS_TYPE> class RegExpNodeValue : public RegExpNode<CLASS_TYPE>
findLen += ofset; findLen += ofset;
} }
} }
if( j>=m_multipleMin if( j>=RegExpNode<CLASS_TYPE>::m_multipleMin
&& j<=m_multipleMax && j<=RegExpNode<CLASS_TYPE>::m_multipleMax
&& findLen>0 ) && findLen>0 )
{ {
//EDN_DEBUG("find " << findLen); //EDN_DEBUG("find " << findLen);
return true; return true;
} else if( 0 == m_multipleMin ) { } else if( 0 == RegExpNode<CLASS_TYPE>::m_multipleMin ) {
//EDN_DEBUG("find size=0"); //EDN_DEBUG("find size=0");
return true; return true;
} }
@ -293,7 +294,7 @@ template<class CLASS_TYPE> class RegExpNodeValue : public RegExpNode<CLASS_TYPE>
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@Value@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData); std::cout<< " data: "; DisplayData(m_data); ); EDN_INFO("Find NODE : " << levelSpace(level) << "@Value@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData); std::cout<< " data: "; DisplayData(m_data); );
}; };
protected : protected :
// SubNodes : // SubNodes :
@ -332,27 +333,27 @@ template<class CLASS_TYPE> class RegExpNodeBracket : public RegExpNode<CLASS_TYP
*/ */
int32_t Generate(EdnVectorBin<int16_t> &data) int32_t Generate(EdnVectorBin<int16_t> &data)
{ {
m_RegExpData = data; RegExpNode<CLASS_TYPE>::m_RegExpData = data;
//EDN_DEBUG("Request Parse [...] data="; DisplayElem(m_RegExpData);); //EDN_DEBUG("Request Parse [...] data="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
m_data.Clear(); m_data.Clear();
char lastElement = 'a'; char lastElement = 'a';
bool multipleElement = false; bool multipleElement = false;
// //
for (int32_t k=0; k<m_RegExpData.Size(); k++) { for (int32_t k=0; k<RegExpNode<CLASS_TYPE>::m_RegExpData.Size(); k++) {
if (m_RegExpData[k] == OPCODE_TO && multipleElement == true) { if (RegExpNode<CLASS_TYPE>::m_RegExpData[k] == OPCODE_TO && multipleElement == true) {
EDN_ERROR("Can not have 2 consecutive - in [...]"); EDN_ERROR("Can not have 2 consecutive - in [...]");
return 0; return 0;
} else if (multipleElement == true) { } else if (multipleElement == true) {
char j='\0'; char j='\0';
for (j=lastElement+1; j <= (char)m_RegExpData[k]; j++) { for (j=lastElement+1; j <= (char)RegExpNode<CLASS_TYPE>::m_RegExpData[k]; j++) {
m_data.PushBack(j); m_data.PushBack(j);
} }
multipleElement = false; multipleElement = false;
} else if(m_RegExpData[k] == OPCODE_TO) { } else if(RegExpNode<CLASS_TYPE>::m_RegExpData[k] == OPCODE_TO) {
multipleElement = true; multipleElement = true;
} else { } else {
lastElement = (char)m_RegExpData[k]; lastElement = (char)RegExpNode<CLASS_TYPE>::m_RegExpData[k];
m_data.PushBack(lastElement); m_data.PushBack(lastElement);
} }
} }
@ -372,7 +373,7 @@ template<class CLASS_TYPE> class RegExpNodeBracket : public RegExpNode<CLASS_TYP
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
//EDN_INFO("Parse node : [...]{" << m_multipleMin << "," << m_multipleMax << "}"); //EDN_INFO("Parse node : [...]{" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
if (0==m_data.Size()) { if (0==m_data.Size()) {
EDN_ERROR("No data inside type elemTypeValue"); EDN_ERROR("No data inside type elemTypeValue");
return false; return false;
@ -380,7 +381,7 @@ template<class CLASS_TYPE> class RegExpNodeBracket : public RegExpNode<CLASS_TYP
//EDN_DEBUG("one of element value List : "; DisplayData(element->m_data);); //EDN_DEBUG("one of element value List : "; DisplayData(element->m_data););
bool tmpFind = true; bool tmpFind = true;
int32_t j; int32_t j;
for (j=0; j<m_multipleMax && tmpFind ==true && j < lenMax; j++) { for (j=0; j<RegExpNode<CLASS_TYPE>::m_multipleMax && tmpFind ==true && j < lenMax; j++) {
int32_t i; int32_t i;
tmpFind=false; tmpFind=false;
for (i=0; i<m_data.Size(); i++) { for (i=0; i<m_data.Size(); i++) {
@ -391,13 +392,13 @@ template<class CLASS_TYPE> class RegExpNodeBracket : public RegExpNode<CLASS_TYP
} }
} }
} }
if( j>=m_multipleMin if( j>=RegExpNode<CLASS_TYPE>::m_multipleMin
&& j<=m_multipleMax && j<=RegExpNode<CLASS_TYPE>::m_multipleMax
&& findLen>0 ) && findLen>0 )
{ {
//EDN_DEBUG("find " << findLen); //EDN_DEBUG("find " << findLen);
return true; return true;
} else if( 0 == m_multipleMin ) { } else if( 0 == RegExpNode<CLASS_TYPE>::m_multipleMin ) {
//EDN_DEBUG("find size=0"); //EDN_DEBUG("find size=0");
return true; return true;
} }
@ -411,7 +412,7 @@ template<class CLASS_TYPE> class RegExpNodeBracket : public RegExpNode<CLASS_TYP
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@[...]@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData); std::cout<< " data: "; DisplayData(m_data); ); EDN_INFO("Find NODE : " << levelSpace(level) << "@[...]@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData); std::cout<< " data: "; DisplayData(m_data); );
}; };
protected : protected :
// SubNodes : // SubNodes :
@ -450,10 +451,10 @@ template<class CLASS_TYPE> class RegExpNodeDigit : public RegExpNode<CLASS_TYPE>
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
//EDN_INFO("Parse node : Digit{" << m_multipleMin << "," << m_multipleMax << "} : "<< data[currentPos] << " lenMax=" << lenMax); //EDN_INFO("Parse node : Digit{" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} : "<< data[currentPos] << " lenMax=" << lenMax);
bool tmpFind = true; bool tmpFind = true;
int32_t j; int32_t j;
for (j=0; j<m_multipleMax && tmpFind ==true && j < lenMax; j++) { for (j=0; j<RegExpNode<CLASS_TYPE>::m_multipleMax && tmpFind ==true && j < lenMax; j++) {
char tmpVal = data[currentPos+j]; char tmpVal = data[currentPos+j];
//EDN_DEBUG("compare : " << tmpVal); //EDN_DEBUG("compare : " << tmpVal);
if( '0' <= tmpVal if( '0' <= tmpVal
@ -465,13 +466,13 @@ template<class CLASS_TYPE> class RegExpNodeDigit : public RegExpNode<CLASS_TYPE>
tmpFind=false; tmpFind=false;
} }
} }
if( j>=m_multipleMin if( j>=RegExpNode<CLASS_TYPE>::m_multipleMin
&& j<=m_multipleMax && j<=RegExpNode<CLASS_TYPE>::m_multipleMax
&& findLen>0 ) && findLen>0 )
{ {
//EDN_DEBUG("find " << findLen); //EDN_DEBUG("find " << findLen);
return true; return true;
} else if( 0 == m_multipleMin ) { } else if( 0 == RegExpNode<CLASS_TYPE>::m_multipleMin ) {
//EDN_DEBUG("find size=0"); //EDN_DEBUG("find size=0");
return true; return true;
} }
@ -485,7 +486,7 @@ template<class CLASS_TYPE> class RegExpNodeDigit : public RegExpNode<CLASS_TYPE>
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@Digit@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@Digit@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
}; };
}; };
#undef __class__ #undef __class__
@ -516,10 +517,10 @@ template<class CLASS_TYPE> class RegExpNodeDigitNot : public RegExpNode<CLASS_TY
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
//EDN_INFO("Parse node : DigitNot{" << m_multipleMin << "," << m_multipleMax << "}"); //EDN_INFO("Parse node : DigitNot{" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
bool tmpFind = true; bool tmpFind = true;
int32_t j; int32_t j;
for (j=0; j<m_multipleMax && tmpFind ==true && j < lenMax; j++) { for (j=0; j<RegExpNode<CLASS_TYPE>::m_multipleMax && tmpFind ==true && j < lenMax; j++) {
char tmpVal = data[currentPos+j]; char tmpVal = data[currentPos+j];
if( '0' > tmpVal if( '0' > tmpVal
|| '9' < tmpVal) || '9' < tmpVal)
@ -529,13 +530,13 @@ template<class CLASS_TYPE> class RegExpNodeDigitNot : public RegExpNode<CLASS_TY
tmpFind=false; tmpFind=false;
} }
} }
if( j>=m_multipleMin if( j>=RegExpNode<CLASS_TYPE>::m_multipleMin
&& j<=m_multipleMax && j<=RegExpNode<CLASS_TYPE>::m_multipleMax
&& findLen>0 ) && findLen>0 )
{ {
//EDN_DEBUG("find " << findLen); //EDN_DEBUG("find " << findLen);
return true; return true;
} else if( 0 == m_multipleMin ) { } else if( 0 == RegExpNode<CLASS_TYPE>::m_multipleMin ) {
//EDN_DEBUG("find size=0"); //EDN_DEBUG("find size=0");
return true; return true;
} }
@ -549,7 +550,7 @@ template<class CLASS_TYPE> class RegExpNodeDigitNot : public RegExpNode<CLASS_TY
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@DigitNot@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@DigitNot@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
}; };
}; };
#undef __class__ #undef __class__
@ -586,10 +587,10 @@ template<class CLASS_TYPE> class RegExpNodeLetter : public RegExpNode<CLASS_TYPE
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
//EDN_INFO("Parse node : Letter{" << m_multipleMin << "," << m_multipleMax << "}"); //EDN_INFO("Parse node : Letter{" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
bool tmpFind = true; bool tmpFind = true;
int32_t j; int32_t j;
for (j=0; j<m_multipleMax && tmpFind ==true && j < lenMax; j++) { for (j=0; j<RegExpNode<CLASS_TYPE>::m_multipleMax && tmpFind ==true && j < lenMax; j++) {
char tmpVal = data[currentPos+j]; char tmpVal = data[currentPos+j];
if( ( 'a' <= tmpVal if( ( 'a' <= tmpVal
&& 'z' >= tmpVal ) && 'z' >= tmpVal )
@ -601,13 +602,13 @@ template<class CLASS_TYPE> class RegExpNodeLetter : public RegExpNode<CLASS_TYPE
tmpFind=false; tmpFind=false;
} }
} }
if( j>=m_multipleMin if( j>=RegExpNode<CLASS_TYPE>::m_multipleMin
&& j<=m_multipleMax && j<=RegExpNode<CLASS_TYPE>::m_multipleMax
&& findLen>0 ) && findLen>0 )
{ {
//EDN_DEBUG("find " << findLen); //EDN_DEBUG("find " << findLen);
return true; return true;
} else if( 0 == m_multipleMin ) { } else if( 0 == RegExpNode<CLASS_TYPE>::m_multipleMin ) {
//EDN_DEBUG("find size=0"); //EDN_DEBUG("find size=0");
return true; return true;
} }
@ -621,7 +622,7 @@ template<class CLASS_TYPE> class RegExpNodeLetter : public RegExpNode<CLASS_TYPE
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@Letter@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@Letter@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
}; };
}; };
#undef __class__ #undef __class__
@ -658,10 +659,10 @@ template<class CLASS_TYPE> class RegExpNodeLetterNot : public RegExpNode<CLASS_T
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
//EDN_INFO("Parse node : LetterNot{" << m_multipleMin << "," << m_multipleMax << "}"); //EDN_INFO("Parse node : LetterNot{" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
bool tmpFind = true; bool tmpFind = true;
int32_t j; int32_t j;
for (j=0; j<m_multipleMax && tmpFind ==true && j < lenMax; j++) { for (j=0; j<RegExpNode<CLASS_TYPE>::m_multipleMax && tmpFind ==true && j < lenMax; j++) {
char tmpVal = data[currentPos+j]; char tmpVal = data[currentPos+j];
if( ( 'a' > tmpVal if( ( 'a' > tmpVal
&& 'Z' < tmpVal ) && 'Z' < tmpVal )
@ -673,13 +674,13 @@ template<class CLASS_TYPE> class RegExpNodeLetterNot : public RegExpNode<CLASS_T
tmpFind=false; tmpFind=false;
} }
} }
if( j>=m_multipleMin if( j>=RegExpNode<CLASS_TYPE>::m_multipleMin
&& j<=m_multipleMax && j<=RegExpNode<CLASS_TYPE>::m_multipleMax
&& findLen>0 ) && findLen>0 )
{ {
//EDN_DEBUG("find " << findLen); //EDN_DEBUG("find " << findLen);
return true; return true;
} else if( 0 == m_multipleMin ) { } else if( 0 == RegExpNode<CLASS_TYPE>::m_multipleMin ) {
//EDN_DEBUG("find size=0"); //EDN_DEBUG("find size=0");
return true; return true;
} }
@ -693,7 +694,7 @@ template<class CLASS_TYPE> class RegExpNodeLetterNot : public RegExpNode<CLASS_T
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@LetterNot@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@LetterNot@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
}; };
}; };
#undef __class__ #undef __class__
@ -733,7 +734,7 @@ template<class CLASS_TYPE> class RegExpNodeWhiteSpace : public RegExpNode<CLASS_
//EDN_INFO("Parse node : Space{" << m_multipleMin << "," << m_multipleMax << "}"); //EDN_INFO("Parse node : Space{" << m_multipleMin << "," << m_multipleMax << "}");
bool tmpFind = true; bool tmpFind = true;
int32_t j; int32_t j;
for (j=0; j<m_multipleMax && tmpFind ==true && j < lenMax; j++) { for (j=0; j<RegExpNode<CLASS_TYPE>::m_multipleMax && tmpFind ==true && j < lenMax; j++) {
char tmpVal = data[currentPos+j]; char tmpVal = data[currentPos+j];
if( ' ' == tmpVal if( ' ' == tmpVal
|| '\t' == tmpVal || '\t' == tmpVal
@ -747,13 +748,13 @@ template<class CLASS_TYPE> class RegExpNodeWhiteSpace : public RegExpNode<CLASS_
tmpFind=false; tmpFind=false;
} }
} }
if( j>=m_multipleMin if( j>=RegExpNode<CLASS_TYPE>::m_multipleMin
&& j<=m_multipleMax && j<=RegExpNode<CLASS_TYPE>::m_multipleMax
&& findLen>0 ) && findLen>0 )
{ {
//EDN_DEBUG("find " << findLen); //EDN_DEBUG("find " << findLen);
return true; return true;
} else if( 0 == m_multipleMin ) { } else if( 0 == RegExpNode<CLASS_TYPE>::m_multipleMin ) {
//EDN_DEBUG("find size=0"); //EDN_DEBUG("find size=0");
return true; return true;
} }
@ -767,7 +768,7 @@ template<class CLASS_TYPE> class RegExpNodeWhiteSpace : public RegExpNode<CLASS_
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@Space@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@Space@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
}; };
}; };
#undef __class__ #undef __class__
@ -804,10 +805,10 @@ template<class CLASS_TYPE> class RegExpNodeWhiteSpaceNot : public RegExpNode<CLA
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
//EDN_INFO("Parse node : SpaceNot{" << m_multipleMin << "," << m_multipleMax << "}"); //EDN_INFO("Parse node : SpaceNot{" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
bool tmpFind = true; bool tmpFind = true;
int32_t j; int32_t j;
for (j=0; j<m_multipleMax && tmpFind ==true && j < lenMax; j++) { for (j=0; j<RegExpNode<CLASS_TYPE>::m_multipleMax && tmpFind ==true && j < lenMax; j++) {
char tmpVal = data[currentPos+j]; char tmpVal = data[currentPos+j];
if( ' ' != tmpVal if( ' ' != tmpVal
&& '\t' != tmpVal && '\t' != tmpVal
@ -821,13 +822,13 @@ template<class CLASS_TYPE> class RegExpNodeWhiteSpaceNot : public RegExpNode<CLA
tmpFind=false; tmpFind=false;
} }
} }
if( j>=m_multipleMin if( j>=RegExpNode<CLASS_TYPE>::m_multipleMin
&& j<=m_multipleMax && j<=RegExpNode<CLASS_TYPE>::m_multipleMax
&& findLen>0 ) && findLen>0 )
{ {
//EDN_DEBUG("find " << findLen); //EDN_DEBUG("find " << findLen);
return true; return true;
} else if( 0 == m_multipleMin ) { } else if( 0 == RegExpNode<CLASS_TYPE>::m_multipleMin ) {
//EDN_DEBUG("find size=0"); //EDN_DEBUG("find size=0");
return true; return true;
} }
@ -841,7 +842,7 @@ template<class CLASS_TYPE> class RegExpNodeWhiteSpaceNot : public RegExpNode<CLA
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@SpaceNot@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@SpaceNot@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
}; };
}; };
#undef __class__ #undef __class__
@ -878,10 +879,10 @@ template<class CLASS_TYPE> class RegExpNodeWordChar : public RegExpNode<CLASS_TY
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
//EDN_INFO("Parse node : Word{" << m_multipleMin << "," << m_multipleMax << "}"); //EDN_INFO("Parse node : Word{" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
bool tmpFind = true; bool tmpFind = true;
int32_t j; int32_t j;
for (j=0; j<m_multipleMax && tmpFind ==true && j < lenMax; j++) { for (j=0; j<RegExpNode<CLASS_TYPE>::m_multipleMax && tmpFind ==true && j < lenMax; j++) {
char tmpVal = data[currentPos+j]; char tmpVal = data[currentPos+j];
if( ( 'a' <= tmpVal if( ( 'a' <= tmpVal
&& 'z' >= tmpVal ) && 'z' >= tmpVal )
@ -895,13 +896,13 @@ template<class CLASS_TYPE> class RegExpNodeWordChar : public RegExpNode<CLASS_TY
tmpFind=false; tmpFind=false;
} }
} }
if( j>=m_multipleMin if( j>=RegExpNode<CLASS_TYPE>::m_multipleMin
&& j<=m_multipleMax && j<=RegExpNode<CLASS_TYPE>::m_multipleMax
&& findLen>0 ) && findLen>0 )
{ {
//EDN_DEBUG("find " << findLen); //EDN_DEBUG("find " << findLen);
return true; return true;
} else if( 0 == m_multipleMin ) { } else if( 0 == RegExpNode<CLASS_TYPE>::m_multipleMin ) {
//EDN_DEBUG("find size=0"); //EDN_DEBUG("find size=0");
return true; return true;
} }
@ -915,7 +916,7 @@ template<class CLASS_TYPE> class RegExpNodeWordChar : public RegExpNode<CLASS_TY
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@Word@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@Word@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
}; };
}; };
#undef __class__ #undef __class__
@ -952,10 +953,10 @@ template<class CLASS_TYPE> class RegExpNodeWordCharNot : public RegExpNode<CLASS
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
//EDN_INFO("Parse node : WordNot{" << m_multipleMin << "," << m_multipleMax << "}"); //EDN_INFO("Parse node : WordNot{" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
bool tmpFind = true; bool tmpFind = true;
int32_t j; int32_t j;
for (j=0; j<m_multipleMax && tmpFind ==true && j < lenMax; j++) { for (j=0; j<RegExpNode<CLASS_TYPE>::m_multipleMax && tmpFind ==true && j < lenMax; j++) {
char tmpVal = data[currentPos+j]; char tmpVal = data[currentPos+j];
if( ( 'A' > tmpVal if( ( 'A' > tmpVal
&& '9' < tmpVal ) && '9' < tmpVal )
@ -969,13 +970,13 @@ template<class CLASS_TYPE> class RegExpNodeWordCharNot : public RegExpNode<CLASS
tmpFind=false; tmpFind=false;
} }
} }
if( j>=m_multipleMin if( j>=RegExpNode<CLASS_TYPE>::m_multipleMin
&& j<=m_multipleMax && j<=RegExpNode<CLASS_TYPE>::m_multipleMax
&& findLen>0 ) && findLen>0 )
{ {
//EDN_DEBUG("find " << findLen); //EDN_DEBUG("find " << findLen);
return true; return true;
} else if( 0 == m_multipleMin ) { } else if( 0 == RegExpNode<CLASS_TYPE>::m_multipleMin ) {
//EDN_DEBUG("find size=0"); //EDN_DEBUG("find size=0");
return true; return true;
} }
@ -989,7 +990,7 @@ template<class CLASS_TYPE> class RegExpNodeWordCharNot : public RegExpNode<CLASS
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@WordNot@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@WordNot@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
}; };
}; };
#undef __class__ #undef __class__
@ -1026,11 +1027,11 @@ template<class CLASS_TYPE> class RegExpNodeDot : public RegExpNode<CLASS_TYPE> {
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
//EDN_INFO("Parse node : '.'{" << m_multipleMin << "," << m_multipleMax << "}"); //EDN_INFO("Parse node : '.'{" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
// equivalent a : [^\x00-\x08\x0A-\x1F\x7F] // equivalent a : [^\x00-\x08\x0A-\x1F\x7F]
bool tmpFind = true; bool tmpFind = true;
int32_t j; int32_t j;
for (j=0; j<m_multipleMax && tmpFind ==true && j < lenMax; j++) { for (j=0; j<RegExpNode<CLASS_TYPE>::m_multipleMax && tmpFind ==true && j < lenMax; j++) {
char tmpVal = data[currentPos+j]; char tmpVal = data[currentPos+j];
if( ( 0x08 < tmpVal if( ( 0x08 < tmpVal
&& 0x0A > tmpVal ) && 0x0A > tmpVal )
@ -1044,13 +1045,13 @@ template<class CLASS_TYPE> class RegExpNodeDot : public RegExpNode<CLASS_TYPE> {
tmpFind=false; tmpFind=false;
} }
} }
if( j>=m_multipleMin if( j>=RegExpNode<CLASS_TYPE>::m_multipleMin
&& j<=m_multipleMax && j<=RegExpNode<CLASS_TYPE>::m_multipleMax
&& findLen>0 ) && findLen>0 )
{ {
//EDN_DEBUG("find " << findLen); //EDN_DEBUG("find " << findLen);
return true; return true;
} else if( 0 == m_multipleMin ) { } else if( 0 == RegExpNode<CLASS_TYPE>::m_multipleMin ) {
//EDN_DEBUG("find size=0"); //EDN_DEBUG("find size=0");
return true; return true;
} }
@ -1064,7 +1065,7 @@ template<class CLASS_TYPE> class RegExpNodeDot : public RegExpNode<CLASS_TYPE> {
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@.@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@.@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
}; };
}; };
@ -1102,7 +1103,7 @@ template<class CLASS_TYPE> class RegExpNodeSOL : public RegExpNode<CLASS_TYPE> {
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
EDN_INFO("Parse node : SOL{" << m_multipleMin << "," << m_multipleMax << "}"); EDN_INFO("Parse node : SOL{" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
return false; return false;
}; };
@ -1113,7 +1114,7 @@ template<class CLASS_TYPE> class RegExpNodeSOL : public RegExpNode<CLASS_TYPE> {
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@SOL@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@SOL@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
}; };
}; };
@ -1151,7 +1152,7 @@ template<class CLASS_TYPE> class RegExpNodeEOL : public RegExpNode<CLASS_TYPE> {
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
EDN_INFO("Parse node : EOL{" << m_multipleMin << "," << m_multipleMax << "}"); EDN_INFO("Parse node : EOL{" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
return false; return false;
}; };
@ -1162,7 +1163,7 @@ template<class CLASS_TYPE> class RegExpNodeEOL : public RegExpNode<CLASS_TYPE> {
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@EOL@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@EOL@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
}; };
}; };
@ -1174,6 +1175,8 @@ typedef struct {
#undef __class__ #undef __class__
#define __class__ "RegExpNodePTheseElem" #define __class__ "RegExpNodePTheseElem"
template<class CLASS_TYPE> class RegExpNodePThese;
template<class CLASS_TYPE> class RegExpNodePTheseElem : public RegExpNode<CLASS_TYPE> { template<class CLASS_TYPE> class RegExpNodePTheseElem : public RegExpNode<CLASS_TYPE> {
public : public :
@ -1205,23 +1208,23 @@ template<class CLASS_TYPE> class RegExpNodePTheseElem : public RegExpNode<CLASS_
*/ */
int32_t Generate(EdnVectorBin<int16_t> &data) int32_t Generate(EdnVectorBin<int16_t> &data)
{ {
m_RegExpData = data; RegExpNode<CLASS_TYPE>::m_RegExpData = data;
//EDN_DEBUG("Request Parse (elem) data="; DisplayElem(m_RegExpData);); //EDN_DEBUG("Request Parse (elem) data="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
int32_t pos = 0; int32_t pos = 0;
int32_t elementSize = 0; int32_t elementSize = 0;
EdnVectorBin<int16_t> tmpData; EdnVectorBin<int16_t> tmpData;
while (pos < m_RegExpData.Size()) { while (pos < RegExpNode<CLASS_TYPE>::m_RegExpData.Size()) {
tmpData.Clear(); tmpData.Clear();
switch (m_RegExpData[pos]) switch (RegExpNode<CLASS_TYPE>::m_RegExpData[pos])
{ {
case OPCODE_PTHESE_IN: case OPCODE_PTHESE_IN:
{ {
elementSize=GetLenOfPThese(m_RegExpData, pos); elementSize=GetLenOfPThese(RegExpNode<CLASS_TYPE>::m_RegExpData, pos);
for (int32_t k=pos+1; k<pos+elementSize+1; k++) { for (int32_t k=pos+1; k<pos+elementSize+1; k++) {
tmpData.PushBack(m_RegExpData[k]); tmpData.PushBack(RegExpNode<CLASS_TYPE>::m_RegExpData[k]);
} }
RegExpNodePThese<CLASS_TYPE> * myElem = new RegExpNodePThese(); RegExpNodePThese<CLASS_TYPE> * myElem = new RegExpNodePThese<CLASS_TYPE>();
(void)myElem->Generate(tmpData); (void)myElem->Generate(tmpData);
// add to the subnode list : // add to the subnode list :
m_subNode.PushBack(myElem); m_subNode.PushBack(myElem);
@ -1235,11 +1238,11 @@ template<class CLASS_TYPE> class RegExpNodePTheseElem : public RegExpNode<CLASS_
case OPCODE_BRACKET_IN: case OPCODE_BRACKET_IN:
{ {
elementSize=GetLenOfBracket(m_RegExpData, pos); elementSize=GetLenOfBracket(RegExpNode<CLASS_TYPE>::m_RegExpData, pos);
for (int32_t k=pos+1; k<pos+elementSize+1; k++) { for (int32_t k=pos+1; k<pos+elementSize+1; k++) {
tmpData.PushBack(m_RegExpData[k]); tmpData.PushBack(RegExpNode<CLASS_TYPE>::m_RegExpData[k]);
} }
RegExpNodeBracket<CLASS_TYPE> * myElem = new RegExpNodeBracket(); RegExpNodeBracket<CLASS_TYPE> * myElem = new RegExpNodeBracket<CLASS_TYPE>();
(void)myElem->Generate(tmpData); (void)myElem->Generate(tmpData);
// add to the subnode list : // add to the subnode list :
m_subNode.PushBack(myElem); m_subNode.PushBack(myElem);
@ -1253,9 +1256,9 @@ template<class CLASS_TYPE> class RegExpNodePTheseElem : public RegExpNode<CLASS_
case OPCODE_BRACE_IN: case OPCODE_BRACE_IN:
{ {
elementSize=GetLenOfBrace(m_RegExpData, pos); elementSize=GetLenOfBrace(RegExpNode<CLASS_TYPE>::m_RegExpData, pos);
for (int32_t k=pos+1; k<pos+elementSize+1; k++) { for (int32_t k=pos+1; k<pos+elementSize+1; k++) {
tmpData.PushBack(m_RegExpData[k]); tmpData.PushBack(RegExpNode<CLASS_TYPE>::m_RegExpData[k]);
} }
int32_t min = 0; int32_t min = 0;
int32_t max = 0; int32_t max = 0;
@ -1291,56 +1294,56 @@ template<class CLASS_TYPE> class RegExpNodePTheseElem : public RegExpNode<CLASS_
return false; return false;
case OPCODE_DOT: case OPCODE_DOT:
m_subNode.PushBack(new RegExpNodeDot()); m_subNode.PushBack(new RegExpNodeDot<CLASS_TYPE>());
break; break;
case OPCODE_START_OF_LINE: case OPCODE_START_OF_LINE:
m_subNode.PushBack(new RegExpNodeSOL()); m_subNode.PushBack(new RegExpNodeSOL<CLASS_TYPE>());
break; break;
case OPCODE_END_OF_LINE: case OPCODE_END_OF_LINE:
m_subNode.PushBack(new RegExpNodeEOL()); m_subNode.PushBack(new RegExpNodeEOL<CLASS_TYPE>());
break; break;
case OPCODE_DIGIT: case OPCODE_DIGIT:
m_subNode.PushBack(new RegExpNodeDigit()); m_subNode.PushBack(new RegExpNodeDigit<CLASS_TYPE>());
break; break;
case OPCODE_DIGIT_NOT: case OPCODE_DIGIT_NOT:
m_subNode.PushBack(new RegExpNodeDigitNot()); m_subNode.PushBack(new RegExpNodeDigitNot<CLASS_TYPE>());
break; break;
case OPCODE_LETTER: case OPCODE_LETTER:
m_subNode.PushBack(new RegExpNodeLetter()); m_subNode.PushBack(new RegExpNodeLetter<CLASS_TYPE>());
break; break;
case OPCODE_LETTER_NOT: case OPCODE_LETTER_NOT:
m_subNode.PushBack(new RegExpNodeLetterNot()); m_subNode.PushBack(new RegExpNodeLetterNot<CLASS_TYPE>());
break; break;
case OPCODE_SPACE: case OPCODE_SPACE:
m_subNode.PushBack(new RegExpNodeWhiteSpace()); m_subNode.PushBack(new RegExpNodeWhiteSpace<CLASS_TYPE>());
break; break;
case OPCODE_SPACE_NOT: case OPCODE_SPACE_NOT:
m_subNode.PushBack(new RegExpNodeWhiteSpaceNot()); m_subNode.PushBack(new RegExpNodeWhiteSpaceNot<CLASS_TYPE>());
break; break;
case OPCODE_WORD: case OPCODE_WORD:
m_subNode.PushBack(new RegExpNodeWordChar()); m_subNode.PushBack(new RegExpNodeWordChar<CLASS_TYPE>());
break; break;
case OPCODE_WORD_NOT: case OPCODE_WORD_NOT:
m_subNode.PushBack(new RegExpNodeWordCharNot()); m_subNode.PushBack(new RegExpNodeWordCharNot<CLASS_TYPE>());
break; break;
default: default:
{ {
elementSize=GetLenOfNormal(m_RegExpData, pos); elementSize=GetLenOfNormal(RegExpNode<CLASS_TYPE>::m_RegExpData, pos);
for (int32_t k=pos; k<pos+elementSize; k++) { for (int32_t k=pos; k<pos+elementSize; k++) {
tmpData.PushBack(m_RegExpData[k]); tmpData.PushBack(RegExpNode<CLASS_TYPE>::m_RegExpData[k]);
} }
RegExpNodeValue * myElem = new RegExpNodeValue(); RegExpNodeValue<CLASS_TYPE> * myElem = new RegExpNodeValue<CLASS_TYPE>();
(void)myElem->Generate(tmpData); (void)myElem->Generate(tmpData);
// add to the subnode list : // add to the subnode list :
m_subNode.PushBack(myElem); m_subNode.PushBack(myElem);
@ -1362,7 +1365,7 @@ template<class CLASS_TYPE> class RegExpNodePTheseElem : public RegExpNode<CLASS_
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
//EDN_INFO("Parse node : (Elem){" << m_multipleMin << "," << m_multipleMax << "}"); //EDN_INFO("Parse node : (Elem){" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
// NOTE 1 : Must done only one time in EVERY case ... // NOTE 1 : Must done only one time in EVERY case ...
// NOTE 2 : All element inside must be OK // NOTE 2 : All element inside must be OK
if (0 == m_subNode.Size()) { if (0 == m_subNode.Size()) {
@ -1389,7 +1392,7 @@ template<class CLASS_TYPE> class RegExpNodePTheseElem : public RegExpNode<CLASS_
*/ */
void Display(int32_t level) void Display(int32_t level)
{ {
EDN_INFO("Find NODE : " << levelSpace(level) << "@(Elem)@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@(Elem)@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
for(int32_t i=0; i<m_subNode.Size(); i++) { for(int32_t i=0; i<m_subNode.Size(); i++) {
m_subNode[i]->Display(level+1); m_subNode[i]->Display(level+1);
} }
@ -1413,7 +1416,7 @@ template<class CLASS_TYPE> class RegExpNodePTheseElem : public RegExpNode<CLASS_
EDN_ERROR("Set multiplicity on an inexistant element ...."); EDN_ERROR("Set multiplicity on an inexistant element ....");
return false; return false;
} }
RegExpNode * myNode = m_subNode[m_subNode.Size()-1]; RegExpNode<CLASS_TYPE> * myNode = m_subNode[m_subNode.Size()-1];
if (NULL==myNode) { if (NULL==myNode) {
EDN_ERROR("INTERNAL error ==> node not generated"); EDN_ERROR("INTERNAL error ==> node not generated");
return false; return false;
@ -1455,25 +1458,25 @@ template<class CLASS_TYPE> class RegExpNodePThese : public RegExpNode<CLASS_TYPE
*/ */
int32_t Generate(EdnVectorBin<int16_t> &data) int32_t Generate(EdnVectorBin<int16_t> &data)
{ {
m_RegExpData = data; RegExpNode<CLASS_TYPE>::m_RegExpData = data;
//EDN_DEBUG("Request Parse (...) data="; DisplayElem(m_RegExpData);); //EDN_DEBUG("Request Parse (...) data="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
//Find all the '|' in the string (and at the good level ...) //Find all the '|' in the string (and at the good level ...)
int32_t pos = 0; int32_t pos = 0;
int32_t elementSize = GetLenOfPTheseElem(m_RegExpData, pos); int32_t elementSize = GetLenOfPTheseElem(RegExpNode<CLASS_TYPE>::m_RegExpData, pos);
// generate all the "elemTypePTheseElem" of the Node // generate all the "elemTypePTheseElem" of the Node
while (elementSize>0) { while (elementSize>0) {
// geerate output deta ... // geerate output deta ...
EdnVectorBin<int16_t> tmpData; EdnVectorBin<int16_t> tmpData;
for (int32_t k=pos; k<pos+elementSize; k++) { for (int32_t k=pos; k<pos+elementSize; k++) {
tmpData.PushBack(m_RegExpData[k]); tmpData.PushBack(RegExpNode<CLASS_TYPE>::m_RegExpData[k]);
} }
RegExpNodePTheseElem<CLASS_TYPE> * myElem = new RegExpNodePTheseElem(); RegExpNodePTheseElem<CLASS_TYPE> * myElem = new RegExpNodePTheseElem<CLASS_TYPE>();
(void)myElem->Generate(tmpData); (void)myElem->Generate(tmpData);
// add to the subnode list : // add to the subnode list :
m_subNode.PushBack(myElem); m_subNode.PushBack(myElem);
pos += elementSize+1; pos += elementSize+1;
//EDN_DEBUG("plop="; DisplayElem(data, pos, pos+1);); //EDN_DEBUG("plop="; DisplayElem(data, pos, pos+1););
elementSize = GetLenOfPTheseElem(m_RegExpData, pos); elementSize = GetLenOfPTheseElem(RegExpNode<CLASS_TYPE>::m_RegExpData, pos);
//EDN_DEBUG("find " << elementSize << " elements"); //EDN_DEBUG("find " << elementSize << " elements");
} }
if (0 == pos && 0 == elementSize) { if (0 == pos && 0 == elementSize) {
@ -1491,13 +1494,13 @@ template<class CLASS_TYPE> class RegExpNodePThese : public RegExpNode<CLASS_TYPE
bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen) bool Parse(CLASS_TYPE &data, int32_t currentPos, int32_t lenMax, int32_t &findLen)
{ {
findLen = 0; findLen = 0;
//EDN_INFO("Parse node : (...){" << m_multipleMin << "," << m_multipleMax << "}"); //EDN_INFO("Parse node : (...){" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "}");
if (0 == m_subNode.Size()) { if (0 == m_subNode.Size()) {
return false; return false;
} }
bool tmpFind = true; bool tmpFind = true;
int32_t j; int32_t j;
for (j=0; j<m_multipleMax && tmpFind == true ; j++) { for (j=0; j<RegExpNode<CLASS_TYPE>::m_multipleMax && tmpFind == true ; j++) {
tmpFind = false; tmpFind = false;
for (int32_t i=0; i<m_subNode.Size(); i++) { for (int32_t i=0; i<m_subNode.Size(); i++) {
int32_t tmpFindLen; int32_t tmpFindLen;
@ -1507,13 +1510,13 @@ template<class CLASS_TYPE> class RegExpNodePThese : public RegExpNode<CLASS_TYPE
} }
} }
} }
if( j>=m_multipleMin if( j>=RegExpNode<CLASS_TYPE>::m_multipleMin
&& j<=m_multipleMax && j<=RegExpNode<CLASS_TYPE>::m_multipleMax
&& findLen>0 ) && findLen>0 )
{ {
//EDN_DEBUG("find " << findLen); //EDN_DEBUG("find " << findLen);
return true; return true;
} else if( 0 == m_multipleMin ) { } else if( 0 == RegExpNode<CLASS_TYPE>::m_multipleMin ) {
//EDN_DEBUG("find size=0"); //EDN_DEBUG("find size=0");
return true; return true;
} }
@ -1528,9 +1531,9 @@ template<class CLASS_TYPE> class RegExpNodePThese : public RegExpNode<CLASS_TYPE
void Display(int32_t level) void Display(int32_t level)
{ {
if (-1 == level) { if (-1 == level) {
EDN_INFO("regExp :"; DisplayElem(m_RegExpData);); EDN_INFO("regExp :"; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
} else { } else {
EDN_INFO("Find NODE : " << levelSpace(level) << "@(...)@ {" << m_multipleMin << "," << m_multipleMax << "} subdata="; DisplayElem(m_RegExpData);); EDN_INFO("Find NODE : " << levelSpace(level) << "@(...)@ {" << RegExpNode<CLASS_TYPE>::m_multipleMin << "," << RegExpNode<CLASS_TYPE>::m_multipleMax << "} subdata="; DisplayElem(RegExpNode<CLASS_TYPE>::m_RegExpData););
for(int32_t i=0; i<m_subNode.Size(); i++) { for(int32_t i=0; i<m_subNode.Size(); i++) {
m_subNode[i]->Display(level+1); m_subNode[i]->Display(level+1);
} }
@ -1623,7 +1626,7 @@ template<class CLASS_TYPE> class EdnRegExp {
* @param[in,out] * @param[in,out]
* @return * @return
*/ */
void SetRegExp(Edn::String &exp) void SetRegExp(Edn::String &expressionRequested)
{ {
m_expressionRequested = expressionRequested; // TODO : Must be deprecated ... m_expressionRequested = expressionRequested; // TODO : Must be deprecated ...
EdnVectorBin<int16_t> tmpExp; EdnVectorBin<int16_t> tmpExp;