Changeset 439


Ignore:
Timestamp:
11/22/08 00:48:47 (3 years ago)
Author:
mooneer
Message:

Oops, let's try this again.

Location:
interpreter/trunk/regex
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • interpreter/trunk/regex/microregex.h

    r364 r439  
    5454 * @return The created regular expression object. 
    5555 */ 
    56 microregex_t microregex_create(char *regex); 
     56microregex_t microregex_create(const char *regex); 
    5757 
    5858/** 
    … …  
    9191 */ 
    9292microregex_state_t  
    93 microregex_match(microregex_t regex_obj, char *str, int start); 
     93microregex_match(microregex_t regex_obj, const char *str, int start); 
    9494 
    9595/** 

  • interpreter/trunk/regex/microregex_internal.h

    r429 r439  
    5454    char *character_class; 
    5555    int invert, loop_from, loop_to; 
     56    int ref; 
    5657 
    5758    struct microregex_nfa_t *next1, *next2; 
     59    microregex_nfa_t prevL, nextL; 
    5860}; 
    5961 
    … …  
    6365struct microregex_t 
    6466{ 
    65     char *regex; 
     67    const char *regex; 
    6668    int paren_count; 
    6769    int max_paren_count; 
    … …  
    6971    int case_insensitive; 
    7072    microregex_nfa_t nfa; 
     73    microregex_nfa_t nlist; 
    7174}; 
    7275 
    … …  
    8689    int loop_count; 
    8790    struct microregex_state_t *prev, *next; 
     91    struct microregex_state_t *prevL, *nextL; /* allocation list, used to free all re's */ 
    8892}; 
    8993 

  • interpreter/trunk/regex/microregex_matcher.c

    r412 r439  
    3333#include "microregex_internal.h" 
    3434  
     35typedef struct tsmstList tMstList; 
     36 
     37struct tsmstList { 
     38  microregex_state_t *state; 
     39  tMstList *prev; 
     40}; 
     41 
     42 
    3543static microregex_state_t 
    36 microregex_state_new() 
     44microregex_state_new(microregex_state_t *lst) 
    3745{ 
    3846    microregex_state_t ret = malloc(sizeof(struct microregex_state_t)); 
    … …  
    5058    ret->match_end = 0; 
    5159    ret->insensitive = 0; 
     60    if (*lst) { 
     61      ret->prevL = (*lst); 
     62      ret->nextL = (*lst)->nextL; 
     63      if (ret->nextL) ret->nextL->prevL = ret; 
     64      (*lst)->nextL = ret; 
     65    } else { 
     66      ret->prevL = ret->nextL = NULL; 
     67      *lst = ret; 
     68    } 
    5269    return ret; 
    5370} 
    5471 
    5572static microregex_state_t 
    56 microregex_state_clone(microregex_state_t st) 
     73microregex_state_clone_ex(microregex_state_t st, int addToList) 
    5774{ 
    5875    int i; 
    … …  
    7491    ret->loop_count = st->loop_count; 
    7592    ret->insensitive = st->insensitive; 
     93    if (addToList) { 
     94      ret->prevL = st; 
     95      ret->nextL = st->nextL; 
     96      if (ret->nextL) ret->nextL->prevL = ret; 
     97      st->nextL = ret; 
     98    } else ret->prevL = ret->nextL = NULL; 
    7699    return ret; 
    77100} 
    78101 
     102static microregex_state_t 
     103microregex_state_clone(microregex_state_t st) 
     104{ 
     105    return microregex_state_clone_ex(st, 1); 
     106} 
     107 
    79108void 
    80 microregex_state_destroy(microregex_state_t *st) 
    81 { 
     109microregex_state_destroy_ex(microregex_state_t *st, int removeFromList) 
     110{ 
     111    if (!st || !*st) return; 
    82112    int i; 
     113    if (removeFromList) { 
     114      if ((*st)->nextL) (*st)->nextL->prevL = (*st)->prevL; 
     115      if ((*st)->prevL) (*st)->prevL->nextL = (*st)->nextL; 
     116    } 
    83117    free((*st)->se_stack); 
    84118    for (i = 0; i < (*st)->num_ses; i++) 
    … …  
    92126 
    93127 
     128static void microregex_state_destroy_list (microregex_state_t st) { 
     129  if (!st) return; 
     130  while (st->prevL) st = st->prevL; 
     131  while (st) { 
     132    microregex_state_t p = st->nextL; 
     133    microregex_state_destroy_ex(&st, 0); 
     134    st = p; 
     135  } 
     136} 
     137 
     138void microregex_state_destroy (microregex_state_t *st) { 
     139  if (!st || !*st) return; 
     140  microregex_state_destroy_list(*st); 
     141  *st = NULL; 
     142} 
     143 
     144 
     145 
    94146/****************************************************************************** 
    95147 * State machine. 
    … …  
    97149static void 
    98150microregex_regex_push_submatch(microregex_state_t *st_lst, microregex_state_t cur,  
    99                                char *str, char *c); 
     151                               const char *str, const char *c); 
    100152static void 
    101153microregex_regex_pop_submatch(microregex_state_t *st_lst, microregex_state_t cur,  
    102                               char *str, char *c); 
     154                              const char *str, const char *c); 
    103155static void 
    104156microregex_regex_character_class(microregex_state_t *st_lst, microregex_state_t cur,  
    105                                  char *str, char *c); 
     157                                 const char *str, const char *c); 
    106158static void 
    107159microregex_regex_alteration(microregex_state_t *st_lst, microregex_state_t cur,  
    108                             char *str, char *c); 
     160                            const char *str, const char *c); 
    109161static void 
    110162microregex_regex_assert_beginning(microregex_state_t *st_lst, microregex_state_t cur,  
    111                                   char *str, char *c); 
     163                                  const char *str, const char *c); 
    112164static void 
    113165microregex_regex_assert_end(microregex_state_t *st_lst, microregex_state_t cur,  
    114                             char *str, char *c); 
     166                            const char *str, const char *c); 
    115167static void 
    116168microregex_regex_counted_loop(microregex_state_t *st_lst, microregex_state_t cur,  
    117                               char *str, char *c); 
     169                              const char *str, const char *c); 
    118170static void 
    119171microregex_regex_counted_end(microregex_state_t *st_lst, microregex_state_t cur,  
    120                              char *str, char *c); 
     172                             const char *str, const char *c); 
    121173static void 
    122174microregex_regex_counted_begin(microregex_state_t *st_lst, microregex_state_t cur,  
    123                                char *str, char *c); 
     175                               const char *str, const char *c); 
    124176static void 
    125177microregex_regex_pass(microregex_state_t *st_lst, microregex_state_t cur,  
    126                       char *str, char *c); 
     178                      const char *str, const char *c); 
    127179static void 
    128180microregex_regex_word_boundary(microregex_state_t *st_lst, microregex_state_t cur,  
    129                       char *str, char *c); 
     181                      const char *str, const char *c); 
    130182static void 
    131183microregex_regex_backtrack_check(microregex_state_t *st_lst, microregex_state_t cur,  
    132                       char *str, char *c); 
     184                      const char *str, const char *c); 
    133185typedef void  
    134 (*state_machine_func_t)(microregex_state_t *, microregex_state_t, char *, char *); 
     186(*state_machine_func_t)(microregex_state_t *, microregex_state_t, const char *, const char *); 
    135187static state_machine_func_t state_functions[] = { 
    136188    microregex_regex_push_submatch, 
    … …  
    201253static void 
    202254microregex_regex_push_submatch(microregex_state_t *st_lst, microregex_state_t cur,  
    203                                char *str, char *c) 
     255                               const char *str, const char *c) 
    204256{ 
    205257    (void)st_lst; 
    … …  
    225277static void 
    226278microregex_regex_pop_submatch(microregex_state_t *st_lst, microregex_state_t cur,  
    227                               char *str, char *c) 
     279                              const char *str, const char *c) 
    228280{ 
    229281    (void)st_lst; 
    … …  
    243295static void 
    244296microregex_regex_pass(microregex_state_t *st_lst, microregex_state_t cur,  
    245                       char *str, char *c) 
     297                      const char *str, const char *c) 
    246298{ 
    247299    (void)st_lst; 
    … …  
    258310static void 
    259311microregex_regex_backtrack_check(microregex_state_t *st_lst, microregex_state_t cur,  
    260                                  char *str, char *c) 
     312                                 const char *str, const char *c) 
    261313{ 
    262314    char *curstr = cur->ses[cur->state->loop_to]; 
    … …  
    281333static void 
    282334microregex_regex_alteration(microregex_state_t *st_lst, microregex_state_t cur,  
    283                             char *str, char *c) 
     335                            const char *str, const char *c) 
    284336{ 
    285337    (void)st_lst; 
    … …  
    303355static void 
    304356microregex_regex_counted_loop(microregex_state_t *st_lst, microregex_state_t cur,  
    305                              char *str, char *c) 
     357                             const char *str, const char *c) 
    306358{ 
    307359    (void)st_lst; 
    … …  
    334386static void 
    335387microregex_regex_counted_end(microregex_state_t *st_lst, microregex_state_t cur,  
    336                              char *str, char *c) 
     388                             const char *str, const char *c) 
    337389{ 
    338390    (void)st_lst; 
    … …  
    350402static void 
    351403microregex_regex_counted_begin(microregex_state_t *st_lst, microregex_state_t cur,  
    352                                char *str, char *c) 
     404                               const char *str, const char *c) 
    353405{ 
    354406    (void)st_lst; 
    … …  
    367419static void 
    368420microregex_regex_assert_end(microregex_state_t *st_lst, microregex_state_t cur,  
    369                             char *str, char *c) 
     421                            const char *str, const char *c) 
    370422{ 
    371423    (void)st_lst; 
    … …  
    382434static void 
    383435microregex_regex_assert_beginning(microregex_state_t *st_lst, microregex_state_t cur,  
    384                                   char *str, char *c) 
     436                                  const char *str, const char *c) 
    385437{ 
    386438    (void)st_lst; 
    … …  
    396448static void 
    397449microregex_regex_character_class(microregex_state_t *st_lst, microregex_state_t cur,  
    398                                  char *str, char *c) 
     450                                 const char *str, const char *c) 
    399451{ 
    400452    (void)st_lst; 
    … …  
    446498static void 
    447499microregex_regex_word_boundary(microregex_state_t *st_lst, microregex_state_t cur,  
    448                                char *str, char *c) 
     500                               const char *str, const char *c) 
    449501{ 
    450502    int left = 0, right = 0; 
    … …  
    463515    else 
    464516    { 
    465         if (left = !(isalnum(*c) || (*c == '_'))) 
     517        if ((left = !(isalnum(*c) || (*c == '_')))) 
    466518        { 
    467519            right = isalnum(*(c+1)) || (*(c+1) == '_'); 
    … …  
    482534 
    483535microregex_state_t  
    484 microregex_match(microregex_t regex_obj, char *str, int start) 
     536microregex_match(microregex_t regex_obj, const char *str, int start) 
    485537{ 
    486538    microregex_state_t st_lst = NULL; 
    487     microregex_state_t begin = microregex_state_new(); 
     539    microregex_state_t flist = NULL; 
     540    microregex_state_t begin = microregex_state_new(&flist); 
    488541    begin->state = regex_obj->nfa; 
    489542    begin->insensitive = regex_obj->case_insensitive; 
    490543    begin->match_begin = begin->match_end = start; 
    491     microregex_nfa_addstateforward(&st_lst, microregex_state_new()); 
     544    microregex_nfa_addstateforward(&st_lst, microregex_state_new(&flist)); 
    492545    microregex_nfa_addstateforward(&st_lst, begin); 
    493546    microregex_state_t cur = begin, ret = NULL; 
    494     char *curstr = str + start; 
     547    const char *curstr = str + start; 
    495548 
    496549    while(*curstr) 
    … …  
    517570        if (*(curstr + 1)) 
    518571        { 
    519             microregex_state_t newbegin = microregex_state_new(); 
     572            microregex_state_t newbegin = microregex_state_new(&flist); 
    520573            newbegin->state = regex_obj->nfa; 
    521574            newbegin->insensitive = regex_obj->case_insensitive; 
    … …  
    542595        else 
    543596        { 
    544             ret = microregex_state_clone(cur); 
    545             while(st_lst != NULL) 
    546             { 
    547                 cur = st_lst; 
    548                 microregex_nfa_remove(&st_lst); 
    549                 microregex_state_destroy(&cur); 
    550             } 
     597            ret = microregex_state_clone_ex(cur, 0); 
     598            microregex_state_destroy_list(flist); 
    551599            return ret; 
    552600        } 
    … …  
    554602        cur = next; 
    555603    } 
    556      
    557     /* Find longest leftmost match. */ 
    558 #if 0 
    559     int matchstart = strlen(str + start); 
    560     int matchlength = 0; 
    561 #endif 
    562      
    563     while(st_lst != NULL) 
    564     { 
    565         cur = st_lst; 
    566  
    567         /* This might be necessary, but I don't think it is. 
    568          * If there's a bug that requires the following code to fix, I'll remove 
    569          * the #ifdef. */ 
    570 #if 0 
    571         if (cur->state && cur->state->state_type == REGEX_END) 
    572         { 
    573             if (matchstart > cur->match_begin || 
    574                 (matchstart == cur->match_begin && matchlength < strlen(cur->ses[0])) 
    575                ) 
    576             { 
    577                 if (ret) microregex_state_destroy(&ret); 
    578                 ret = microregex_state_clone(cur); 
    579                 matchstart = cur->match_begin; 
    580                 matchlength = strlen(cur->ses[0]); 
    581             } 
    582         } 
    583 #endif 
    584          
    585         microregex_nfa_remove(&st_lst); 
    586         microregex_state_destroy(&cur); 
    587     } 
     604    microregex_state_destroy_list(flist); 
    588605    return ret; 
    589606} 

  • interpreter/trunk/regex/microregex_parser.c

    r429 r439  
    3333#include "microregex_internal.h" 
    3434 
    35 microregex_nfa_t microregex_parse_regex(microregex_t, char *, char **, int); 
    36 void microregex_destroy_nfa(microregex_nfa_t *); 
    37  
    38 static void 
     35static microregex_nfa_t microregex_parse_regex(microregex_t, const char *, char **, int, microregex_nfa_t *); 
     36 
     37static int 
    3938microregex_nfa_append(microregex_nfa_t *nfa, microregex_nfa_t end) 
    4039{ 
    … …  
    4241    { 
    4342        *nfa = end; 
    44         return; 
    45     } 
    46  
     43        return 1; 
     44    } 
     45    int added = 0; 
    4746    if ((*nfa)->state_type != PASS && (*nfa)->state_type != REGEX_END && (*nfa)->next1 != end) 
    48         microregex_nfa_append(&(*nfa)->next1, end); 
     47        added = microregex_nfa_append(&(*nfa)->next1, end); 
    4948    if ((*nfa)->state_type == ALTERATION || (*nfa)->state_type == COUNTED_LOOP) 
    50         if ((*nfa)->next2 != end) 
    51             microregex_nfa_append(&(*nfa)->next2, end); 
    52 } 
    53  
    54 static microregex_nfa_t 
    55 microregex_nfa_backtrack_check(int backtrack) 
    56 { 
    57     microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     49        if ((*nfa)->next2 != end) { 
     50            int added2 = microregex_nfa_append(&(*nfa)->next2, end); 
     51            added |= added2; 
     52        } 
     53    return added; 
     54} 
     55 
     56 
     57static void microregex_nfa_tolist (microregex_nfa_t ret, microregex_nfa_t *lst) { 
     58  if (*lst) { 
     59    ret->prevL = (*lst); 
     60    ret->nextL = (*lst)->nextL; 
     61    if (ret->nextL) ret->nextL->prevL = ret; 
     62    (*lst)->nextL = ret; 
     63  } else { 
     64    ret->prevL = ret->nextL = NULL; 
     65    *lst = ret; 
     66  } 
     67} 
     68 
     69 
     70static microregex_nfa_t 
     71microregex_nfa_backtrack_check(int backtrack, microregex_nfa_t *lst) 
     72{ 
     73    microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     74    microregex_nfa_tolist(ret, lst); 
    5875    ret->state_type = BACKTRACK_CHECK; 
    5976    ret->character_class = NULL; 
    … …  
    6683 
    6784static microregex_nfa_t 
    68 microregex_nfa_alteration(microregex_nfa_t next1, microregex_nfa_t next2) 
    69 { 
    70     microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     85microregex_nfa_alteration(microregex_nfa_t next1, microregex_nfa_t next2, microregex_nfa_t *lst) 
     86{ 
     87    microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     88    microregex_nfa_tolist(ret, lst); 
    7189    ret->state_type = ALTERATION; 
    7290    ret->character_class = NULL; 
    … …  
    7896 
    7997static microregex_nfa_t 
    80 microregex_nfa_assert_beginning() 
    81 { 
    82     microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     98microregex_nfa_assert_beginning(microregex_nfa_t *lst) 
     99{ 
     100    microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     101    microregex_nfa_tolist(ret, lst); 
    83102    ret->state_type = ASSERT_BEGINNING; 
    84103    ret->character_class = NULL; 
    … …  
    90109 
    91110static microregex_nfa_t 
    92 microregex_nfa_assert_end() 
    93 { 
    94     microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     111microregex_nfa_assert_end(microregex_nfa_t *lst) 
     112{ 
     113    microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     114    microregex_nfa_tolist(ret, lst); 
    95115    ret->state_type = ASSERT_END; 
    96116    ret->character_class = NULL; 
    … …  
    102122 
    103123static microregex_nfa_t 
    104 microregex_nfa_counted_begin() 
    105 { 
    106     microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     124microregex_nfa_counted_begin(microregex_nfa_t *lst) 
     125{ 
     126    microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     127    microregex_nfa_tolist(ret, lst); 
    107128    ret->state_type = COUNTED_BEGIN; 
    108129    ret->character_class = NULL; 
    … …  
    114135 
    115136static microregex_nfa_t 
    116 microregex_nfa_counted_loop(int from, int to) 
    117 { 
    118     microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     137microregex_nfa_counted_loop(int from, int to, microregex_nfa_t *lst) 
     138{ 
     139    microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     140    microregex_nfa_tolist(ret, lst); 
    119141    ret->state_type = COUNTED_LOOP; 
    120142    ret->character_class = NULL; 
    … …  
    128150 
    129151static microregex_nfa_t 
    130 microregex_nfa_counted_end() 
    131 { 
    132     microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     152microregex_nfa_counted_end(microregex_nfa_t *lst) 
     153{ 
     154    microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     155    microregex_nfa_tolist(ret, lst); 
    133156    ret->state_type = COUNTED_END; 
    134157    ret->character_class = NULL; 
    … …  
    140163 
    141164static microregex_nfa_t 
    142 microregex_nfa_push_submatch() 
    143 { 
    144     microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     165microregex_nfa_push_submatch(microregex_nfa_t *lst) 
     166{ 
     167    microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     168    microregex_nfa_tolist(ret, lst); 
    145169    ret->state_type = PUSH_SUBMATCH; 
    146170    ret->character_class = NULL; 
    … …  
    152176 
    153177static microregex_nfa_t 
    154 microregex_nfa_pop_submatch() 
    155 { 
    156     microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     178microregex_nfa_pop_submatch(microregex_nfa_t *lst) 
     179{ 
     180    microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     181    microregex_nfa_tolist(ret, lst); 
    157182    ret->state_type = POP_SUBMATCH; 
    158183    ret->character_class = NULL; 
    … …  
    164189 
    165190static microregex_nfa_t 
    166 microregex_nfa_end() 
    167 { 
    168     microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     191microregex_nfa_end(microregex_nfa_t *lst) 
     192{ 
     193    microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     194    microregex_nfa_tolist(ret, lst); 
    169195    ret->state_type = REGEX_END; 
    170196    ret->character_class = NULL; 
    … …  
    176202 
    177203static microregex_nfa_t 
    178 microregex_nfa_pass() 
    179 { 
    180     microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     204microregex_nfa_pass(microregex_nfa_t *lst) 
     205{ 
     206    microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     207    microregex_nfa_tolist(ret, lst); 
    181208    ret->state_type = PASS; 
    182209    ret->character_class = NULL; 
    … …  
    188215 
    189216static microregex_nfa_t 
    190 microregex_nfa_oneplus(microregex_nfa_t one, int greedy) 
    191 { 
    192     microregex_nfa_t pass = microregex_nfa_pass(); 
     217microregex_nfa_oneplus(microregex_nfa_t one, int greedy, microregex_nfa_t *lst) 
     218{ 
     219    microregex_nfa_t pass = microregex_nfa_pass(lst); 
    193220    microregex_nfa_t ret =  
    194221        microregex_nfa_alteration( 
    195222            greedy ? pass : NULL, 
    196223            greedy ? NULL : pass 
    197         ); 
     224        , lst); 
    198225    microregex_nfa_append(&one, ret); 
    199226    pass->next1 = one; 
    … …  
    202229 
    203230static microregex_nfa_t 
    204 microregex_nfa_zeroplus(microregex_nfa_t one, int greedy) 
     231microregex_nfa_zeroplus(microregex_nfa_t one, int greedy, microregex_nfa_t *lst) 
    205232{ 
    206233    microregex_nfa_t ret =  
    … …  
    208235            greedy ? one : NULL,  
    209236            greedy ? NULL : one 
    210         ); 
    211     microregex_nfa_t pass = microregex_nfa_pass(); 
     237        , lst); 
     238    microregex_nfa_t pass = microregex_nfa_pass(lst); 
    212239    microregex_nfa_append(&one, pass); 
    213240    pass->next1 = ret; 
    … …  
    216243 
    217244static microregex_nfa_t 
    218 microregex_nfa_zeroone(microregex_t regex, microregex_nfa_t one, int greedy, int p) 
    219 { 
    220     microregex_nfa_t pass = microregex_nfa_pass(); 
    221     microregex_nfa_t ce = microregex_nfa_counted_end(); 
     245microregex_nfa_zeroone(microregex_t regex, microregex_nfa_t one, int greedy, int p, microregex_nfa_t *lst) 
     246{ 
     247    microregex_nfa_t pass = microregex_nfa_pass(lst); 
     248    microregex_nfa_t ce = microregex_nfa_counted_end(lst); 
    222249 
    223250    microregex_nfa_t parens = NULL; 
    224251    int i; 
    225252    for (i = p; i < regex->max_paren_count; i++) { 
    226         microregex_nfa_append(&parens, microregex_nfa_push_submatch()); 
     253        microregex_nfa_append(&parens, microregex_nfa_push_submatch(lst)); 
    227254    } 
    228255    for (i = regex->max_paren_count; i > p; i--) { 
    229         microregex_nfa_append(&parens, microregex_nfa_pop_submatch()); 
     256        microregex_nfa_append(&parens, microregex_nfa_pop_submatch(lst)); 
    230257    } 
    231258    microregex_nfa_append(&parens, ce); 
    … …  
    235262            greedy ? one : parens,  
    236263            greedy ? parens : one 
    237         ); 
     264        , lst); 
    238265    microregex_nfa_append(&one, pass); 
    239266    pass->next1 = ce; 
    … …  
    241268} 
    242269 
    243 static char * 
    244 microregex_nfa_charliteral_process(char *regex, char *buf) 
     270static const char * 
     271microregex_nfa_charliteral_process(const char *regex, char *buf) 
    245272{ 
    246273    int i, j; 
    … …  
    296323            } 
    297324            case '0': 
    298             { 
    299                 buf[0] = (char)strtol(regex, &regex, 8); 
     325            {   char *tt; 
     326                buf[0] = (char)strtol(regex, &tt, 8); 
     327                regex = tt; 
    300328                break; 
    301329            } 
    302330            case 'x': 
    303             { 
    304                 buf[0] = (char)strtol(regex, &regex, 16); 
     331            {   char *tt; 
     332                buf[0] = (char)strtol(regex, &tt, 16); 
     333                regex = tt; 
    305334                break; 
    306335            } 
    … …  
    387416 
    388417static microregex_nfa_t 
    389 microregex_nfa_charliteral(char *regex, char **end_location) 
    390 { 
    391     microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     418microregex_nfa_charliteral(const char *regex, const char **end_location, microregex_nfa_t *lst) 
     419{ 
     420    microregex_nfa_t ret = (microregex_nfa_t)malloc(sizeof(struct microregex_nfa_t)); 
     421    microregex_nfa_tolist(ret, lst); 
    392422    char tmp_buf[256]; 
    393423 
    … …  
    404434    if (*regex == '[') 
    405435    { 
    406         char *tmp = regex + 1; 
     436        const char *tmp = regex + 1; 
    407437        if (*tmp == '^')  
    408438        { 
    … …  
    490520             
    491521            ret->state_type = COUNTED_BEGIN; 
    492             microregex_nfa_t bt = microregex_nfa_backtrack_check(backtrack); 
     522            microregex_nfa_t bt = microregex_nfa_backtrack_check(backtrack, lst); 
    493523            ret->next1 = bt; 
    494524        } 
    … …  
    516546 */ 
    517547microregex_t 
    518 microregex_create(char *regex) 
     548microregex_create(const char *regex) 
    519549{ 
    520550    microregex_t ret = (microregex_t)malloc(sizeof(struct microregex_t)); 
    … …  
    523553    ret->regex = regex; 
    524554    ret->err_string = NULL; 
    525     ret->nfa = microregex_parse_regex(ret, regex, NULL, 0); 
    526     microregex_nfa_append(&ret->nfa, microregex_nfa_end()); 
    527  
    528     return ret; 
    529 } 
    530  
    531 /** 
    532  * Destroy regular expression object. 
    533  * @param regex_obj The regular expression object to destroy. 
    534  */ 
    535 void 
    536 microregex_destroy_nfa(microregex_nfa_t *regex_obj) 
    537 { 
    538     if (regex_obj == NULL || (*regex_obj) == NULL) return; 
    539  
    540     if ((*regex_obj)->state_type != PASS) 
    541     { 
    542         microregex_destroy_nfa(&(*regex_obj)->next1); 
    543         microregex_destroy_nfa(&(*regex_obj)->next2); 
    544     } 
    545  
    546     free((*regex_obj)->character_class); 
    547     free(*regex_obj); 
    548     *regex_obj = NULL; 
     555    ret->nlist = NULL; 
     556    ret->nfa = microregex_parse_regex(ret, regex, NULL, 0, &ret->nlist); 
     557    microregex_nfa_append(&ret->nfa, microregex_nfa_end(&ret->nlist)); 
     558 
     559    return ret; 
    549560} 
    550561 
    … …  
    559570 
    560571    if ((*regex_obj)->err_string) free((*regex_obj)->err_string); 
    561     if ((*regex_obj)->nfa) microregex_destroy_nfa(&(*regex_obj)->nfa); 
     572 
     573    microregex_nfa_t lst = (*regex_obj)->nlist, nn; 
     574    while (lst) { 
     575      nn = lst->nextL; 
     576      free(lst->character_class); 
     577      free(lst); 
     578      lst = nn; 
     579    } 
     580 
    562581    free(*regex_obj); 
    563582    *regex_obj = NULL; 
    … …  
    582601 * @return The created NFA object. 
    583602 */ 
    584 microregex_nfa_t 
    585 microregex_parse_regex(microregex_t regex_obj, char *regex, char **end_char, int paren_start) 
     603static microregex_nfa_t 
     604microregex_parse_regex(microregex_t regex_obj, const char *regex, char **end_char, int paren_start, microregex_nfa_t *lst) 
    586605{ 
    587606    int cur_paren = regex_obj->paren_count; 
    … …  
    607626                microregex_nfa_append( 
    608627                    &prev, 
    609                     microregex_nfa_push_submatch() 
     628                    microregex_nfa_push_submatch(lst) 
    610629                ); 
    611630                microregex_nfa_append( 
    … …  
    615634                        regex + 1, 
    616635                        &end_location, 
    617                         paren_start + 1 
     636                        paren_start + 1, 
     637                        lst 
    618638                    ) 
    619639                ); 
    … …  
    628648                    microregex_nfa_append( 
    629649                        &prev, 
    630                         microregex_nfa_pop_submatch() 
     650                        microregex_nfa_pop_submatch(lst) 
    631651                    ); 
    632652                } 
    … …  
    649669                        regex + 1, 
    650670                        &end_location, 
    651                         paren_start 
    652                     ) 
     671                        paren_start, 
     672                        lst 
     673                    ), lst 
    653674                ); 
    654675 
    … …  
    666687                    microregex_nfa_oneplus( 
    667688                        prev, 
    668                         greedy 
     689                        greedy, 
     690                        lst 
    669691                    ); 
    670692 
    … …  
    680702                    microregex_nfa_zeroplus( 
    681703                        prev, 
    682                         greedy 
     704                        greedy, 
     705                        lst 
    683706                    ); 
    684707 
    … …  
    696719                        prev, 
    697720                        greedy, 
    698                         cur_paren 
     721                        cur_paren, 
     722                        lst 
    699723                    ); 
    700724 
    … …  
    705729            { 
    706730                /* Counted repetition */ 
    707                 char *cur_pos = regex; 
    708                 int from = strtol(regex + 1, &regex, 10); 
     731                const char *cur_pos = regex; char *tt; 
     732                int from = strtol(regex + 1, &tt, 10); 
     733                regex = tt; 
    709734                int to; 
    710735                if (!*regex || (*regex != ',' && *regex != '}')) 
    … …  
    715740                else if (*regex == ',') 
    716741                { 
    717                     to = strtol(regex + 1, &regex, 10); 
     742                    to = strtol(regex + 1, &tt, 10); 
     743                    regex = tt; 
    718744                    if (*regex != '}') 
    719745                    { 
    … …  
    731757                } 
    732758 
    733                 microregex_nfa_t tmpnfa = microregex_nfa_counted_begin(); 
    734                 microregex_nfa_t counted_loop = microregex_nfa_counted_loop(from, to); 
     759                microregex_nfa_t tmpnfa = microregex_nfa_counted_begin(lst); 
     760                microregex_nfa_t counted_loop = microregex_nfa_counted_loop(from, to, lst); 
    735761                greedy = (*(++regex) != '?'); 
    736                 microregex_nfa_t tmppass = microregex_nfa_pass(); 
     762                microregex_nfa_t tmppass = microregex_nfa_pass(lst); 
    737763                tmppass->next1 = counted_loop; 
    738764 
    739                 counted_loop->next1 = greedy ? prev : microregex_nfa_counted_end(); 
    740                 counted_loop->next2 = greedy ? microregex_nfa_counted_end() : prev; 
     765                counted_loop->next1 = greedy ? prev : microregex_nfa_counted_end(lst); 
     766                counted_loop->next2 = greedy ? microregex_nfa_counted_end(lst) : prev; 
    741767                microregex_nfa_append( 
    742768                    &prev, 
    … …  
    755781                microregex_nfa_append( 
    756782                    &nfa, 
    757                     microregex_nfa_assert_beginning() 
     783                    microregex_nfa_assert_beginning(lst) 
    758784                ); 
    759785                break; 
    … …  
    764790                microregex_nfa_append( 
    765791                    &nfa, 
    766                     microregex_nfa_assert_end() 
     792                    microregex_nfa_assert_end(lst) 
    767793                ); 
    768794                break; 
    … …  
    775801                prev = microregex_nfa_charliteral( 
    776802                    regex, 
    777                     &end_location 
     803                    (const char **)(&end_location), 
     804                    lst 
    778805                ); 
    779  
    780806                regex = end_location; 
    781807            } 
    … …  
    786812 
    787813    if (prev) microregex_nfa_append(&nfa, prev); 
    788     if (end_char) *end_char = regex; 
     814    if (end_char) *end_char = (char *)regex; 
    789815    return nfa; 
    790816} 
Note: See TracChangeset for help on using the changeset viewer.