DCL 3.7.4
Loading...
Searching...
No Matches
_regex.h File Reference

Go to the source code of this file.

Classes

struct  match_result

Macros

#define __DCL_REGEX_WRAP   20110119

Typedefs

typedef void * regex_handle

Enumerations

enum  regex_compile_flags { regex_icase = 0x0001 , regex_nosubs = 0x0002 , regex_newline = 0x0004 }
enum  regex_match_flags { regex_not_bol = 0x0001 , regex_not_eol = 0x0002 }

Functions

regex_handle __regex_create ()
void __regex_destroy (regex_handle _handle)
void __regex_compile (regex_handle _handle, const wchar_t *_pattern, size_t _n, unsigned int _flags)
void __matches_free (match_result *_results)
size_t __regex_match (regex_handle _handle, const wchar_t *_begin, const wchar_t *_end, match_result **_results, unsigned int _flags)
bool __regex_match (regex_handle _handle, const wchar_t *_begin, const wchar_t *_end, unsigned int _flags)
bool __regex_search (regex_handle _handle, const wchar_t *_begin, const wchar_t *_end, match_result **_results, unsigned int _flags)
bool __regex_search (regex_handle _handle, const wchar_t *_begin, const wchar_t *_end, unsigned int _flags)
bool __regex_matches (const wchar_t *_regex, const wchar_t *_regexend, const wchar_t *_begin, const wchar_t *_end, bool _icase) __DCL_THROWS1(RegexException *)
bool __regex_matches (const char *_regex, const char *_regexend, const char *_begin, const char *_end, bool _icase) __DCL_THROWS1(RegexException *)
size_t __regex_search (const wchar_t *_regex, const wchar_t *_regexend, const wchar_t *_begin, const wchar_t *_end, bool _icase) __DCL_THROWS1(RegexException *)
size_t __regex_search (const char *_regex, const char *_regexend, const char *_begin, const char *_end, bool _icase) __DCL_THROWS1(RegexException *)
String __regex_substring (const wchar_t *_regex, const wchar_t *_regexend, const wchar_t *_begin, const wchar_t *_end, bool _icase) __DCL_THROWS1(RegexException *)
ByteString __regex_substring (const char *_regex, const char *_regexend, const char *_begin, const char *_end, bool _icase) __DCL_THROWS1(RegexException *)
String __regex_replace (const wchar_t *_regex, const wchar_t *_regexend, const wchar_t *_begin, const wchar_t *_end, const wchar_t *_replacement, const wchar_t *_replacementend, bool _icase, size_t _limit=(size_t) -1) __DCL_THROWS1(RegexException *)
ByteString __regex_replace (const char *_regex, const char *_regexend, const char *_begin, const char *_end, const char *_replacement, const char *_replacementend, bool _icase, size_t _limit=(size_t) -1) __DCL_THROWS1(RegexException *)
StringArray & __regex_split (const wchar_t *_regex, const wchar_t *_regexend, const wchar_t *_begin, const wchar_t *_end, bool _icase, StringArray &_results, size_t _limit=(size_t) -1) __DCL_THROWS1(RegexException *)
ByteStringArray & __regex_split (const char *_regex, const char *_regexend, const char *_begin, const char *_end, bool _icase, ByteStringArray &_results, size_t _limit=(size_t) -1) __DCL_THROWS1(RegexException *)

Macro Definition Documentation

◆ __DCL_REGEX_WRAP

#define __DCL_REGEX_WRAP   20110119

Definition at line 2 of file _regex.h.

Typedef Documentation

◆ regex_handle

typedef void* regex_handle

Definition at line 12 of file _regex.h.

Enumeration Type Documentation

◆ regex_compile_flags

enum regex_compile_flags
Enumerator
regex_icase 
regex_nosubs 
regex_newline 

Definition at line 17 of file _regex.h.

17 {
18 regex_icase = 0x0001,
19 regex_nosubs = 0x0002,
20 regex_newline = 0x0004
21};
regex_icase
@ regex_icase
Definition _regex.h:18
regex_newline
@ regex_newline
Definition _regex.h:20
regex_nosubs
@ regex_nosubs
Definition _regex.h:19

◆ regex_match_flags

enum regex_match_flags
Enumerator
regex_not_bol 
regex_not_eol 

Definition at line 38 of file _regex.h.

38 {
39 regex_not_bol = 0x0001,
40 regex_not_eol = 0x0002
41};
regex_not_bol
@ regex_not_bol
Definition _regex.h:39
regex_not_eol
@ regex_not_eol
Definition _regex.h:40

Function Documentation

◆ __matches_free()

