メインページ | アルファベット順一覧 | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

dkcRegex.c

Regex [詳細]

#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)
RegClassalloc_RegClass (wchar_t s, wchar_t e, RegClass *n)
void free_RegClass (RegClass *p)
RegNodealloc_RegNode ()
void free_RegNode (RegNode *p)
RegNodeRegParser_make_empty_leaf (RegParser *)
RegNodeRegParser_make_char_leaf (RegParser *, wchar_t c)
RegNodeRegParser_make_node (RegParser *, int t, RegNode *lft, RegNode *rht)
void RegParser_eat_token (RegParser *)
RegNodeRegParser_expr (RegParser *)
RegNodeRegParser_term (RegParser *)
RegNodeRegParser_factor (RegParser *)
RegNodeRegParser_primary (RegParser *)
RegNodeRegParser_reclass (RegParser *)
void RegParser_Construct (RegParser *, const unicode *pat)
RegNodeRegParser_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)
RegNFAalloc_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 ○| ̄|_


説明

Regex

作者:
d金魚
から:
2004/09/01

dkcRegex.c で定義されています。


マクロ定義

 
#define alloc_RegTrans  )     malloc_adapter(sizeof(RegTrans))
 

dkcRegex.c611 行で定義されています。

参照元 RegNFA_add_e_transition(), と RegNFA_add_transition_a5().

#define free_RegTrans  )     free_adapter(p)
 

dkcRegex.c612 行で定義されています。

参照元 RegNFA_Destruct().

#define my_lstrcpyW   dkcstd_wcsncpy
 

BOFの可能性あり

dkcRegex.c30 行で定義されています。

#define my_lstrlenW   dkcstd_wcslen
 

dkcRegex.c28 行で定義されています。

参照元 dkcRegularExpressionMatch(), と RegParser_Construct().


型定義

typedef unsigned char byte
 

dkcRegex.c16 行で定義されています。

typedef unsigned short dbyte
 

dkcRegex.c17 行で定義されています。

typedef struct OneRange_ OneRange
 

typedef unsigned long qbyte
 

dkcRegex.c18 行で定義されています。

typedef struct RegClass_ RegClass
 

typedef struct RegLexer_ RegLexer
 

トークンに分解

行頭を表す^と行末を表す$については上位層で頑張る

typedef struct RegNFA_ RegNFA
 

構文木->NFA変換

typedef struct RegNode_ RegNode
 

typedef struct RegParser_ RegParser
 

構文木作成

typedef struct RegTrans_ RegTrans
 

状態遷移

typedef struct st_ele_ st_ele
 

typedef unsigned char uchar
 

dkcRegex.c22 行で定義されています。

typedef unsigned int uint
 

dkcRegex.c24 行で定義されています。

typedef unsigned long ulong
 

dkcRegex.c25 行で定義されています。

typedef DKC_UNICODE unicode
 

dkcRegex.c19 行で定義されています。

typedef unsigned short ushort
 

dkcRegex.c23 行で定義されています。


列挙型

anonymous enum
 

only for RegTrans::type;

列挙型の値:
eEpsilon 
eClass 
eChar 

dkcRegex.c615 行で定義されています。

00615      {
00616     eEpsilon,
00617     eClass,
00618     eChar,
00619 };


関数

RegClass* alloc_RegClass wchar_t  s,
wchar_t  e,
RegClass n
 

dkcRegex.c296 行で定義されています。

参照先 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 }

RegNFA* alloc_RegNFA const unicode key  ) 
 

dkcRegex.c701 行で定義されています。

参照先 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 }

RegNode* alloc_RegNode  ) 
 

dkcRegex.c319 行で定義されています。

参照先 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 }

DKC_REGEX* WINAPI dkcAllocRegex const unicode key,
BOOL  caseS,
BOOL  down
 

dkcRegex.c982 行で定義されています。

参照先 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 }

DKC_REPLACE* WINAPI dkcAllocReplace  ) 
 

