自己动手写一个轻巧，高效的正则表达式引擎

case'+':
e=pop();
s=state(Split,e.start,NULL);
patch(e.out,s);
push(frag(e.start,list1(&s->out1)));
break;

实现：模拟NFA

structList
{
State**s;
intn;
};

int
match(State*start,char*s)
{
List*clist,*nlist,*t;

/*l1andl2arepreallocatedglobals*/
clist=startlist(start,&l1);
nlist=&l2;
for(;*s;s++){
step(clist,*s,nlist);
t=clist;clist=nlist;nlist=t;/*swapclist,nlist*/
}
returnismatch(clist);
}

为了避免在每一次迭代中申请内存，match用两个预先申请的表l1和l2作为clist和nlist，每一步交换二者。

如果最后的状态列表包含匹配状态，就达成了匹配。

int
ismatch(List*l)
{
inti;

for(i=0;i<l->n;i++)
if(l->s[i]==matchstate)
return1;
return0;
}

addstate添加一个状态到列表中，但是已经在里面了不会添加。每一次添加的时候都要遍历整个列表很低效；实际上listid作为列表的生成数。当addstate添加s，它在s->lastlist记录listid。如果两者相同，s在列表创建时已经在其中了。Addstate也接受未标记的箭头：如果s是带有两个未标记箭头，且指向新的状态的Split状态，addstate把这些状态添加到list中而不是s。

void
addstate(List*l,State*s)
{
if(s==NULL||s->lastlist==listid)
return;
s->lastlist=listid;
if(s->c==Split){
/*followunlabeledarrows*/
addstate(l,s->out);
addstate(l,s->out1);
return;
}
l->s[l->n++]=s;
}

startlist通过加入开始状态创建初始列表：

List*
startlist(State*s,List*l)
{
listid++;
l->n=0;
addstate(l,s);
returnl;
}

最后，step用单个字符推进NFA，用当前列表clist计算后续列表nlist。

void
step(List*clist,intc,List*nlist)
{
inti;
State*s;

listid++;
nlist->n=0;
for(i=0;i<clist->n;i++){
s=clist->s[i];
if(s->c==c)
addstate(nlist,s->out);
}
}

性能

来分开五个用空格隔开的部分，或是在选择符号中最常出现的分支不是排在前面。总之，程序员总是避免耗时的部分，否则就要进行优化。Thompson的NFA就不需要这样的调整：没有低效的正则表达式。

structDState
{
Listl;
DState*next[256];
DState*left;
DState*right;
};

int
match(DState*start,char*s)
{
intc;
DState*d,*next;

d=start;
for(;*s;s++){
c=*s&0xFF;
if((next=d->next[c])==NULL)
next=nextstate(d,c);
d=next;
}
returnismatch(&d->l);
}

DState*
dstate(List*l)
{
inti;
DState**dp,*d;
staticDState*alldstates;

qsort(l->s,l->n,sizeofl->s[0],ptrcmp);

/*lookintreeforexistingDState*/
dp=&alldstates;
while((d=*dp)!=NULL){
i=listcmp(l,&d->l);
if(i<0)
dp=&d->left;
elseif(i>0)
dp=&d->right;
else
returnd;
}

/*allocate,initializenewDState*/
d=malloc(sizeof*d+l->n*sizeofl->s[0]);
memset(d,0,sizeof*d);
d->l.s=(State**)(d+1);
memmove(d->l.s,l->s,l->n*sizeofl->s[0]);
d->l.n=l->n;

/*insertintree*/
*dp=d;
returnd;
}

DState*
nextstate(DState*d,intc)
{
step(&d->l,c,&l1);
returnd->next[c]=dstate(&l1);
}

DState*
startdstate(State*start)
{
returndstate(startlist(start,&l1));
}

if(/([0-9]+-[0-9]+-[0-9]+)([0-9]+:[0-9]+)/){
print"date:$1,time:$2\n";
}