nfa转dfa，正式完成

为了加速转换的处理，我压缩了符号表。具体算法参考任何一本与编译或者自动机相关的书籍。

这里的核心问题是处理传递性闭包，transitive closure,这个我目前采取的是最简单的warshall算法，虽然是4次的复杂度，但是由于我构建nfa的时候并没有采取标准的方法，使得nfa的节点减少很多。ps，上上篇所说的re转nfa，我这里有一个修改，就是对于or转换，不再增加节点，而是只增加两条空转换边。

相关代码如下

#include "nfa_process.h"
//首先在原来的nfa节点中，把最后的那个正则的开始节点可达的那些节点提取出来，相当于又一次的拷贝
p_edge_list nfa_to_dfa[100];//这个当作新的nfa图
int nfa_min_node_number=0;//注意nfa_min_node_number使用的时候是从1开始的，他的值表示已经使用到了多少
#define BYTE_MASK 0x80
typedef struct _dfa_edge
{
    struct _dfa_edge* next;
    char label;
    int dest_dfa_index;
}dfa_edge,*pdfa_edge;
typedef struct _dfa_node
{
    pdfa_edge begin;
    int dfa_hash_number;
}dfa_node,*pdfa_node;
dfa_node current_dfa_table[400];//由于dfa的数量很大，所以开一个400的数组
int dfa_node_number=0;//dfa_node_number作为一个全局变量，用来标号使用
int current_dfa_node=0;//这个用来表示处理到了那一个dfa节点了
typedef struct _dfa_hash
{
    int in_use;
    char* name;
    int dfa_node_pointer;
}dfa_hash;
dfa_hash dfa_hash_table[400];//400的理由同上，这里刚好397是一个质数
void ntd_add_edge(int ntd_node_begin,int ntd_node_end,char label)//在压缩过的 nfa中加边 
{
    p_edge_list temp_pnode=malloc(sizeof(struct _graph_edge_list));
    temp_pnode->label_of_edge=label;
    temp_pnode->destination_number=ntd_node_end;
    temp_pnode->next_edge=nfa_to_dfa[ntd_node_begin];
    nfa_to_dfa[ntd_node_begin]=temp_pnode;
}
int dfa_into_hash(char* input_name,int dfa_node_index,int byte_of_bitmap)//这里是hash插入函数
{
    int for_i;
    unsigned int result;
    int counter;
    char* hash_name;
    result=0;
    for(for_i=0;for_i<byte_of_bitmap;for_i++)
    {
        result+=(unsigned int) input_name[for_i];
    }
    result=result%397;
    counter=0;
    while(counter<397)
    {
        if(dfa_hash_table[result].in_use==0)
        {
            dfa_hash_table[result].dfa_node_pointer=dfa_node_index;
            dfa_hash_table[result].in_use=1;
            hash_name=malloc(sizeof(char)*(byte_of_bitmap+1));
            strcpy(hash_name,input_name);
            dfa_hash_table[result].name=hash_name;
            return result;
        }
        result=(result+1)%397;
        counter++;
    }
    return -1;
}
int search_dfa_hash(char* input_name)//对于一个名字寻找是否已经在表中
{
    int for_i;
    unsigned int result;
    int counter;
    int byte_of_bitmap=strlen(input_name);
    result=0;
    for(for_i=0;for_i<byte_of_bitmap;for_i++)
    {
        result+=(unsigned int) input_name[for_i];
    }
    result=result%397;
    counter=0;
    while(counter<397)
    {
        if(dfa_hash_table[result].in_use==0)
        {
            return -1;
        }
        else
        {
            if(!strcmp(dfa_hash_table[result].name,input_name))
            {
                return result;
            }
            else
            {
                result=(result+1)%397;
                counter++;
            }
        }
    }
    return -1;
}