dkcRegex.c74 行で定義されています。

参照先 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 }

int WINAPI dkcFreeRegex DKC_REGEX **  p  ) 
 

dkcRegex.c993 行で定義されています。

参照先 dkcFree(), と free_RegNFA().

参照元 dkcRegularExpressionSearch().

00993                                       {
00994     free_RegNFA((*p)->re_);
00995     return dkcFree(p);
00996 }

int WINAPI dkcFreeReplace DKC_REPLACE **  pp  ) 
 

dkcRegex.c92 行で定義されています。

参照先 dkcFree(), dkcFreeStream(), と NULL.

00092                                            {
00093     if(NULL==pp){
00094         return edk_ArgumentException;
00095     }
00096     dkcFreeStream(&(*pp)->mStream);
00097     return dkcFree((void **)pp);
00098 }

BOOL WINAPI dkcRegexSearch DKC_REGEX p,
const unicode str,
ulong  len,
ulong  stt,
ulong mbg,
ulong med
 

dkcRegex.c998 行で定義されています。

参照先 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 }

BOOL WINAPI dkcRegularExpressionMatch const DKC_UNICODE pat,
const DKC_UNICODE str,
BOOL  caseS
 

Gp.Search

超簡易正規表現マッチング関数。

patとstr全体がマッチするならtrue、ダメならfalseを返す

dkcRegex.c1062 行で定義されています。

参照先 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 }

BOOL WINAPI dkcRegularExpressionSearch const DKC_UNICODE key,
BOOL  caseS,
BOOL  down,
const unicode str,
ulong  len,
ulong  stt,
ulong mbg,
ulong med
 

dkcRegex.c1032 行で定義されています。

参照先 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 }

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
 

dkcRegex.c101 行で定義されています。

00104                                                                           {
00105     return edk_SUCCEEDED;
00106 }

static DKC_INLINE void free_adapter void *  p  )  [static]
 

dkcRegex.c64 行で定義されています。

参照先 dkcFree().

参照元 free_RegClass(), と free_RegNode().

00064                                             {
00065     //free(p);
00066     dkcFree(&p);
00067 }

void free_RegClass RegClass p  ) 
 

dkcRegex.c302 行で定義されています。

参照先 free_adapter().

参照元 free_RegNode().

00302                                {
00303     free_adapter(p);
00304 }

void free_RegNFA RegNFA p  ) 
 

dkcRegex.c715 行で定義されています。

参照先 dkcFree(), と RegNFA_Destruct().

参照元 dkcFreeRegex().

00715                            {
00716     RegNFA_Destruct(p);
00717     dkcFree(&p);
00718 }

void free_RegNode RegNode p  ) 
 

dkcRegex.c328 行で定義されています。

参照先 RegNode_::cls, free_adapter(), と free_RegClass().

参照元 free_RegParser().

00328                              {
00329     if(p->cls){
00330         free_RegClass(p->cls);
00331     }
00332     free_adapter(p);
00333 }

static DKC_INLINE void free_RegParser RegParser p,
RegNode next
[static]
 

dkcRegex.c398 行で定義されています。

参照先 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 }

static DKC_INLINE unicode ignore_map unicode  c  )  [static]
 

dkcRegex.c51 行で定義されています。

参照元 ignore_not_equal(), と RegTrans_match_i().

00052 { 
00053     return (unicode)(L'a'<=c && c<=L'z' ? c-L'a'+L'A' : c); 
00054 }

static DKC_INLINE BOOL ignore_not_equal unicode  c1,
unicode  c2
[static]
 

dkcRegex.c55 行で定義されています。

参照先 ignore_map().

00056 {
00057     return ignore_map(c1)!=ignore_map(c2);
00058 }

static DKC_INLINE void* malloc_adapter size_t  s  )  [static]
 

dkcRegex.c59 行で定義されています。

参照先 dkcAllocateFast().

参照元 alloc_RegClass(), と alloc_RegNode().