void __matches_free ( match_result * _results)

Definition at line 89 of file _regex.cpp.

90{
91 free(_results);
92// delete[] _results;
93}

◆ __regex_compile()

void __regex_compile ( regex_handle _handle,
const wchar_t * _pattern,
size_t _n,
unsigned int _flags )

Definition at line 69 of file _regex.cpp.

74{
75 wregex::flag_type flags = wregex::extended;// wregex::normal;
76 if (_flags & regex_icase)
77 flags |= wregex::icase;
78 if (_flags & regex_nosubs)
79 flags |= wregex::nosubs;
80#if 0
81 if (_flags & regex_newline)
82 flags |= wregex::newline_alt;
83#endif
84 __DCL_DEBUG_ALLOC_ENTER;
85 ((wregex*)_handle)->assign(_pattern, _pattern + _n, flags);
86 __DCL_DEBUG_ALLOC_LEAVE;
87}
__DCL_DEBUG_ALLOC_LEAVE
#define __DCL_DEBUG_ALLOC_LEAVE
Definition Object.h:708
__DCL_DEBUG_ALLOC_ENTER
#define __DCL_DEBUG_ALLOC_ENTER
Definition Object.h:707

◆ __regex_create()

regex_handle __regex_create ( )

Definition at line 44 of file _regex.cpp.

45{
46 //wregex* p = (wregex*)malloc(sizeof(wregex));
47 //return new(p) wregex;
48 __DCL_DEBUG_ALLOC_ENTER;
49 regex_handle r = (regex_handle)new wregex();
50 __DCL_DEBUG_ALLOC_LEAVE;
51 return r;
52}
regex_handle
void * regex_handle
Definition _regex.h:12
r
IOException *size_t r
Definition MediaInfo.cpp:82

◆ __regex_destroy()

void __regex_destroy ( regex_handle _handle)

Definition at line 54 of file _regex.cpp.

55{
56 //wregex* p = (wregex*)_handle;
57 //p->~wregex();
58 //free(p);
59#ifdef __DCL_DEBUG_DELETE
60// MINGW64 g++ 은 overrided delete를 호출하지 않는다!
61#define delete(_p) __DCL_DEBUG_DELETE(_p)
62#endif
63 delete ((wregex*)_handle);
64#ifdef __DCL_DEBUG_DELETE
65#undef delete
66#endif
67}

◆ __regex_match() [1/2]

size_t __regex_match ( regex_handle _handle,
const wchar_t * _begin,
const wchar_t * _end,
match_result ** _results,
unsigned int _flags )

Definition at line 95 of file _regex.cpp.

100{
101 regex_constants::match_flag_type flags = regex_constants::match_default;
102 if (_flags & regex_not_bol)
103 flags |= regex_constants::match_not_bol;
104 if (_flags & regex_not_eol)
105 flags |= regex_constants::match_not_eol;
106
107 wcmatch m;
108 __DCL_DEBUG_ALLOC_ENTER;
109 bool b = regex_match(_begin, _end, m, *((const wregex*)_handle), flags);
110 __DCL_DEBUG_ALLOC_LEAVE;
111 if (b) {
112 match_result* match = (match_result*)malloc(sizeof(match_result) * m.size());
113 for(size_t i = 0; i < m.size(); i++) {
114 match[i].first = m[i].first;
115 match[i].second = m[i].second;
116 match[i].matched = m[i].matched;
117 }
118 *_results = match;
119 return m.size();
120 }
121 *_results = NULL;
122 return 0;
123}
NULL
#define NULL
Definition Config.h:312
match_result
Definition _regex.h:32
match_result::first
const wchar_t * first
Definition _regex.h:33
match_result::second
const wchar_t * second
Definition _regex.h:34
match_result::matched
bool matched
Definition _regex.h:35

◆ __regex_match() [2/2]

bool __regex_match ( regex_handle _handle,
const wchar_t * _begin,
const wchar_t * _end,
unsigned int _flags )

Definition at line 125 of file _regex.cpp.

130{
131 regex_constants::match_flag_type flags = regex_constants::match_default;
132 if (_flags & regex_not_bol)
133 flags |= regex_constants::match_not_bol;
134 if (_flags & regex_not_eol)
135 flags |= regex_constants::match_not_eol;
136
137 __DCL_DEBUG_ALLOC_ENTER;
138 bool r = regex_match(_begin, _end, *(const wregex*)_handle, flags);
139 __DCL_DEBUG_ALLOC_LEAVE;
140 return r;
141}

◆ __regex_matches() [1/2]

bool __regex_matches ( const char * _regex,
const char * _regexend,
const char * _begin,
const char * _end,
bool _icase )

