#include "dkcRegex.h"
#include "dkutil_cstd/string.h"
#include "dkcStack.h"
dkcRegex.cのインクルード依存関係図
構成 | |
struct | RegLexer_ |
トークンに分解 [詳細] | |
struct | OneRange_ |
struct | RegClass_ |
struct | RegNode_ |
struct | RegParser_ |
構文木作成 [詳細] | |
struct | RegTrans_ |
状態遷移 [詳細] | |
struct | RegNFA_ |
構文木->NFA変換 [詳細] | |
struct | st_ele_ |
マクロ定義 | |
#define | my_lstrlenW dkcstd_wcslen |
#define | my_lstrcpyW dkcstd_wcsncpy |
BOFの可能性あり | |
#define | alloc_RegTrans() malloc_adapter(sizeof(RegTrans)) |
#define | free_RegTrans(p) free_adapter(p) |
型定義 | |
typedef unsigned char | byte |
typedef unsigned short | dbyte |
typedef unsigned long | qbyte |
typedef DKC_UNICODE | unicode |
typedef unsigned char | uchar |
typedef unsigned short | ushort |
typedef unsigned int | uint |
typedef unsigned long | ulong |
typedef RegLexer_ | RegLexer |
トークンに分解 | |
typedef OneRange_ | OneRange |
typedef RegClass_ | RegClass |
typedef RegNode_ | RegNode |
typedef RegParser_ | RegParser |
構文木作成 | |
typedef RegTrans_ | RegTrans |
状態遷移 | |
typedef RegNFA_ | RegNFA |
構文木->NFA変換 | |
typedef st_ele_ | st_ele |
列挙型 | |
enum | { eEpsilon, eClass, eChar } |
only for RegTrans::type; [詳細] | |
関数 | |
static DKC_INLINE unicode | ignore_map (unicode c) |
static DKC_INLINE BOOL | ignore_not_equal (unicode c1, unicode c2) |
static DKC_INLINE void * | malloc_adapter (size_t s) |
static DKC_INLINE void | free_adapter (void *p) |
static DKC_INLINE long | Min (long x, long y) |
static DKC_INLINE long | Max (long x, long y) |
DKC_REPLACE *WINAPI | dkcAllocReplace () |
int WINAPI | dkcFreeReplace (DKC_REPLACE **pp) |
int WINAPI | dkcReplaceRun (const BYTE *src, size_t srcsize, const BYTE *target_data, size_t target_data_size, const BYTE *replace_data, size_t replace_data_size) |
void | RegLexerInit (RegLexer *p, const wchar_t *pat, ulong len) |
static DKC_INLINE int | RegLexerGetTokenImpl (RegLexer *p) |
int | RegLexerGetToken (RegLexer *p) |
wchar_t | RegLexerGetChar (RegLexer *p) |
void | RegClassInit (RegClass *p, wchar_t s, wchar_t e, RegClass *n) |
RegClass * | alloc_RegClass (wchar_t s, wchar_t e, RegClass *n) |
void | free_RegClass (RegClass *p) |
RegNode * | alloc_RegNode () |
void | free_RegNode (RegNode *p) |
RegNode * | RegParser_make_empty_leaf (RegParser *) |
RegNode * | RegParser_make_char_leaf (RegParser *, wchar_t c) |
RegNode * | RegParser_make_node (RegParser *, int t, RegNode *lft, RegNode *rht) |
void | RegParser_eat_token (RegParser *) |
RegNode * | RegParser_expr (RegParser *) |
RegNode * | RegParser_term (RegParser *) |
RegNode * | RegParser_factor (RegParser *) |
RegNode * | RegParser_primary (RegParser *) |
RegNode * | RegParser_reclass (RegParser *) |
void | RegParser_Construct (RegParser *, const unicode *pat) |
RegNode * | RegParser_root (RegParser *p) |
BOOL | RegParser_err (RegParser *p) |
BOOL | RegParser_isHeadType (RegParser *p) |
BOOL | RegParser_isTailType (RegParser *p) |
static DKC_INLINE void | free_RegParser (RegParser *p, RegNode *next) |
void | RegParser_Destruct (RegParser *p) |
BOOL | RegTrans_match_c (RegTrans *pt, wchar_t c) |
BOOL | RegTrans_match_i (RegTrans *pt, wchar_t c) |
BOOL | RegTrans_match (RegTrans *pt, wchar_t c, BOOL caseS) |
BOOL | RegNFA_check_and_push_stack (RegNFA *, int curSt, int pos) |
void | RegNFA_pop_stack (RegNFA *) |
void | RegNFA_add_transition_a4 (RegNFA *, int from, wchar_t ch, int to) |
void | RegNFA_add_transition_a5 (RegNFA *, int from, RegClass *cls, BOOL cmp, int to) |
void | RegNFA_add_e_transition (RegNFA *, int from, int to) |
int | RegNFA_gen_state (RegNFA *) |
void | RegNFA_gen_nfa (RegNFA *, int entry, RegNode *t, int exit) |
BOOL | RegNFA_Construct (RegNFA *, const wchar_t *pat) |
void | RegNFA_Destruct (RegNFA *) |
BOOL | RegNFA_isHeadType (RegNFA *p) |
BOOL | RegNFA_isTailType (RegNFA *p) |
void | RegNFA_match_a3 (RegNFA *, int curSt, int pos) |
int | RegNFA_match_a4 (RegNFA *, const wchar_t *str, int len, BOOL caseS) |
RegNFA * | alloc_RegNFA (const unicode *key) |
void | free_RegNFA (RegNFA *p) |
DKC_REGEX *WINAPI | dkcAllocRegex (const unicode *key, BOOL caseS, BOOL down) |
int WINAPI | dkcFreeRegex (DKC_REGEX **p) |
BOOL WINAPI | dkcRegexSearch (DKC_REGEX *p, const unicode *str, ulong len, ulong stt, ulong *mbg, ulong *med) |
BOOL WINAPI | dkcRegularExpressionSearch (const DKC_UNICODE *key, BOOL caseS, BOOL down, const unicode *str, ulong len, ulong stt, ulong *mbg, ulong *med) |
BOOL WINAPI | dkcRegularExpressionMatch (const DKC_UNICODE *pat, const wchar_t *str, BOOL caseS) |
Gp.Search | |
変数 | |
static int | tmp |
non thread safe ○| ̄|_ |
dkcRegex.c で定義されています。
|
dkcRegex.c の 611 行で定義されています。 参照元 RegNFA_add_e_transition(), と RegNFA_add_transition_a5(). |
|
dkcRegex.c の 612 行で定義されています。 参照元 RegNFA_Destruct(). |
|
BOFの可能性あり
dkcRegex.c の 30 行で定義されています。 |
|
dkcRegex.c の 28 行で定義されています。 |
|
dkcRegex.c の 16 行で定義されています。 |
|
dkcRegex.c の 17 行で定義されています。 |
|
|
|
dkcRegex.c の 18 行で定義されています。 |
|
|
|
トークンに分解 行頭を表す^と行末を表す$については上位層で頑張る |
|
構文木->NFA変換
|
|
|
|
構文木作成
|
|
状態遷移
|
|
|
|
dkcRegex.c の 22 行で定義されています。 |
|
dkcRegex.c の 24 行で定義されています。 |
|
dkcRegex.c の 25 行で定義されています。 |
|
dkcRegex.c の 19 行で定義されています。 |
|
dkcRegex.c の 23 行で定義されています。 |
|
only for RegTrans::type;
dkcRegex.c の 615 行で定義されています。
|
|
dkcRegex.c の 296 行で定義されています。 参照先 malloc_adapter(), と RegClassInit(). 参照元 RegNFA_add_transition_a4(), RegParser_primary(), と RegParser_reclass(). 00296 { 00297 RegClass *p = malloc_adapter(sizeof(RegClass)); 00298 RegClassInit(p,s,e,n); 00299 return p; 00300 }
|
|
dkcRegex.c の 701 行で定義されています。 参照先 dkcAllocate(), dkcFree(), FALSE, NULL, と RegNFA_Construct(). 参照元 dkcAllocRegex(). 00701 { 00702 RegNFA *p = dkcAllocate(sizeof(RegNFA)); 00703 if(NULL==p){ 00704 return NULL; 00705 } 00706 if(FALSE==RegNFA_Construct(p,key)){ 00707 goto Error; 00708 } 00709 return p; 00710 Error: 00711 dkcFree(&p); 00712 return NULL; 00713 }
|
|
dkcRegex.c の 319 行で定義されています。 参照先 malloc_adapter(). 参照元 RegParser_make_char_leaf(), RegParser_make_empty_leaf(), RegParser_make_node(), RegParser_primary(), と RegParser_reclass(). 00319 { 00320 RegNode *p = (RegNode *)malloc_adapter(sizeof(RegNode)); 00321 /*p->left = NULL; 00322 p->right = NULL; 00323 p->cls = NULL;*/ 00324 memset(p,0,sizeof(RegNode)); 00325 00326 return p; 00327 }
|
|
dkcRegex.c の 982 行で定義されています。 参照先 alloc_RegNFA(), dkcRegularExpression::caseS_, dkcAllocate(), dkcRegularExpression::down_, と dkcRegularExpression::re_. 参照元 dkcRegularExpressionSearch(). 00983 { 00984 DKC_REGEX *p = dkcAllocate(sizeof(DKC_REGEX)); 00985 p->re_ = alloc_RegNFA(key); 00986 p->caseS_ = caseS; 00987 p->down_ = down; 00988 return p; 00989 }
|
|
dkcRegex.c の 74 行で定義されています。 参照先 dkcAllocate(), dkcAllocStream(), dkcFree(), dkcFreeStream(), edkcStreamInitMemory, dkc_Replace::mStream, と NULL. 00074 { 00075 00076 DKC_REPLACE *p = dkcAllocate(sizeof(DKC_REPLACE)); 00077 if(NULL==p){ 00078 return NULL; 00079 } 00080 p->mStream = dkcAllocStream(edkcStreamInitMemory,NULL,5012,NULL,NULL); 00081 if(NULL==p->mStream){ 00082 goto Error; 00083 } 00084 return p; 00085 Error: 00086 dkcFreeStream(&(p->mStream)); 00087 dkcFree((void **)&p); 00088 return NULL; 00089 }
|
|
dkcRegex.c の 993 行で定義されています。 参照先 dkcFree(), と free_RegNFA(). 参照元 dkcRegularExpressionSearch(). 00993 { 00994 free_RegNFA((*p)->re_); 00995 return dkcFree(p); 00996 }
|
|
dkcRegex.c の 92 行で定義されています。 参照先 dkcFree(), dkcFreeStream(), と NULL. 00092 { 00093 if(NULL==pp){ 00094 return edk_ArgumentException; 00095 } 00096 dkcFreeStream(&(*pp)->mStream); 00097 return dkcFree((void **)pp); 00098 }
|
|
dkcRegex.c の 998 行で定義されています。 参照先 dkcRegularExpression::caseS_, dkcRegularExpression::down_, FALSE, dkcRegularExpression::re_, RegNFA_isHeadType(), RegNFA_isTailType(), RegNFA_match_a4(), と TRUE. 参照元 dkcRegularExpressionSearch(). 01000 { 01001 /* 01002 const int d; 01003 int s; 01004 const int e;*/ 01005 if( p->down_ && RegNFA_isHeadType(p->re_) && stt>0 ) 01006 return FALSE; 01007 { 01008 01009 const int d = (p->down_ ? 1 : -1); 01010 int s = (!p->down_ && RegNFA_isHeadType(p->re_) ? 0 : stt); 01011 const int e = (p->down_ ? (RegNFA_isHeadType(p->re_) ? 1 : len) : -1); 01012 01013 for( ; s!=e; s+=d ) 01014 { 01015 //const int L = re_->match( str+s, len-s, caseS_ ); 01016 int L = RegNFA_match_a4( p->re_,str+s, len-s, p->caseS_ ); 01017 if( L > 0 ) 01018 { 01019 if( RegNFA_isTailType(p->re_) && L!=(int)(len-s) ) 01020 continue; 01021 *mbg = (ulong)(s); 01022 *med = (ulong)(s+L); 01023 return TRUE; 01024 } 01025 } 01026 } 01027 01028 return FALSE; 01029 }
|
|
Gp.Search 超簡易正規表現マッチング関数。 patとstr全体がマッチするならtrue、ダメならfalseを返す dkcRegex.c の 1062 行で定義されています。 参照先 FALSE, my_lstrlenW, RegNFA_Construct(), RegNFA_Destruct(), と RegNFA_match_a4(). 01063 { 01064 int len = my_lstrlenW(str); 01065 RegNFA re; 01066 BOOL r; 01067 if(FALSE==RegNFA_Construct(&re,pat)) 01068 return FALSE; 01069 01070 r = (len == RegNFA_match_a4(&re, str, len, caseS )); 01071 01072 RegNFA_Destruct(&re); 01073 01074 return r; 01075 }
|
|
dkcRegex.c の 1032 行で定義されています。 参照先 dkcAllocRegex(), dkcFreeRegex(), dkcRegexSearch(), FALSE, と NULL. 01033 { 01034 DKC_REGEX *p; 01035 BOOL r; 01036 01037 p = dkcAllocRegex(key,caseS,down); 01038 if(NULL==p) 01039 return FALSE; 01040 01041 r = dkcRegexSearch(p,str,len,stt,mbg,med); 01042 /*if(FALSE==r) 01043 return FALSE;*/ 01044 01045 dkcFreeRegex(&p); 01046 return r; 01047 01048 01049 }
|
|
dkcRegex.c の 101 行で定義されています。
|
|
dkcRegex.c の 64 行で定義されています。 参照先 dkcFree(). 参照元 free_RegClass(), と free_RegNode(). 00064 { 00065 //free(p); 00066 dkcFree(&p); 00067 }
|
|
dkcRegex.c の 302 行で定義されています。 参照先 free_adapter(). 参照元 free_RegNode(). 00302 { 00303 free_adapter(p); 00304 }
|
|
dkcRegex.c の 715 行で定義されています。 参照先 dkcFree(), と RegNFA_Destruct(). 参照元 dkcFreeRegex(). 00715 { 00716 RegNFA_Destruct(p); 00717 dkcFree(&p); 00718 }
|
|
dkcRegex.c の 328 行で定義されています。 参照先 RegNode_::cls, free_adapter(), と free_RegClass(). 参照元 free_RegParser(). 00328 { 00329 if(p->cls){ 00330 free_RegClass(p->cls); 00331 } 00332 free_adapter(p); 00333 }
|
|
dkcRegex.c の 398 行で定義されています。 参照先 free_RegNode(), RegNode_::left, と RegNode_::right. 参照元 RegParser_Destruct(). 00398 { 00399 if(next->left){ 00400 free_RegParser(p,next->left); 00401 } 00402 if(next->right){ 00403 free_RegParser(p,next->right); 00404 } 00405 free_RegNode(next); 00406 }
|
|
dkcRegex.c の 51 行で定義されています。 参照元 ignore_not_equal(), と RegTrans_match_i(). 00052 { 00053 return (unicode)(L'a'<=c && c<=L'z' ? c-L'a'+L'A' : c); 00054 }
|
|
dkcRegex.c の 55 行で定義されています。 参照先 ignore_map(). 00056 { 00057 return ignore_map(c1)!=ignore_map(c2); 00058 }
|
|
dkcRegex.c の 59 行で定義されています。 参照先 dkcAllocateFast(). 参照元 alloc_RegClass(), と alloc_RegNode(). 00059 { 00060 //return malloc(s); 00061 void *p=dkcAllocateFast(s); 00062 return p; 00063 }
|
|
dkcRegex.c の 72 行で定義されています。 参照元 RegParser_reclass().
|
|
dkcRegex.c の 71 行で定義されています。 参照元 RegParser_reclass().
|
|
dkcRegex.c の 289 行で定義されています。 参照先 OneRange_::end, RegClass_::next, RegClass_::range, と OneRange_::stt. 参照元 alloc_RegClass().
|
|
dkcRegex.c の 270 行で定義されています。 参照先 RegLexer_::chr_. 参照元 RegParser_primary(), と RegParser_reclass(). 00270 { 00271 return p->chr_; 00272 }
|
|
dkcRegex.c の 230 行で定義されています。 00231 { 00232 return RegLexerGetTokenImpl(p); 00233 //d金魚改:ここをC言語で表現するのは骨が折れる… 00234 //const wchar_t*& x = (*p->sub_ ? p->sub_ : p->pat_); 00235 /* 00236 const wchar_t* x = (*p->sub_ ? p->sub_ : p->pat_); 00237 if( x == p->end_ ) return R_End; 00238 switch( *x++ ) 00239 { 00240 case L'.': return R_Any; 00241 case L'[': return R_Lcl; 00242 case L']': return R_Rcl; 00243 case L'^': return R_Ncl; 00244 case L'-': return R_Range; 00245 case L'(': return R_Lbr; 00246 case L')': return R_Rbr; 00247 case L'|': return R_Bar; 00248 case L'*': return R_Star; 00249 case L'+': return R_Plus; 00250 case L'?': return R_Quest; 00251 case L'\\': 00252 if( x==p->end_ ) return R_End; 00253 switch( *x++ ) 00254 { 00255 case L't': p->chr_=L'\t'; return R_Char; 00256 case L'w': p->sub_=L"[0-9a-zA-Z_]"; return RegLexerGetToken(p); 00257 case L'W': p->sub_=L"[^0-9a-zA-Z_]"; return RegLexerGetToken(p); 00258 case L'd': p->sub_=L"[0-9]"; return RegLexerGetToken(p); 00259 case L'D': p->sub_=L"[^0-9]"; return RegLexerGetToken(p); 00260 case L's': p->sub_=L"[\t ]"; return RegLexerGetToken(p); 00261 case L'S': p->sub_=L"[^\t ]"; return RegLexerGetToken(p); 00262 } // fall through... 00263 default: 00264 p->chr_ = *(x-1); 00265 return R_Char; 00266 } 00267 */ 00268 00269 }
|
|
dkcRegex.c の 161 行で定義されています。 参照先 RegLexer_::chr_, dkcmFORCE_NOT_ASSERT, RegLexer_::end_, RegLexer_::pat_, R_Any, R_Bar, R_Char, R_End, R_Lbr, R_Lcl, R_Ncl, R_Plus, R_Quest, R_Range, R_Rbr, R_Rcl, R_Star, と RegLexer_::sub_. 参照元 RegLexerGetToken(). 00161 { 00162 00163 //const wchar_t* x = (*p->sub_ ? p->sub_ : p->pat_); 00164 const wchar_t *x = L"\0"; 00165 int r = R_Char; 00166 if( p->sub_ == p->end_ ) 00167 { r = R_End; goto End;} 00168 00169 if(*p->sub_) 00170 x = p->sub_; 00171 else 00172 x = p->pat_; 00173 00174 dkcmFORCE_NOT_ASSERT(x > p->end_); 00175 00176 switch( *x++ ) 00177 { 00178 case L'.': 00179 r = R_Any;break; 00180 case L'[': 00181 r = R_Lcl;break; 00182 case L']': 00183 r = R_Rcl;break; 00184 case L'^': 00185 r = R_Ncl;break; 00186 case L'-': 00187 r = R_Range;break; 00188 case L'(': 00189 r = R_Lbr;break; 00190 case L')': 00191 r = R_Rbr;break; 00192 case L'|': 00193 r = R_Bar;break; 00194 case L'*': 00195 r = R_Star;break; 00196 case L'+': 00197 r = R_Plus;break; 00198 case L'?': 00199 r = R_Quest;break; 00200 case L'\\': 00201 if( x==p->end_ ){ r = R_End;break;} 00202 switch( *x++ ) 00203 { 00204 case L't': p->chr_=L'\t'; 00205 r = R_Char;break; 00206 case L'w': p->sub_=L"[0-9a-zA-Z_]"; 00207 r = RegLexerGetTokenImpl(p);break; 00208 case L'W': p->sub_=L"[^0-9a-zA-Z_]"; 00209 r = RegLexerGetTokenImpl(p);break; 00210 case L'd': p->sub_=L"[0-9]"; 00211 r = RegLexerGetTokenImpl(p);break; 00212 case L'D': p->sub_=L"[^0-9]"; 00213 r = RegLexerGetTokenImpl(p);break; 00214 case L's': p->sub_=L"[\t ]"; 00215 r = RegLexerGetTokenImpl(p);break; 00216 case L'S': p->sub_=L"[^\t ]"; 00217 r = RegLexerGetTokenImpl(p);break; 00218 } // fall through... 00219 default: 00220 p->chr_ = *(x-1); 00221 r = R_Char; 00222 } 00223 End: 00224 //update 00225 p->sub_ = x; 00226 return r; 00227 00228 }
|
|
dkcRegex.c の 153 行で定義されています。 参照先 RegLexer_::end_, RegLexer_::pat_, と RegLexer_::sub_. 00154 { 00155 //memset(p,0,sizeof(*p)); 00156 p->pat_ = pat; 00157 p->end_ = pat + len; 00158 p->sub_ = L""; 00159 }
|
|
dkcRegex.c の 782 行で定義されています。 参照先 alloc_RegTrans, dkcStackPointer(), eEpsilon, RegTrans_::next, RegNFA_::st, RegTrans_::to, と RegTrans_::type. 参照元 RegNFA_gen_nfa(). 00783 { 00784 RegTrans **t; 00785 //RegTrans* x = new RegTrans; 00786 RegTrans* x = alloc_RegTrans(); 00787 //x->next = aptr<RegTrans>( st[from] ); 00788 00789 t = (RegTrans **)dkcStackPointer(p->st); 00790 x->next = t[from]; 00791 x->to = to; 00792 x->type = eEpsilon; 00793 t[from] = x; 00794 }
|
|
dkcRegex.c の 775 行で定義されています。 参照先 alloc_RegClass(), FALSE, NULL, と RegNFA_add_transition_a5(). 参照元 RegNFA_gen_nfa(). 00776 { 00777 RegNFA_add_transition_a5( p,from, 00778 alloc_RegClass(ch,ch,NULL), 00779 FALSE, to ); 00780 }
|
|
dkcRegex.c の 758 行で定義されています。 参照先 alloc_RegTrans, RegTrans_::cls, RegTrans_::cmpcls, dkcStackPointer(), eClass, RegTrans_::next, RegNFA_::st, RegTrans_::to, と RegTrans_::type. 参照元 RegNFA_add_transition_a4(), と RegNFA_gen_nfa(). 00759 { 00760 RegTrans **t; 00761 //RegTrans* x = new RegTrans; 00762 RegTrans *x=alloc_RegTrans(); 00763 00764 //x->next = aptr<RegTrans>( p->st[from] ); 00765 t = (RegTrans **)dkcStackPointer(p->st); 00766 00767 x->next = t[from]; 00768 x->to = to; 00769 x->type = eClass;//type.eClass; 00770 x->cls = cls; 00771 x->cmpcls= cmp; 00772 t[from] = x; 00773 }
|
|
dkcRegex.c の 877 行で定義されています。 参照先 dkcStackDynamicPush(), dkcStackPointer(), dkcStackSize(), FALSE, st_ele_::ps, RegNFA_::pstack, st_ele_::st, と TRUE. 参照元 RegNFA_match_a3(). 00878 { 00879 /*for( int i=stack_.size()-1; i>=0; --i ) 00880 if( stack_[i].ps != pos ) 00881 break; 00882 else if( stack_[i].st == curSt ) 00883 return FALSE; 00884 00885 st_ele nw = {curSt,pos}; 00886 stack_.Add( nw ); 00887 return TRUE; 00888 */ 00889 int i; 00890 st_ele *pt; 00891 st_ele nw; 00892 00893 00894 i = (int)(dkcStackSize(p->pstack) - 1); 00895 pt = dkcStackPointer(p->pstack); 00896 00897 for(;i >= 0;--i){ 00898 if( pt[i].ps != pos ) 00899 break; 00900 else if( pt[i].st == curSt ) 00901 return FALSE; 00902 } 00903 nw.st = curSt; 00904 nw.ps = pos; 00905 dkcStackDynamicPush(p->pstack, &nw ); 00906 return TRUE; 00907 }
|
|
dkcRegex.c の 720 行で定義されています。 参照先 dkcAllocStack(), dkcFreeStack(), FALSE, RegNFA_::final, NULL, RegNFA_::parser, RegNFA_::pstack, RegNFA_gen_nfa(), RegNFA_gen_state(), RegParser_Construct(), RegParser_root(), RegNFA_::st, RegNFA_::start, と TRUE. 参照元 alloc_RegNFA(), と dkcRegularExpressionMatch(). 00721 { 00722 00723 p->pstack = dkcAllocStack(10,sizeof(st_ele)); 00724 if(NULL==p->pstack){ 00725 return FALSE; 00726 } 00727 p->st = dkcAllocStack(10,sizeof(RegTrans *)); 00728 if(NULL==p->st) 00729 goto Error; 00730 00731 RegParser_Construct( &p->parser,pat ); 00732 00733 p->start = RegNFA_gen_state(p); 00734 p->final = RegNFA_gen_state(p); 00735 RegNFA_gen_nfa( p,p->start, RegParser_root(&p->parser), p->final ); 00736 return TRUE; 00737 Error: 00738 dkcFreeStack(&p->pstack); 00739 return FALSE; 00740 }
|
|
dkcRegex.c の 742 行で定義されています。 参照先 dkcFreeStack(), dkcStackPop(), dkcStackSize(), dkcStackTop(), free_RegTrans, RegNFA_::parser, RegNFA_::pstack, RegParser_Destruct(), と RegNFA_::st. 参照元 dkcRegularExpressionMatch(), と free_RegNFA(). 00743 { 00744 RegTrans *t; 00745 ulong i=0; 00746 ulong e = dkcStackSize(p->st); 00747 00748 for(;i<e;i++){//ここにバグがあるかも? 00749 dkcStackTop(p->st,(void *)&t); 00750 free_RegTrans(t); 00751 dkcStackPop(p->st); 00752 } 00753 RegParser_Destruct(&p->parser); 00754 dkcFreeStack(&p->st); 00755 dkcFreeStack(&p->pstack); 00756 }
|
|
dkcRegex.c の 803 行で定義されています。 参照先 RegNode_::ch, RegNode_::cls, RegNode_::cmpcls, RegNode_::left, N_01, N_Char, N_Class, N_Closure, N_Closure1, N_Concat, N_Empty, N_Or, RegNFA_add_e_transition(), RegNFA_add_transition_a4(), RegNFA_add_transition_a5(), RegNFA_gen_state(), RegNode_::right, と RegNode_::type. 参照元 RegNFA_Construct(). 00804 { 00805 switch( t->type ) 00806 { 00807 case N_Char: 00808 // ch 00809 // entry ----> exit 00810 RegNFA_add_transition_a4( p,entry, t->ch, exit ); 00811 break; 00812 case N_Class: 00813 // cls 00814 // entry -----> exit 00815 RegNFA_add_transition_a5( p,entry, t->cls, t->cmpcls, exit ); 00816 break; 00817 case N_Concat: { 00818 // left right 00819 // entry ------> step -------> exit 00820 int step = RegNFA_gen_state(p); 00821 RegNFA_gen_nfa(p, entry, t->left, step ); 00822 RegNFA_gen_nfa(p, step, t->right, exit ); 00823 } break; 00824 case N_Or: 00825 // left 00826 // ------> 00827 // entry ------->--> exit 00828 // right 00829 RegNFA_gen_nfa(p, entry, t->left, exit ); 00830 RegNFA_gen_nfa(p, entry, t->right, exit ); 00831 break; 00832 case N_Closure: 00833 // e 00834 // e <------ e 00835 // entry ---> before ------> after ---> exit 00836 // | left ^ 00837 // >------->------------------->------>-| 00838 // e 00839 case N_Closure1: { 00840 // e 00841 // e <------ e 00842 // entry ---> before ------> after ---> exit 00843 // left 00844 int before = RegNFA_gen_state(p); 00845 int after = RegNFA_gen_state(p); 00846 RegNFA_add_e_transition(p, entry, before ); 00847 RegNFA_add_e_transition(p, after, exit ); 00848 RegNFA_add_e_transition(p, after, before ); 00849 RegNFA_gen_nfa(p, before, t->left, after ); 00850 if( t->type != N_Closure1 ) 00851 RegNFA_add_e_transition(p, entry, exit ); 00852 } break; 00853 case N_01: 00854 // e 00855 // ------> 00856 // entry ------> exit 00857 // left 00858 RegNFA_add_e_transition(p, entry, exit ); 00859 RegNFA_gen_nfa(p, entry, t->left, exit ); 00860 break; 00861 case N_Empty: 00862 // e 00863 // entry ---> exit 00864 RegNFA_add_e_transition(p, entry, exit ); 00865 break; 00866 } 00867 }
|
|
dkcRegex.c の 796 行で定義されています。 参照先 dkcStackDynamicPush(), dkcStackSize(), NULL, と RegNFA_::st. 参照元 RegNFA_Construct(), と RegNFA_gen_nfa(). 00797 { 00798 RegTrans *temp = NULL; 00799 dkcStackDynamicPush(p->st,(void *)&temp); 00800 return dkcStackSize(p->st) - 1; 00801 }
|
|
dkcRegex.c の 690 行で定義されています。 参照先 RegNFA_::parser, と RegParser_isHeadType(). 参照元 dkcRegexSearch(). 00690 { 00691 return RegParser_isHeadType(&p->parser); 00692 }
|
|
dkcRegex.c の 693 行で定義されています。 参照先 RegNFA_::parser, と RegParser_isTailType(). 参照元 dkcRegexSearch(). 00693 { 00694 return RegParser_isTailType(&p->parser); 00695 }
|
|
dkcRegex.c の 936 行で定義されています。 参照先 RegNFA_::caseS_, dkcStackPointer(), eEpsilon, RegNFA_::len_, RegNFA_::matchpos_, RegTrans_::next, NULL, RegNFA_check_and_push_stack(), RegNFA_pop_stack(), RegTrans_match(), RegNFA_::st, RegNFA_::str_, RegTrans_::to, と RegTrans_::type. 参照元 RegNFA_match_a4(). 00937 { 00938 if( curSt == 1 ) // 1==終状態 00939 { 00940 // マッチ成功を記録 00941 if( p->matchpos_ < pos ) 00942 p->matchpos_ = pos; 00943 } 00944 00945 if( p->matchpos_ < p->len_ ) 00946 { 00947 RegTrans* tr; 00948 RegTrans **sst; 00949 sst = (RegTrans **)dkcStackPointer(p->st); 00950 00951 tr=sst[curSt]; 00952 for( ; tr!=NULL; tr=tr->next ) 00953 { 00954 if( tr->type == eEpsilon ) 00955 { 00956 // ε無限ループを防止策。同じ状態には戻らないように… 00957 if( RegNFA_check_and_push_stack(p,tr->to, pos) ) 00958 { 00959 RegNFA_match_a3(p, tr->to, pos ); 00960 RegNFA_pop_stack(p); 00961 } 00962 } 00963 //else if( pos<len_ && tr->match( str_[pos], caseS_ ) ) 00964 else if(pos<p->len_ && RegTrans_match(tr, p->str_[pos], p->caseS_ ) ) 00965 { 00966 if( p->str_[pos] == L'i' ) 00967 p->str_ = p->str_; 00968 RegNFA_match_a3(p, tr->to, pos+1 ); 00969 } 00970 } 00971 } 00972 }
|
|
dkcRegex.c の 916 行で定義されています。 参照先 RegNFA_::caseS_, dkcStackDynamicPush(), RegNFA_::len_, RegNFA_::matchpos_, RegNFA_::parser, RegNFA_::pstack, RegNFA_match_a3(), RegParser_err(), と RegNFA_::str_. 参照元 dkcRegexSearch(), と dkcRegularExpressionMatch(). 00917 { 00918 00919 if( RegParser_err(&p->parser) ) 00920 return -1; // エラー 00921 00922 p->matchpos_ = -1; 00923 p->caseS_ = caseS; 00924 p->str_ = str; 00925 p->len_ = len; // 作業変数にコピー 00926 00927 { 00928 st_ele nw = {0,0}; 00929 dkcStackDynamicPush(p->pstack, &nw ); 00930 RegNFA_match_a3(p, 0, 0 ); // 0:始状態 00931 } 00932 return p->matchpos_ ; 00933 }
|
|
dkcRegex.c の 909 行で定義されています。 参照先 dkcStackPop(), と RegNFA_::pstack. 参照元 RegNFA_match_a3(). 00910 { 00911 //stack_.ForceSize( stack_.size()-1 ); 00912 dkcStackPop(p->pstack); 00913 }
|
|
dkcRegex.c の 377 行で定義されています。 参照先 RegParser_::err_, FALSE, RegParser_::isHeadType_, RegParser_::isTailType_, RegParser_::lex_, my_lstrlenW, RegLexerInit(), RegParser_eat_token(), RegParser_expr(), RegParser_::root_, と tmp. 参照元 RegNFA_Construct(). 00380 { 00381 p->err_ = FALSE; 00382 p->isHeadType_ = (*pat==L'^'); 00383 00384 tmp=my_lstrlenW(pat); 00385 00386 p->isTailType_ = ( tmp && pat[tmp-1]==L'$' ); 00387 00388 RegLexerInit(&p->lex_, 00389 (p->isHeadType_ ? pat+1 : pat), 00390 (my_lstrlenW(pat) - (p->isHeadType_ ? 1 : 0) 00391 - (p->isTailType_ ? 1 : 0)) 00392 ); 00393 00394 RegParser_eat_token(p); 00395 p->root_ = RegParser_expr(p); 00396 }
|
|
dkcRegex.c の 407 行で定義されています。 参照先 free_RegParser(), と RegParser_::root_. 参照元 RegNFA_Destruct(). 00407 { 00408 free_RegParser(p,p->root_); 00409 }
|
|
dkcRegex.c の 411 行で定義されています。 参照先 RegParser_::lex_, RegParser_::nextToken_, と RegLexerGetToken(). 参照元 RegParser_Construct(), RegParser_expr(), RegParser_factor(), RegParser_primary(), と RegParser_reclass(). 00412 { 00413 //p->nextToken_ = p->lex_.GetToken(); 00414 p->nextToken_ = RegLexerGetToken(&p->lex_); 00415 }
|
|
dkcRegex.c の 362 行で定義されています。 参照先 RegParser_::err_. 参照元 RegNFA_match_a4(). 00362 { return p->err_; }
|
|
dkcRegex.c の 580 行で定義されています。 参照先 N_Or, RegParser_::nextToken_, R_Bar, RegParser_eat_token(), RegParser_make_node(), と RegParser_term(). 参照元 RegParser_Construct(), と RegParser_primary(). 00581 { 00582 // REGEXP ::= TERM 00583 // TERM '|' REGEXP 00584 00585 RegNode* node = RegParser_term(p); 00586 if( p->nextToken_ == R_Bar ) 00587 { 00588 RegParser_eat_token(p); 00589 node = RegParser_make_node(p, N_Or, node, RegParser_expr(p) ); 00590 } 00591 return node; 00592 }
|
|
dkcRegex.c の 538 行で定義されています。 参照先 N_01, N_Closure, N_Closure1, RegParser_::nextToken_, NULL, R_Plus, R_Quest, R_Star, RegParser_eat_token(), RegParser_make_node(), と RegParser_primary(). 参照元 RegParser_term(). 00539 { 00540 // FACTOR ::= PRIMARY 00541 // PRIMARY '*' 00542 // PRIMARY '+' 00543 // PRIMARY '?' 00544 00545 RegNode* node = RegParser_primary(p); 00546 switch( p->nextToken_ ) 00547 { 00548 case R_Star: 00549 node=RegParser_make_node(p,N_Closure,node,NULL); 00550 RegParser_eat_token(p); 00551 break; 00552 case R_Plus: 00553 node=RegParser_make_node(p,N_Closure1,node,NULL); 00554 RegParser_eat_token(p); 00555 break; 00556 case R_Quest: 00557 node=RegParser_make_node(p,N_01,node,NULL ); 00558 RegParser_eat_token(p); 00559 break; 00560 } 00561 //RegParser_eat_token(p); 00562 return node; 00563 }
|
|
dkcRegex.c の 363 行で定義されています。 参照元 RegNFA_isHeadType(). 00363 { return p->isHeadType_; }
|
|
dkcRegex.c の 364 行で定義されています。 参照元 RegNFA_isTailType(). 00364 { return p->isTailType_; }
|
|
dkcRegex.c の 425 行で定義されています。 参照先 alloc_RegNode(), RegNode_::ch, N_Char, と RegNode_::type. 参照元 RegParser_primary(). 00426 { 00427 //RegNode* node = new RegNode; 00428 RegNode *node = alloc_RegNode(); 00429 node->type = N_Char; 00430 node->ch = c; 00431 return node; 00432 }
|
|
dkcRegex.c の 417 行で定義されています。 参照先 alloc_RegNode(), N_Empty, と RegNode_::type. 参照元 RegParser_primary(), と RegParser_term(). 00418 { 00419 //RegNode* node = new RegNode; 00420 RegNode *node = alloc_RegNode(); 00421 node->type = N_Empty; 00422 return node; 00423 }
|
|
dkcRegex.c の 434 行で定義されています。 参照先 alloc_RegNode(), RegNode_::left, RegNode_::right, と RegNode_::type. 参照元 RegParser_expr(), RegParser_factor(), と RegParser_term(). 00435 { 00436 //RegNode* node = new RegNode; 00437 RegNode *node = alloc_RegNode(); 00438 node->type = t; 00439 node->left = lft; 00440 node->right= rht; 00441 return node; 00442 }
|
|
dkcRegex.c の 491 行で定義されています。 参照先 alloc_RegClass(), alloc_RegNode(), RegNode_::cls, RegNode_::cmpcls, RegParser_::err_, FALSE, RegParser_::lex_, N_Class, RegParser_::nextToken_, NULL, R_Any, R_Char, R_Lbr, R_Lcl, R_Rbr, R_Rcl, RegLexerGetChar(), RegParser_eat_token(), RegParser_expr(), RegParser_make_char_leaf(), RegParser_make_empty_leaf(), RegParser_reclass(), TRUE, と RegNode_::type. 参照元 RegParser_factor(). 00492 { 00493 // PRIMARY ::= CHAR 00494 // '.' 00495 // '[' CLASS ']' 00496 // '(' REGEXP ')' 00497 00498 RegNode* node; 00499 switch( p->nextToken_ ) 00500 { 00501 case R_Char: 00502 node = RegParser_make_char_leaf( p,RegLexerGetChar(&p->lex_) ); 00503 RegParser_eat_token(p); 00504 break; 00505 case R_Any: 00506 //node = new RegNode; 00507 node = alloc_RegNode(); 00508 node->type = N_Class; 00509 //node->cls = aptr<RegClass>(new RegClass( 0, 65535, NULL )); 00510 node->cls = alloc_RegClass(0, 65535, NULL); 00511 node->cmpcls = FALSE; 00512 RegParser_eat_token(p); 00513 break; 00514 case R_Lcl: 00515 RegParser_eat_token(p); 00516 node = RegParser_reclass(p); 00517 if( p->nextToken_ == R_Rcl ) 00518 RegParser_eat_token(p); 00519 else 00520 p->err_ = TRUE; 00521 break; 00522 case R_Lbr: 00523 RegParser_eat_token(p); 00524 node = RegParser_expr(p); 00525 if( p->nextToken_ == R_Rbr ) 00526 RegParser_eat_token(p); 00527 else 00528 p->err_ = TRUE; 00529 break; 00530 default: 00531 node = RegParser_make_empty_leaf(p); 00532 p->err_ = TRUE; 00533 break; 00534 } 00535 return node; 00536 }
|
|
dkcRegex.c の 444 行で定義されています。 参照先 alloc_RegClass(), alloc_RegNode(), RegNode_::cls, RegNode_::cmpcls, RegParser_::err_, FALSE, RegParser_::lex_, Max(), Min(), N_Class, RegParser_::nextToken_, NULL, R_Char, R_Ncl, R_Range, RegLexerGetChar(), RegParser_eat_token(), TRUE, と RegNode_::type. 参照元 RegParser_primary(). 00445 { 00446 // CLASS ::= '^'? CHAR (CHAR | -CHAR)* 00447 00448 BOOL neg = FALSE; 00449 RegNode* node; 00450 RegClass* cls; 00451 00452 if( p->nextToken_ == R_Ncl ){ 00453 neg=TRUE; 00454 RegParser_eat_token(p); 00455 } 00456 00457 cls = NULL; 00458 while( p->nextToken_ == R_Char ) 00459 { 00460 //wchar_t ch = p->lex_.GetChar(); 00461 wchar_t ch = RegLexerGetChar(&p->lex_); 00462 RegParser_eat_token(p); 00463 if( p->nextToken_ == R_Range ) 00464 { 00465 RegParser_eat_token(p); 00466 if( p->nextToken_ != R_Char ) 00467 p->err_ = TRUE; 00468 else 00469 { 00470 wchar_t ch2 = RegLexerGetChar(&p->lex_); 00471 //cls = new RegClass( Min(ch,ch2), Max(ch,ch2), cls ); 00472 cls = alloc_RegClass((unicode)Min(ch,ch2),(unicode) Max(ch,ch2), cls); 00473 RegParser_eat_token(p); 00474 } 00475 } 00476 else 00477 { 00478 //cls = new RegClass( ch, ch, cls ); 00479 cls = alloc_RegClass( ch, ch, cls ); 00480 } 00481 } 00482 00483 //RegNode* node = new RegNode; 00484 node = alloc_RegNode(); 00485 node->type = N_Class; 00486 node->cls = cls;//aptr<RegClass>(cls); 00487 node->cmpcls = neg; 00488 return node; 00489 }
|
|
dkcRegex.c の 361 行で定義されています。 参照先 RegParser_::root_. 参照元 RegNFA_Construct(). 00361 { return p->root_; }
|
|
dkcRegex.c の 565 行で定義されています。 参照先 N_Concat, RegParser_::nextToken_, R_Any, R_Char, R_End, R_Lbr, R_Lcl, RegParser_factor(), RegParser_make_empty_leaf(), と RegParser_make_node(). 参照元 RegParser_expr(). 00566 { 00567 // TERM ::= EMPTY 00568 // FACTOR TERM 00569 RegNode* node; 00570 if( p->nextToken_ == R_End ) 00571 return RegParser_make_empty_leaf(p); 00572 00573 node = RegParser_factor(p); 00574 if( p->nextToken_==R_Lbr || p->nextToken_==R_Lcl 00575 || p->nextToken_==R_Char|| p->nextToken_==R_Any ) 00576 node = RegParser_make_node(p, N_Concat, node, RegParser_term(p) ); 00577 return node; 00578 }
|
|
dkcRegex.c の 642 行で定義されています。 参照先 RegTrans_::cmpcls, RegTrans_match_c(), と RegTrans_match_i(). 参照元 RegNFA_match_a3(). 00643 { 00644 BOOL m = caseS ? RegTrans_match_c(pt, c ) : RegTrans_match_i(pt, c ); 00645 return pt->cmpcls ? !m : m; 00646 }
|
|
dkcRegex.c の 622 行で定義されています。 参照先 RegTrans_::cls, OneRange_::end, FALSE, RegClass_::next, RegClass_::range, OneRange_::stt, と TRUE. 参照元 RegTrans_match(). 00623 { 00624 RegClass* p = pt->cls; 00625 for( ; p; p=p->next ) 00626 if( p->range.stt<=c && c<=p->range.end ) 00627 return TRUE; 00628 return FALSE; 00629 }
|
|
dkcRegex.c の 631 行で定義されています。 参照先 RegTrans_::cls, OneRange_::end, FALSE, ignore_map(), RegClass_::next, RegClass_::range, OneRange_::stt, と TRUE. 参照元 RegTrans_match(). 00632 { 00633 RegClass* p; 00634 c = ignore_map(c); 00635 for( p=pt->cls; p; p=p->next ) 00636 if( ignore_map(p->range.stt)<=c 00637 && c<=ignore_map(p->range.end) ) 00638 return TRUE; 00639 return FALSE; 00640 }
|
|
non thread safe ○| ̄|_
dkcRegex.c の 373 行で定義されています。 参照元 dkcSemiRealRandomGet32(), RegParser_Construct(), st_delete(), と st_foreach(). |