home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 February / PCWorld_2000-02_cd.bin / Software / TemaCD / tcvpa / data1.cab / MyFileGroup / INCLUDE / RegExp.hpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-06-03  |  4.5 KB  |  127 lines
  1. #ifdef BUILD_TCCORE
  2. #define TCCORELIB __declspec(dllexport)
  3. #else
  4. #ifdef BUILD_LOCAL
  5. #define TCCORELIB
  6. #else
  7. #define TCCORELIB __declspec(dllimport)
  8. #endif
  9. #endif
  10.  
  11. // **********************************************************************
  12. class TCCORELIB TC_CRegExp 
  13. {
  14. public:
  15.     enum { MAX_PAIRS = 10 };
  16. /*
  17.  
  18. REGULAR EXPRESSION SYNTAX:
  19.  
  20. A regular expression is zero or more branches, separated by `|`.
  21. It matches anything that matches one of the branches.
  22.  
  23. A branch is zero or more pieces, concatenated.
  24. It matches a match for the first, followed by a match for the second, etc.
  25.  
  26. A piece is an atom possibly followed by `*`, `+`, or `?`.
  27.  
  28. An atom followed by `*` matches a sequence of 0 or more matches of the atom.
  29. An atom followed by `+` matches a sequence of 1 or more matches of the atom.
  30. An atom followed by `?` matches a match of the atom, or the null string.
  31.  
  32. An atom is:
  33.     -    a regular expression in parentheses (matching a match for the regular expression)
  34.     -    range (see below)
  35.     -    `.` (matching any single character)
  36.     -    `^` (matching the null string at the beginning of the input string)
  37.     -    `$` (matching the null string at the end of the input string)
  38.     -    `\e` followed by a single character (matching that character)
  39.     -    a single character with no other significance (matching that character).
  40.  
  41. A range is a sequence of characters enclosed in `[]`.
  42. It normally matches any single character from the sequence.
  43.  
  44. If the sequence begins with `^`, it matches any single character not from the rest of the sequence.
  45.  
  46. If two characters in the sequence are separated by `-`, this is shorthand
  47. for the full list of ASCII characters between them (e.g. `[0-9]` matches any decimal digit).
  48.  
  49. To include a literal `]` in the sequence, make it the first character
  50. (following a possible `^`).
  51.  
  52. To include a literal `-`, make it the first or last character.
  53.  
  54. */
  55.  
  56. // **********************************************************************
  57. public: 
  58. struct IntPair 
  59. {
  60. public:  long position ;
  61. public:  long length ;
  62.  
  63. }; // end of class IntPair
  64.  
  65. // **********************************************************************
  66.  
  67. // **********************************************************************
  68. public: 
  69. struct RegExpStruct 
  70. {
  71. public:  char * startp [MAX_PAIRS];
  72. public:  char * endp [MAX_PAIRS];
  73. public:  char regstart ;
  74. public:  char reganch ;
  75. public:  char * regmust ;
  76. public:  int regmlen ;
  77. public:  char program [1];
  78.  
  79. }; // end of class RegExpStruct
  80.  
  81. // **********************************************************************
  82. protected:  RegExpStruct* m_RegExp ;
  83. protected:  TC_CString m_RegExpString ;
  84. protected:  TC_CString m_LastError ;
  85. protected:  char* m_RegParse ;
  86. protected:  int m_RegNPar ;
  87. protected:  char m_RegDummy ;
  88. protected:  char* m_RegCode ;
  89. protected:  long m_RegSize ;
  90. protected:  char * m_RegInput ;
  91. protected:  char * m_RegBOL ;
  92. protected:  char ** m_RegStartP ;
  93. protected:  char ** m_RegEndP ;
  94. protected:  void regerror (char* s)  ;
  95. protected:  char* reg (int paren, int* flagp)  ;
  96. protected:  char* regbranch (int* flagp)  ;
  97. protected:  char* regpiece (int* flagp)  ;
  98. protected:  char* regatom (int* flagp)  ;
  99. protected:  char* regnode (char op)  ;
  100. protected:  void regc (char b)  ;
  101. protected:  void reginsert (char op, char* opnd)  ;
  102. protected:  void regtail (char *p, char *val)  ;
  103. protected:  void regoptail (char *p, char *val)  ;
  104. protected:  int regtry (RegExpStruct *prog, char *string)  ;
  105. protected:  int regmatch (char *prog)  ;
  106. protected:  int regrepeat (char *p)  ;
  107. protected:  char * regnext (register char *p)  ;
  108. protected:  TC_CRegExp::RegExpStruct* _regcomp (char* exp)  ;
  109. protected:  int _regexec (register RegExpStruct *prog, register char *string)  ;
  110. protected:  void _regsub (RegExpStruct *prog, char *source, char *dest)  ;
  111. public:   TC_CRegExp ()  ;
  112. public:   TC_CRegExp (const char* regExp)  ;
  113. public:   TC_CRegExp (TC_CRegExp& r)  ;
  114. public:   ~TC_CRegExp ()  ;
  115. public:  BOOL SetRegExp (const char* regExp)  ;
  116. public:  BOOL SetRegExp (TC_CRegExp& regExp)  ;
  117. public:  TC_CRegExp& operator= (const char* regExp)  ;
  118. public:  TC_CRegExp& operator= (TC_CRegExp& regExp)  ;
  119. public:  long IndexIn (const char* string, long beginFrom  = 0)  ;
  120. public:  long Match (const char* string, long& length, long beginFrom = 0)  ;
  121. public:  long Match (const char* string, IntPair segs [MAX_PAIRS], long beginFrom = 0)  ;
  122. public:  TC_CString & LastError ()  ;
  123.  
  124. }; // end of class TC_CRegExp
  125.  
  126. // **********************************************************************
  127.