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

# 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)
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 ○|￣|＿

## 説明

Regex

作者:
  d金魚

から:
  2004/09/01

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

## マクロ定義

#define alloc_RegTrans | (
|  | ) | malloc_adapter(sizeof(RegTrans))

| dkcRegex.c の 611 行で定義されています。 参照元 RegNFA_add_e_transition(), と RegNFA_add_transition_a5().

#define free_RegTrans | ( | p |  | ) | free_adapter(p)

| dkcRegex.c の 612 行で定義されています。 参照元 RegNFA_Destruct().

#define my_lstrcpyW dkcstd_wcsncpy

| BOFの可能性あり dkcRegex.c の 30 行で定義されています。

#define my_lstrlenW dkcstd_wcslen

| dkcRegex.c の 28 行で定義されています。 参照元 dkcRegularExpressionMatch(), と RegParser_Construct().

## 型定義

typedef unsigned char byte

| dkcRegex.c の 16 行で定義されています。

typedef unsigned short dbyte

| dkcRegex.c の 17 行で定義されています。

typedef struct OneRange_ OneRange

typedef unsigned long qbyte

| dkcRegex.c の 18 行で定義されています。

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.c の 22 行で定義されています。

typedef unsigned int uint

| dkcRegex.c の 24 行で定義されています。

typedef unsigned long ulong

| dkcRegex.c の 25 行で定義されています。

typedef DKC_UNICODE unicode

| dkcRegex.c の 19 行で定義されています。

typedef unsigned short ushort

| dkcRegex.c の 23 行で定義されています。

## 列挙型

anonymous enum

  | only for RegTrans::type; 列挙型の値:
  eEpsilon |
  eClass |
  eChar |
dkcRegex.c の 615 行で定義されています。
    00615      {
    00616     eEpsilon,
    00617     eClass,
    00618     eChar,
    00619 };

## 関数

RegClass* alloc_RegClass | ( | wchar_t | s,
|  | wchar_t | e,
|  | RegClass * | n
| ) |

| 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 }

RegNFA* alloc_RegNFA | ( | const unicode * | key | ) |

| 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 }

RegNode* alloc_RegNode | ( |  | ) |

| 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 }

DKC_REGEX* WINAPI dkcAllocRegex | ( | const unicode * | key,
|  | BOOL | caseS,
|  | BOOL | down
| ) |

| 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 }

DKC_REPLACE* WINAPI dkcAllocReplace | ( |  | ) |

| 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 }

int WINAPI dkcFreeRegex | ( | DKC_REGEX ** | p | ) |

| dkcRegex.c の 993 行で定義されています。 参照先 dkcFree(), と free_RegNFA(). 参照元 dkcRegularExpressionSearch().
    00993                                       {
    00994     free_RegNFA((*p)->re_);
    00995     return dkcFree(p);
    00996 }

int WINAPI dkcFreeReplace | ( | DKC_REPLACE ** | pp | ) |

| 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 }

BOOL WINAPI dkcRegexSearch | ( | DKC_REGEX * | p,
|  | const unicode * | str,
|  | ulong | len,
|  | ulong | stt,
|  | ulong * | mbg,
|  | ulong * | med
| ) |

| 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 }

BOOL WINAPI dkcRegularExpressionMatch | ( | const DKC_UNICODE * | pat,
|  | const DKC_UNICODE * | str,
|  | BOOL | caseS
| ) |

| 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 }

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

| 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 }

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.c の 101 行で定義されています。
    00104                                                                           {
    00105     return edk_SUCCEEDED;
    00106 }

static DKC_INLINE void free_adapter | ( | void * | p | ) | `[static]`

| dkcRegex.c の 64 行で定義されています。 参照先 dkcFree(). 参照元 free_RegClass(), と free_RegNode().
    00064                                             {
    00065     //free(p);
    00066     dkcFree(&p);
    00067 }

void free_RegClass | ( | RegClass * | p | ) |

| dkcRegex.c の 302 行で定義されています。 参照先 free_adapter(). 参照元 free_RegNode().
    00302                                {
    00303     free_adapter(p);
    00304 }

void free_RegNFA | ( | RegNFA * | p | ) |

| dkcRegex.c の 715 行で定義されています。 参照先 dkcFree(), と RegNFA_Destruct(). 参照元 dkcFreeRegex().
    00715                            {
    00716     RegNFA_Destruct(p);
    00717     dkcFree(&p);
    00718 }

void free_RegNode | ( | RegNode * | p | ) |

| 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 }

static DKC_INLINE void free_RegParser | ( | RegParser * | p,
|  | RegNode * | next
| ) | `[static]`

| 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 }

static DKC_INLINE unicode ignore_map | ( | unicode | c | ) | `[static]`

| 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 }

static DKC_INLINE BOOL ignore_not_equal | ( | unicode | c1,
|  | unicode | c2
| ) | `[static]`

| dkcRegex.c の 55 行で定義されています。 参照先 ignore_map().
    00056 {
    00057     return ignore_map(c1)!=ignore_map(c2);
    00058 }

static DKC_INLINE void* malloc_adapter | ( | size_t | s | ) | `[static]`

| dkcRegex.c の 59 行で定義されています。 参照先 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.c の 72 行で定義されています。 参照元 RegParser_reclass().
    00072 { return (y<x ? x : y); }

static DKC_INLINE long Min | ( | long | x,
|  | long | y
| ) | `[static]`

| dkcRegex.c の 71 行で定義されています。 参照元 RegParser_reclass().
    00071 { return (x<y ? x : y); }

void RegClassInit | ( | RegClass * | p,
|  | wchar_t | s,
|  | wchar_t | e,
|  | RegClass * | n
| ) |