Definition at line 216 of file _regex.cpp.

221{
222 regex::flag_type flags = regex::ECMAScript;
223 if (_icase) {
224 flags |= regex::icase;
225 }
226
227 try {
228 __DCL_DEBUG_ALLOC_ENTER;
229 regex re(_regex, _regexend, flags);
230 __DCL_DEBUG_ALLOC_ENTER;
231 bool r = regex_match(_begin, _end, re);
232 __DCL_DEBUG_ALLOC_LEAVE;
233 return r;
234 }
235 // catch (std::runtime_error& e)
236 catch (std::exception& e) {
237 throw(new RegexException(typeid(e).name(), e.what()));
238 }
239}

◆ __regex_matches() [2/2]

bool __regex_matches ( const wchar_t * _regex,
const wchar_t * _regexend,
const wchar_t * _begin,
const wchar_t * _end,
bool _icase )

Definition at line 191 of file _regex.cpp.

196{
197 regex::flag_type flags = regex::ECMAScript;
198 if (_icase) {
199 flags |= regex::icase;
200 }
201
202 try {
203 __DCL_DEBUG_ALLOC_ENTER;
204 wregex re(_regex, _regexend, flags);
205 __DCL_DEBUG_ALLOC_ENTER;
206 bool r = regex_match(_begin, _end, re);
207 __DCL_DEBUG_ALLOC_LEAVE;
208 return r;
209 }
210 // catch (std::runtime_error& e)
211 catch (std::exception& e) {
212 throw(new RegexException(typeid(e).name(), e.what()));
213 }
214}

◆ __regex_replace() [1/2]

ByteString __regex_replace ( const char * _regex,
const char * _regexend,
const char * _begin,
const char * _end,
const char * _replacement,
const char * _replacementend,
bool _icase,
size_t _limit = (size_t) -1 )

Definition at line 411 of file _regex.cpp.

418{
419 regex::flag_type flags = regex::ECMAScript | regex::nosubs;
420 if (_icase) {
421 flags |= regex::icase;
422 }
423
424 try {
425 ByteStringBuilder r;
426 __DCL_DEBUG_ALLOC_ENTER;
427 regex re(_regex, _regexend, flags);
428 __DCL_DEBUG_ALLOC_ENTER;
429 cmatch m;
430 __DCL_DEBUG_ALLOC_ENTER;
431 while (_begin < _end && _limit && regex_search(_begin, _end, m, re)) {
432 __DCL_ASSERT(m.size() > 0);
433 r.append(_begin, m[0].first)
434 .append(_replacement, _replacementend);
435
436 _limit--;
437 _begin = m[0].second;
438 }
439 __DCL_DEBUG_ALLOC_LEAVE;
440 if (_begin < _end) {
441 r.append(_begin, _end);
442 }
443
444 return r;
445 }
446 // catch (std::runtime_error& e)
447 catch (std::exception& e) {
448 throw(new RegexException(typeid(e).name(), e.what()));
449 }
450}
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:394

◆ __regex_replace() [2/2]

String __regex_replace ( const wchar_t * _regex,
const wchar_t * _regexend,
const wchar_t * _begin,
const wchar_t * _end,
const wchar_t * _replacement,
const wchar_t * _replacementend,
bool _icase,
size_t _limit = (size_t) -1 )

Definition at line 370 of file _regex.cpp.

377{
378 regex::flag_type flags = regex::ECMAScript | regex::nosubs;
379 if (_icase) {
380 flags |= regex::icase;
381 }
382
383 try {
384 StringBuilder r;
385 __DCL_DEBUG_ALLOC_ENTER;
386 wregex re(_regex, _regexend, flags);
387 __DCL_DEBUG_ALLOC_ENTER;
388 wcmatch m;
389 __DCL_DEBUG_ALLOC_ENTER;
390 while (_begin < _end && _limit && regex_search(_begin, _end, m, re)) {
391 __DCL_ASSERT(m.size() > 0);
392 r.append(_begin, m[0].first)
393 .append(_replacement, _replacementend);
394
395 _limit--;
396 _begin = m[0].second;
397 }
398 __DCL_DEBUG_ALLOC_LEAVE;
399 if (_begin < _end) {
400 r.append(_begin, _end);
401 }
402
403 return r;
404 }
405 // catch (std::runtime_error& e)
406 catch (std::exception& e) {
407 throw(new RegexException(typeid(e).name(), e.what()));
408 }
409}

◆ __regex_search() [1/4]

size_t __regex_search ( const char * _regex,
const char * _regexend,
const char * _begin,
const char * _end,
bool _icase )