int hamming_distance(int input)//用来得到一个4字节的int里面二进制存在1的个数
{
    int temp=(unsigned)input;
    temp=(temp&0x55555555)+((temp>>1)&0x55555555);
    temp=(temp&0x33333333)+((temp>>2)&0x33333333);
    temp=(temp&0x0f0f0f0f)+((temp>>4)&0x0f0f0f0f);
    temp=(temp&0x00ff00ff)+((temp>>8)&0x00ff00ff);
    temp=(temp&0x0000ffff)+((temp>>16)&0x0000ffff);
    return temp;
}
int length_of_char_set(void)//计算字符表中的字符的种类
{
    int result=0;
    result+=hamming_distance(alpha_table.char_one);
    result+=hamming_distance(alpha_table.char_two);
    result+=hamming_distance(alpha_table.char_three);
    result+=hamming_distance(alpha_table.char_four);
    return result;
}

 minimize_char_set(char* mini_set)//压缩字母表
{
    int for_i;
    unsigned int another_mask;
    int mini_set_counter;
    mini_set_counter=for_i=0;
    for(for_i=0;for_i<32;for_i++)
    {
        if(for_i!=17)//对于空转换字符我们不予理睬
        {
            another_mask=MASK>>for_i;
            if(alpha_table.char_one&another_mask)
            {
                
                mini_set[mini_set_counter++]=for_i;
            }
        }
    }
    for(for_i=32;for_i<64;for_i++)
    {
        another_mask=MASK>>(for_i%32);
        if(alpha_table.char_two&another_mask)
        {
            mini_set[mini_set_counter++]=for_i;
        }
    }
    for(for_i=64;for_i<96;for_i++)
    {
        another_mask=MASK>>(for_i%32);
        if(alpha_table.char_three&another_mask)
        {
            mini_set[mini_set_counter++]=for_i;
        }
    }
    for(for_i=96;for_i<128;for_i++)
    {
        another_mask=MASK>>(for_i%32);
        if(alpha_table.char_four&another_mask)
        {
            mini_set[mini_set_counter++]=for_i;
        }
    }
}

void set_dfa_bit(char* begin,int index)//在转换节点中设置第index位，这里是从1开始数的，所以要注意
{
    char* temp;
    index=index-1;
    temp=begin+index/8;
    index=index%8;
    *temp=(unsigned char)(*temp)|(BYTE_MASK>>index);
}
int extract_nfa(void)//这里是压缩nfa，实质上与前面那个nfa复制函数是一样的 
//返回开始节点的索引，为了nfa转dfa用
{
    int nfa_begin_number;
    int nfa_end_number;

    int copy_destination;
    int offset;
    int original_token;
    char copy_label;
    p_edge_list pcopy;
    original_token=token_node_number-1;
    nfa_begin_number=token_node[original_token].bottom;
    nfa_end_number=token_node[original_token].top;
    offset=nfa_min_node_number-nfa_begin_number+1;//因为这样要考虑下一个节点
    for(nfa_begin_number;nfa_begin_number<=nfa_end_number;nfa_begin_number++)//开始复制图
    {
        pcopy=nfa_node[nfa_begin_number];
        nfa_min_node_number++;
        nfa_node[nfa_min_node_number]=NULL;
        while(pcopy!=NULL)
        {
            copy_label=pcopy->label_of_edge;
            copy_destination=pcopy->destination_number+offset;
            ntd_add_edge(nfa_min_node_number,copy_destination,copy_label);
            pcopy=pcopy->next_edge;
        }
    }
    return token_node[original_token].begin+offset;
}
void tackle_dfa_label(char* output,int dfa_current,char input_label,int node_size)//处理边转换
{
    char* current_nfa_set;
    int for_i;
    int dfa_hash_index;
    p_edge_list temp_edge;//这里处理的还是nfa的边
    char temp_label=input_label;
    dfa_hash_index=current_dfa_table[dfa_current].dfa_hash_number;
    current_nfa_set=dfa_hash_table[dfa_hash_index].name;
    for(for_i=0;for_i<node_size;for_i++)//对于这个位图中的每一位进行遍历
    {
        if((BYTE_MASK>>(for_i%8))&(current_nfa_set[for_i/8]))//如果这个位有效
        {
            temp_edge=nfa_to_dfa[for_i+1];//注意这里要加1，因为 nfa_to_table的索引是从1开始的
            while(temp_edge!=NULL)
            {
                if(temp_edge->label_of_edge==temp_label)
                {
                    set_dfa_bit(output,temp_edge->destination_number);//注意这里不需要减1
                }
                temp_edge=temp_edge->next_edge;
            }
        }
    }
}