00059                                                 {
00060     //return malloc(s);
00061     void *p=dkcAllocateFast(s);
00062     return p;
00063 }

static DKC_INLINE long Max long  x,
long  y
[static]
 

dkcRegex.c72 行で定義されています。

参照元 RegParser_reclass().

00072 { return (y<x ? x : y); }

static DKC_INLINE long Min long  x,
long  y
[static]
 

dkcRegex.c71 行で定義されています。

参照元 RegParser_reclass().

00071 { return (x<y ? x : y); }

void RegClassInit RegClass p,
wchar_t  s,
wchar_t  e,
RegClass n
 

dkcRegex.c289 行で定義されています。

参照先 OneRange_::end, RegClass_::next, RegClass_::range, と OneRange_::stt.

参照元 alloc_RegClass().

00290 { 
00291     p->range.stt=s;
00292     p->range.end=e;
00293     p->next=n;
00294 }

wchar_t RegLexerGetChar RegLexer p  ) 
 

dkcRegex.c270 行で定義されています。

参照先 RegLexer_::chr_.

参照元 RegParser_primary(), と RegParser_reclass().

00270                                       {
00271     return p->chr_; 
00272 }

int RegLexerGetToken RegLexer p  ) 
 

dkcRegex.c230 行で定義されています。

参照先 RegLexerGetTokenImpl().

参照元 RegParser_eat_token().

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 }

static DKC_INLINE int RegLexerGetTokenImpl RegLexer p  )  [static]
 

dkcRegex.c161 行で定義されています。

参照先 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 }

void RegLexerInit RegLexer p,
const wchar_t *  pat,
ulong  len
 

dkcRegex.c153 行で定義されています。

参照先 RegLexer_::end_, RegLexer_::pat_, と RegLexer_::sub_.

参照元 RegParser_Construct().

00154 {
00155     //memset(p,0,sizeof(*p));
00156     p->pat_ = pat;
00157     p->end_ = pat + len;
00158     p->sub_ =  L"";
00159 }

DKC_INLINE void RegNFA_add_e_transition RegNFA ,
int  from,
int  to
 

dkcRegex.c782 行で定義されています。

参照先 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 }

DKC_INLINE void RegNFA_add_transition_a4 RegNFA ,
int  from,
wchar_t  ch,
int  to
 

dkcRegex.c775 行で定義されています。

参照先 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 }

void RegNFA_add_transition_a5 RegNFA ,
int  from,
RegClass cls,
BOOL  cmp,
int  to
 

dkcRegex.c758 行で定義されています。

参照先 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 }

BOOL RegNFA_check_and_push_stack RegNFA ,
int  curSt,
int  pos
 

dkcRegex.c877 行で定義されています。

参照先 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 }

BOOL RegNFA_Construct RegNFA ,
const wchar_t *  pat
 

dkcRegex.c720 行で定義されています。

参照先 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 }

void RegNFA_Destruct RegNFA  ) 
 

dkcRegex.c742 行で定義されています。

参照先 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 }

void RegNFA_gen_nfa RegNFA ,
int  entry,
RegNode t,
int  exit
 

dkcRegex.c803 行で定義されています。

参照先 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 }

DKC_INLINE int RegNFA_gen_state RegNFA  ) 
 

dkcRegex.c796 行で定義されています。

参照先 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 }

BOOL RegNFA_isHeadType RegNFA p  ) 
 

dkcRegex.c690 行で定義されています。

参照先 RegNFA_::parser, と RegParser_isHeadType().

参照元 dkcRegexSearch().

00690                                   { 
00691     return RegParser_isHeadType(&p->parser); 
00692 }

BOOL RegNFA_isTailType RegNFA p  ) 
 

dkcRegex.c693 行で定義されています。

参照先 RegNFA_::parser, と RegParser_isTailType().

参照元 dkcRegexSearch().

00693                                   {
00694     return RegParser_isTailType(&p->parser); 
00695 }