Definition at line 273 of file _regex.cpp.

278{
279 // GNUC BUG!!
280 // regex re(_pattern, regex::extended | (_icase ? regex::icase : 0));
281 regex::flag_type flags = regex::ECMAScript | regex::nosubs;
282 if (_icase) {
283 flags |= regex::icase;
284 }
285
286 size_t r = (size_t)-1;
287 try {
288 __DCL_DEBUG_ALLOC_ENTER;
289 regex re(_regex, _regexend, flags);
290 __DCL_DEBUG_ALLOC_ENTER;
291 cmatch m;
292 __DCL_DEBUG_ALLOC_ENTER;
293 if (regex_search(_begin, _end, m, re)) {
294 r = m[0].first - _begin;
295 }
296 __DCL_DEBUG_ALLOC_LEAVE;
297 }
298 // catch (std::runtime_error& e)
299 catch (std::exception& e) {
300 throw(new RegexException(typeid(e).name(), e.what()));
301 }
302 return r;
303}

◆ __regex_search() [2/4]

size_t __regex_search ( const wchar_t * _regex,
const wchar_t * _regexend,
const wchar_t * _begin,
const wchar_t * _end,
bool _icase )

Definition at line 241 of file _regex.cpp.

246{
247 // GNUC BUG!!
248 // regex re(_pattern, regex::extended | (_icase ? regex::icase : 0));
249 regex::flag_type flags = regex::ECMAScript | regex::nosubs;
250 if (_icase) {
251 flags |= regex::icase;
252 }
253
254 size_t r = (size_t)-1;
255 try {
256 __DCL_DEBUG_ALLOC_ENTER;
257 wregex re(_regex, _regexend, flags);
258 __DCL_DEBUG_ALLOC_ENTER;
259 wcmatch m;
260 __DCL_DEBUG_ALLOC_ENTER;
261 if (regex_search(_begin, _end, m, re)) {
262 r = m[0].first - _begin;
263 }
264 __DCL_DEBUG_ALLOC_LEAVE;
265 }
266 // catch (std::runtime_error& e)
267 catch (std::exception& e) {
268 throw(new RegexException(typeid(e).name(), e.what()));
269 }
270 return r;
271}

◆ __regex_search() [3/4]

bool __regex_search ( regex_handle _handle,
const wchar_t * _begin,
const wchar_t * _end,
match_result ** _results,
unsigned int _flags )

Definition at line 143 of file _regex.cpp.

148{
149 regex_constants::match_flag_type flags = regex_constants::match_default;
150 if (_flags & regex_not_bol)
151 flags |= regex_constants::match_not_bol;
152 if (_flags & regex_not_eol)
153 flags |= regex_constants::match_not_eol;
154
155 wcmatch m;
156 __DCL_DEBUG_ALLOC_ENTER;
157 bool r = regex_search(_begin, _end, m, *((const wregex*)_handle), flags);
158 __DCL_DEBUG_ALLOC_LEAVE;
159 if (r) {
160 match_result* match = (match_result*)malloc(sizeof(match_result) * m.size());
161 for(size_t i = 0; i < m.size(); i++) {
162 match[i].first = m[i].first;
163 match[i].second = m[i].second;
164 match[i].matched = m[i].matched;
165 }
166 *_results = match;
167 return m.size();
168 }
169 *_results = NULL;
170 return r;
171}

◆ __regex_search() [4/4]

bool __regex_search ( regex_handle _handle,
const wchar_t * _begin,
const wchar_t * _end,
unsigned int _flags )

Definition at line 173 of file _regex.cpp.

178{
179 regex_constants::match_flag_type flags = regex_constants::match_default;
180 if (_flags & regex_not_bol)
181 flags |= regex_constants::match_not_bol;
182 if (_flags & regex_not_eol)
183 flags |= regex_constants::match_not_eol;
184
185 __DCL_DEBUG_ALLOC_ENTER;
186 bool r = regex_search(_begin, _end, *(const wregex*)_handle, flags);
187 __DCL_DEBUG_ALLOC_LEAVE;
188 return r;
189}

◆ __regex_split() [1/2]

ByteStringArray & __regex_split ( const char * _regex,
const char * _regexend,
const char * _begin,
const char * _end,
bool _icase,
ByteStringArray & _results,
size_t _limit = (size_t) -1 )

Definition at line 491 of file _regex.cpp.