int is_label_null(char* input_name,int name_size_inbyte)//判断一个label是否为空
{
    int result;
    int for_i;
    result=0;
    for(for_i=0;for_i<name_size_inbyte;for_i++)
    {
        result+=(unsigned char)(input_name[for_i]);
    }
    if(result==0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
void extend_dfa_label(char* input_name,int node_size,int* result_null_access)//这里对结果进行空扩展
{
    char* extend_temp;
    int for_i,for_j;
    int size_in_byte;
    unsigned char current_mask;
    int for_k;
    size_in_byte=(node_size+7)/8;
    for_j=0;
    extend_temp=malloc(sizeof(char)*(size_in_byte));//临时的位图
    for(for_i=0;for_i<size_in_byte;for_i++)
    {
        extend_temp[for_i]=0;
    }
    while(for_j<node_size)
    {
        current_mask=BYTE_MASK>>(for_j%8);
        if(input_name[for_j/8]&current_mask)
        {
            for(for_k=0;for_k<node_size;for_k++)
            {
                if(result_null_access[for_j*node_size+for_k])
                {
                    set_dfa_bit(extend_temp,for_k+1);//for_k处在for_k+1位那里
                }
            }
        }
        for_j++;
    }
    for(for_k=0;for_k<size_in_byte;for_k++)//然后把结果复制回去
    {
        input_name[for_k]=extend_temp[for_k];
    }
    free(extend_temp);
}

void null_transition(int index_of_begin)//这里是nfa转dfa的主函数 
{
    int nfa_begin=index_of_begin;//获得起始节点
    int node_size=nfa_min_node_number;
    int for_i,for_k,for_m;
    int for_j;
    //现在需要求传递性闭包，目前为了省事采取四次方的算法，虽然可以做点优化，但是是以空间复杂度为代价的
    //由于是四次方的算法，所以我们需要尽量减少节点的数目，幸运的是，我自己定义的转换规则几乎很少去增加节点
    //这样将大大的有利于效率
    //计算传递性闭包，我采用warshall算法，直接开一个n*n的矩阵
    int* origin_null_access=malloc(sizeof(int)*node_size*node_size);
    int* result_null_access=malloc(sizeof(int)*node_size*node_size);
    int node_size_byte=(node_size+7)/8;
    int alpha_size;
    char* mini_alpha_set;
    int search_result;
    char label;
    pdfa_edge temp_dfa_edge;
    char* begin_nfa_set=malloc(sizeof(char)*(node_size_byte+1));
    char* temp_nfa_set=malloc(sizeof(char)*(node_size_byte+1));
    for(for_i=0;for_i<node_size*node_size;for_i++)
    {
        origin_null_access[for_i]=0;
        result_null_access[for_i]=0;
    }
    for(for_i=0;for_i<=node_size_byte;for_i++)//malloc注意一定要自己去初始化值，否则默认为0xcd操
    {
        begin_nfa_set[for_i]=0;
        temp_nfa_set[for_i]=0;
    }
    for(for_i=1;for_i<=node_size;for_i++)//初始化矩阵
        //注意矩阵下标是从0开始的，而节点下标是从1开始的，引用的时候要小心
    {
        p_edge_list temp;
        temp=nfa_to_dfa[for_i];
        origin_null_access[(for_i-1)*node_size+for_i-1]=1;//由于自己对自己总是可达的
        result_null_access[(for_i-1)*node_size+for_i-1]=1;//同上
        while(temp!=NULL)
        {
            if(temp->label_of_edge==(char)17)
            {
                origin_null_access[(for_i-1)*node_size+temp->destination_number-1]=1;
                result_null_access[(for_i-1)*node_size+temp->destination_number-1]=1;
            }
            temp=temp->next_edge;
        }
    }
    //初始化基础的可达矩阵
    for(for_i=1;for_i<node_size;for_i++)//这里之所以迭代node_size-1次，因为最长简单路径不超过node_size-1条边。
    {
        for(for_j=0;for_j<node_size;for_j++)
        {
            for(for_k=0;for_k<node_size;for_k++)
            {
                int temp=0;
                for(for_m=0;for_m<node_size;for_m++)
                {
                    temp+=result_null_access[for_j*node_size+for_m]*origin_null_access[for_m*node_size+for_k];
                }
                if(temp>0)
                {
                    result_null_access[for_j*node_size+for_k]=1;//可联通
                }
                else
                {
                    result_null_access[for_j*node_size+for_k]=0;//不可联通
                }
            }
        }
    }
    //至此邻接矩阵已经构建完成，现在我们把它变成邻接位图
    node_size_byte=(node_size+7)/8;
    //现在来处理字符集，注意，这里不包括空转换字符
    alpha_size=length_of_char_set();
    mini_alpha_set=malloc(sizeof(char)*alpha_size);
    for(for_i=0;for_i<alpha_size;for_i++)
    {
        mini_alpha_set[for_i]=0;
    }
    minimize_char_set(mini_alpha_set);
    //这里用位图来表示每个点的在某一个字符上的转换集合
    //加上一个，是为了使他变成字符串，这样就好比较了
    //方便了hash和二叉树的插入和寻找
    for(for_i=0;for_i<node_size;for_i++)
    {
        if(result_null_access[(nfa_begin-1)*node_size+for_i]==1)//我擦，这里忘了减少1了
        {
            set_dfa_bit(begin_nfa_set,for_i+1);
        }
    }
    dfa_node_number++;
    current_dfa_table[dfa_node_number].begin=NULL;
    current_dfa_table[dfa_node_number].dfa_hash_number=dfa_into_hash(begin_nfa_set,dfa_node_number,node_size_byte+1);
    current_dfa_node=0;
    while(current_dfa_node<dfa_node_number)
    {
        current_dfa_node++;
        
        for(for_j=0;for_j<alpha_size;for_j++)
        {
            for(for_i=0;for_i<=node_size_byte;for_i++)
            {
                temp_nfa_set[for_i]='';
            }//清空上次的结果 
            label=mini_alpha_set[for_j];//设定转换条件
            tackle_dfa_label(temp_nfa_set,current_dfa_node,label,node_size);//进行边转换
            extend_dfa_label(temp_nfa_set,node_size,result_null_access);//进行空扩展
            if(!is_label_null(temp_nfa_set,node_size_byte))//如果在这个字符上有转换
            {
                search_result=search_dfa_hash(temp_nfa_set);
                if(search_result==-1)//如果为新的状态，则为之建立一个新的节点
                {
                    dfa_node_number++;
                    current_dfa_table[dfa_node_number].begin=NULL;
                    current_dfa_table[dfa_node_number].dfa_hash_number=dfa_into_hash(temp_nfa_set,dfa_node_number,node_size_byte+1);
                    temp_dfa_edge=malloc(sizeof(struct _dfa_edge));//建立一条新的边
                    temp_dfa_edge->next=current_dfa_table[current_dfa_node].begin;
                    temp_dfa_edge->label=mini_alpha_set[for_j];
                    temp_dfa_edge->dest_dfa_index=dfa_node_number;
                    printf("add an node %d
",dfa_node_number);
                    printf("add an edge from %d to %d with label %c
",current_dfa_node,dfa_node_number,mini_alpha_set[for_j]);
                }
                else//如果已经存在这个状态
                {
                    temp_dfa_edge=malloc(sizeof(struct _dfa_edge));
                    temp_dfa_edge->next=current_dfa_table[current_dfa_node].begin;
                    temp_dfa_edge->label=mini_alpha_set[for_j];
                    temp_dfa_edge->dest_dfa_index=dfa_hash_table[search_result].dfa_node_pointer;
                    printf("add an edge from %d to %d with label %c
",current_dfa_node,temp_dfa_edge->dest_dfa_index,mini_alpha_set[for_j]);
                }
                current_dfa_table[current_dfa_node].begin=temp_dfa_edge;//修改邻接表 
            }//对于单字符处理完毕
        }//对于所有的字符都处理完毕了
    }//对于当前节点处理完毕，但是可能还有其他节点，继续迭代。
}//他妈的 nfa转dfa全都处理完毕 
void show_dfa_table(void)//输出邻接表
{ 
    int for_i;
    pdfa_edge temp_dfa_edge;
    for(for_i=1;for_i<=dfa_node_number;for_i++)
    {
        temp_dfa_edge=current_dfa_table[for_i].begin;
        while(temp_dfa_edge!=NULL)
        {
            printf("there is an dfa edge from %d to %d with label %c
",for_i,temp_dfa_edge->dest_dfa_index,temp_dfa_edge->label);
            temp_dfa_edge=temp_dfa_edge->next;
        }
    }
}