void RegNFA_match_a3 RegNFA ,
int  curSt,
int  pos
 

dkcRegex.c936 行で定義されています。

参照先 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 }

int RegNFA_match_a4 RegNFA ,
const wchar_t *  str,
int  len,
BOOL  caseS
 

dkcRegex.c916 行で定義されています。

参照先 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 }

void RegNFA_pop_stack RegNFA  ) 
 

dkcRegex.c909 行で定義されています。

参照先 dkcStackPop(), と RegNFA_::pstack.

参照元 RegNFA_match_a3().

00910 {
00911     //stack_.ForceSize( stack_.size()-1 );
00912     dkcStackPop(p->pstack);
00913 }

void RegParser_Construct RegParser ,
const unicode pat
 

dkcRegex.c377 行で定義されています。

参照先 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 }

void RegParser_Destruct RegParser p  ) 
 

dkcRegex.c407 行で定義されています。

参照先 free_RegParser(), と RegParser_::root_.

参照元 RegNFA_Destruct().

00407                                      {
00408     free_RegParser(p,p->root_);
00409 }

void RegParser_eat_token RegParser  ) 
 

dkcRegex.c411 行で定義されています。

参照先 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 }

BOOL RegParser_err RegParser p  ) 
 

dkcRegex.c362 行で定義されています。

参照先 RegParser_::err_.

参照元 RegNFA_match_a4().

00362 { return p->err_; }

RegNode * RegParser_expr RegParser  ) 
 

dkcRegex.c580 行で定義されています。

参照先 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 }

RegNode * RegParser_factor RegParser  ) 
 

dkcRegex.c538 行で定義されています。

参照先 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 }

BOOL RegParser_isHeadType RegParser p  ) 
 

dkcRegex.c363 行で定義されています。

参照先 RegParser_::isHeadType_.

参照元 RegNFA_isHeadType().

00363 { return p->isHeadType_; }

BOOL RegParser_isTailType RegParser p  ) 
 

dkcRegex.c364 行で定義されています。

参照先 RegParser_::isTailType_.

参照元 RegNFA_isTailType().

00364 { return p->isTailType_; }

RegNode * RegParser_make_char_leaf RegParser ,
wchar_t  c
 

dkcRegex.c425 行で定義されています。

参照先 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 }

RegNode * RegParser_make_empty_leaf RegParser  ) 
 

dkcRegex.c417 行で定義されています。

参照先 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 }

RegNode * RegParser_make_node RegParser ,
int  t,
RegNode lft,
RegNode rht
 

dkcRegex.c434 行で定義されています。

参照先 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 }

RegNode * RegParser_primary RegParser  ) 
 

dkcRegex.c491 行で定義されています。

参照先 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 }

RegNode * RegParser_reclass RegParser  ) 
 

dkcRegex.c444 行で定義されています。

参照先 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 }

RegNode* RegParser_root RegParser p  ) 
 

dkcRegex.c361 行で定義されています。

参照先 RegParser_::root_.

参照元 RegNFA_Construct().

00361 { return p->root_; }

RegNode * RegParser_term RegParser  ) 
 

dkcRegex.c565 行で定義されています。

参照先 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 }

BOOL RegTrans_match RegTrans pt,
wchar_t  c,
BOOL  caseS
 

dkcRegex.c642 行で定義されています。

参照先 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 }

BOOL RegTrans_match_c RegTrans pt,
wchar_t  c
 

dkcRegex.c622 行で定義されています。

参照先 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 }

BOOL RegTrans_match_i RegTrans pt,
wchar_t  c
 

dkcRegex.c631 行で定義されています。

参照先 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 }


変数

int tmp [static]
 

non thread safe ○| ̄|_

dkcRegex.c373 行で定義されています。

参照元 dkcSemiRealRandomGet32(), RegParser_Construct(), st_delete(), と st_foreach().


dkutil_cに対してSat Sep 10 09:24:48 2005に生成されました。  doxygen 1.4.4