498{
499 regex::flag_type flags = regex::ECMAScript | regex::nosubs;
500 if (_icase) {
501 flags |= regex::icase;
502 }
503
504 try {
505 __DCL_DEBUG_ALLOC_ENTER;
506 regex re(_regex, _regexend, flags);
507 __DCL_DEBUG_ALLOC_ENTER;
508 cmatch m;
509 __DCL_DEBUG_ALLOC_ENTER;
510 while (_begin < _end && _limit && regex_search(_begin, _end, m, re)) {
511 __DCL_ASSERT(m.size() > 0);
512 _results.add(ByteString(_begin, m[0].first));
513
514 _limit--;
515 _begin = m[0].second;
516 }
517 __DCL_DEBUG_ALLOC_LEAVE;
518 if (_begin < _end) {
519 _results.add(ByteString(_begin, _end));
520 }
521
522 return _results;
523 }
524 // catch (std::runtime_error& e)
525 catch (std::exception& e) {
526 throw(new RegexException(typeid(e).name(), e.what()));
527 }
528}

◆ __regex_split() [2/2]

StringArray & __regex_split ( const wchar_t * _regex,
const wchar_t * _regexend,
const wchar_t * _begin,
const wchar_t * _end,
bool _icase,
StringArray & _results,
size_t _limit = (size_t) -1 )

Definition at line 452 of file _regex.cpp.

459{
460 regex::flag_type flags = regex::ECMAScript | regex::nosubs;
461 if (_icase) {
462 flags |= regex::icase;
463 }
464
465 try {
466 __DCL_DEBUG_ALLOC_ENTER;
467 wregex re(_regex, _regexend, flags);
468 __DCL_DEBUG_ALLOC_ENTER;
469 wcmatch m;
470 __DCL_DEBUG_ALLOC_ENTER;
471 while (_begin < _end && _limit && regex_search(_begin, _end, m, re)) {
472 __DCL_ASSERT(m.size() > 0);
473 _results.add(String(_begin, m[0].first));
474
475 _limit--;
476 _begin = m[0].second;
477 }
478 __DCL_DEBUG_ALLOC_LEAVE;
479 if (_begin < _end) {
480 _results.add(String(_begin, _end));
481 }
482
483 return _results;
484 }
485 // catch (std::runtime_error& e)
486 catch (std::exception& e) {
487 throw(new RegexException(typeid(e).name(), e.what()));
488 }
489}

◆ __regex_substring() [1/2]

ByteString __regex_substring ( const char * _regex,
const char * _regexend,
const char * _begin,
const char * _end,
bool _icase )

Definition at line 337 of file _regex.cpp.

342{
343 // GNUC BUG!!
344 // regex re(_pattern, regex::extended | (_icase ? regex::icase : 0));
345 regex::flag_type flags = regex::ECMAScript | regex::nosubs;
346 if (_icase) {
347 flags |= regex::icase;
348 }
349
350 ByteString r;
351 try {
352 __DCL_DEBUG_ALLOC_ENTER;
353 regex re(_regex, _regexend, flags);
354 __DCL_DEBUG_ALLOC_ENTER;
355 cmatch m;
356 __DCL_DEBUG_ALLOC_ENTER;
357 __DCL_DEBUG_ALLOC_ENTER;
358 if (regex_search(_begin, _end, m, re)) {
359 r.assign(m[0].first, m[0].second);
360 }
361 __DCL_DEBUG_ALLOC_LEAVE;
362 }
363 // catch (std::runtime_error& e)
364 catch (std::exception& e) {
365 throw(new RegexException(typeid(e).name(), e.what()));
366 }
367 return r;
368}

◆ __regex_substring() [2/2]

String __regex_substring ( const wchar_t * _regex,
const wchar_t * _regexend,
const wchar_t * _begin,
const wchar_t * _end,
bool _icase )

Definition at line 305 of file _regex.cpp.

310{
311 // GNUC BUG!!
312 // regex re(_pattern, regex::extended | (_icase ? regex::icase : 0));
313 regex::flag_type flags = regex::ECMAScript | regex::nosubs;
314 if (_icase) {
315 flags |= regex::icase;
316 }
317
318 String r;
319 try {
320 __DCL_DEBUG_ALLOC_ENTER;
321 wregex re(_regex, _regexend, flags);
322 __DCL_DEBUG_ALLOC_ENTER;
323 wcmatch m;
324 __DCL_DEBUG_ALLOC_ENTER;
325 if (regex_search(_begin, _end, m, re)) {
326 r.assign(m[0].first, m[0].second);
327 }
328 __DCL_DEBUG_ALLOC_LEAVE;
329 }
330 // catch (std::runtime_error& e)
331 catch (std::exception& e) {
332 throw(new RegexException(typeid(e).name(), e.what()));
333 }
334 return r;
335}