| dkcRegex.c の 289 行で定義されています。 参照先 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.c の 270 行で定義されています。 参照先 RegLexer_::chr_. 参照元 RegParser_primary(), と RegParser_reclass().
    00270                                       {
    00271     return p->chr_;
    00272 }

int RegLexerGetToken | ( | RegLexer * | p | ) |

| dkcRegex.c の 230 行で定義されています。 参照先 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.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 }

void RegLexerInit | ( | RegLexer * | p,
|  | const wchar_t * | pat,
|  | ulong | len
| ) |

| dkcRegex.c の 153 行で定義されています。 参照先 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.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 }

DKC_INLINE void RegNFA_add_transition_a4 | ( | RegNFA * | ,
|  | int | from,
|  | wchar_t | ch,
|  | int | to
| ) |

| 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 }

void RegNFA_add_transition_a5 | ( | RegNFA * | ,
|  | int | from,
|  | RegClass * | cls,
|  | BOOL | cmp,
|  | int | to
| ) |

| 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 }

BOOL RegNFA_check_and_push_stack | ( | RegNFA * | ,
|  | int | curSt,
|  | int | pos
| ) |

| 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 }

BOOL RegNFA_Construct | ( | RegNFA * | ,
|  | const wchar_t * | pat
| ) |

| 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 }

void RegNFA_Destruct | ( | RegNFA * |  | ) |

| 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 }

void RegNFA_gen_nfa | ( | RegNFA * | ,
|  | int | entry,
|  | RegNode * | t,
|  | int | exit
| ) |

| 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 }

DKC_INLINE int RegNFA_gen_state | ( | RegNFA * |  | ) |

| 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 }

BOOL RegNFA_isHeadType | ( | RegNFA * | p | ) |

| dkcRegex.c の 690 行で定義されています。 参照先 RegNFA_::parser, と RegParser_isHeadType(). 参照元 dkcRegexSearch().
    00690                                   {
    00691     return RegParser_isHeadType(&p->parser);
    00692 }

BOOL RegNFA_isTailType | ( | RegNFA * | p | ) |

| dkcRegex.c の 693 行で定義されています。 参照先 RegNFA_::parser, と RegParser_isTailType(). 参照元 dkcRegexSearch().
    00693                                   {
    00694     return RegParser_isTailType(&p->parser);
    00695 }

void RegNFA_match_a3 | ( | RegNFA * | ,
|  | int | curSt,
|  | int | pos
| ) |

| 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 }

int RegNFA_match_a4 | ( | RegNFA * | ,
|  | const wchar_t * | str,
|  | int | len,
|  | BOOL | caseS
| ) |

| 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 }

void RegNFA_pop_stack | ( | RegNFA * |  | ) |

| dkcRegex.c の 909 行で定義されています。 参照先 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.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 }

void RegParser_Destruct | ( | RegParser * | p | ) |

| dkcRegex.c の 407 行で定義されています。 参照先 free_RegParser(), と RegParser_::root_. 参照元 RegNFA_Destruct().
    00407                                      {
    00408     free_RegParser(p,p->root_);
    00409 }

void RegParser_eat_token | ( | RegParser * |  | ) |

| 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 }

BOOL RegParser_err | ( | RegParser * | p | ) |

| dkcRegex.c の 362 行で定義されています。 参照先 RegParser_::err_. 参照元 RegNFA_match_a4().
    00362 { return p->err_; }

RegNode * RegParser_expr | ( | RegParser * |  | ) |

| 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 }

RegNode * RegParser_factor | ( | RegParser * |  | ) |

| 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 }

BOOL RegParser_isHeadType | ( | RegParser * | p | ) |

| dkcRegex.c の 363 行で定義されています。 参照先 RegParser_::isHeadType_. 参照元 RegNFA_isHeadType().
    00363 { return p->isHeadType_; }

BOOL RegParser_isTailType | ( | RegParser * | p | ) |

| dkcRegex.c の 364 行で定義されています。 参照先 RegParser_::isTailType_. 参照元 RegNFA_isTailType().
    00364 { return p->isTailType_; }

RegNode * RegParser_make_char_leaf | ( | RegParser * | ,
|  | wchar_t | c
| ) |

| 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 }

RegNode * RegParser_make_empty_leaf | ( | RegParser * |  | ) |

| 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 }

RegNode * RegParser_make_node | ( | RegParser * | ,
|  | int | t,
|  | RegNode * | lft,
|  | RegNode * | rht
| ) |

| 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 }

RegNode * RegParser_primary | ( | RegParser * |  | ) |

| 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 }

RegNode * RegParser_reclass | ( | RegParser * |  | ) |

| 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 }

RegNode* RegParser_root | ( | RegParser * | p | ) |

| dkcRegex.c の 361 行で定義されています。 参照先 RegParser_::root_. 参照元 RegNFA_Construct().
    00361 { return p->root_; }

RegNode * RegParser_term | ( | RegParser * |  | ) |

| 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 }

BOOL RegTrans_match | ( | RegTrans * | pt,
|  | wchar_t | c,
|  | BOOL | caseS
| ) |

| 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 }

BOOL RegTrans_match_c | ( | RegTrans * | pt,
|  | wchar_t | c
| ) |

| 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 }

BOOL RegTrans_match_i | ( | RegTrans * | pt,
|  | wchar_t | c
| ) |

| 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 }

## 変数

int tmp`[static]`

| non thread safe ○|￣|＿ dkcRegex.c の 373 行で定義されています。 参照元 dkcSemiRealRandomGet32(), RegParser_Construct(), st_delete(), と st_foreach().