nfa转dfa，正式完成
为了加速转换的处理，我压缩了符号表。具体算法参考任何一本与编译或者自动机相关的书籍。
这里的核心问题是处理传递性闭包，transitive closure,这个我目前采取的是最简单的warshall算法，虽然是4次的复杂度，但是由于我构建nfa的时候并没有采取标准的方法，使得nfa的节点减少很多。ps，上上篇所说的re转nfa，我这里有一个修改，就是对于or转换，不再增加节点，而是只增加两条空转换边。
相关代码如下
1 #include "nfa_process.h" 2 //首先在原来的nfa节点中，把最后的那个正则的开始节点可达的那些节点提取出来，相当于又一次的拷贝 3 p_edge_list nfa_to_dfa[100];//这个当作新的nfa图 4 int nfa_min_node_number=0;//注意nfa_min_node_number使用的时候是从1开始的，他的值表示已经使用到了多少 5 #define BYTE_MASK 0x80 6 typedef struct _dfa_edge 7 { 8 struct _dfa_edge* next; 9 char label; 10 int dest_dfa_index; 11 }dfa_edge,*pdfa_edge; 12 typedef struct _dfa_node 13 { 14 pdfa_edge begin; 15 int dfa_hash_number; 16 }dfa_node,*pdfa_node; 17 dfa_node current_dfa_table[400];//由于dfa的数量很大，所以开一个400的数组 18 int dfa_node_number=0;//dfa_node_number作为一个全局变量，用来标号使用 19 int current_dfa_node=0;//这个用来表示处理到了那一个dfa节点了 20 typedef struct _dfa_hash 21 { 22 int in_use; 23 char* name; 24 int dfa_node_pointer; 25 }dfa_hash; 26 dfa_hash dfa_hash_table[400];//400的理由同上，这里刚好397是一个质数 27 void ntd_add_edge(int ntd_node_begin,int ntd_node_end,char label)//在压缩过的 nfa中加边 28 { 29 p_edge_list temp_pnode=malloc(sizeof(struct _graph_edge_list)); 30 temp_pnode->label_of_edge=label; 31 temp_pnode->destination_number=ntd_node_end; 32 temp_pnode->next_edge=nfa_to_dfa[ntd_node_begin]; 33 nfa_to_dfa[ntd_node_begin]=temp_pnode; 34 } 35 int dfa_into_hash(char* input_name,int dfa_node_index,int byte_of_bitmap)//这里是hash插入函数 36 { 37 int for_i; 38 unsigned int result; 39 int counter; 40 char* hash_name; 41 result=0; 42 for(for_i=0;for_i<byte_of_bitmap;for_i++) 43 { 44 result+=(unsigned int) input_name[for_i]; 45 } 46 result=result%397; 47 counter=0; 48 while(counter<397) 49 { 50 if(dfa_hash_table[result].in_use==0) 51 { 52 dfa_hash_table[result].dfa_node_pointer=dfa_node_index; 53 dfa_hash_table[result].in_use=1; 54 hash_name=malloc(sizeof(char)*(byte_of_bitmap+1)); 55 strcpy(hash_name,input_name); 56 dfa_hash_table[result].name=hash_name; 57 return result; 58 } 59 result=(result+1)%397; 60 counter++; 61 } 62 return -1; 63 } 64 int search_dfa_hash(char* input_name)//对于一个名字寻找是否已经在表中 65 { 66 int for_i; 67 unsigned int result; 68 int counter; 69 int byte_of_bitmap=strlen(input_name); 70 result=0; 71 for(for_i=0;for_i<byte_of_bitmap;for_i++) 72 { 73 result+=(unsigned int) input_name[for_i]; 74 } 75 result=result%397; 76 counter=0; 77 while(counter<397) 78 { 79 if(dfa_hash_table[result].in_use==0) 80 { 81 return -1; 82 } 83 else 84 { 85 if(!strcmp(dfa_hash_table[result].name,input_name)) 86 { 87 return result; 88 } 89 else 90 { 91 result=(result+1)%397; 92 counter++; 93 } 94 } 95 } 96 return -1; 97 } 98 99 100 int hamming_distance(int input)//用来得到一个4字节的int里面二进制存在1的个数 101 { 102 int temp=(unsigned)input; 103 temp=(temp&0x55555555)+((temp>>1)&0x55555555); 104 temp=(temp&0x33333333)+((temp>>2)&0x33333333); 105 temp=(temp&0x0f0f0f0f)+((temp>>4)&0x0f0f0f0f); 106 temp=(temp&0x00ff00ff)+((temp>>8)&0x00ff00ff); 107 temp=(temp&0x0000ffff)+((temp>>16)&0x0000ffff); 108 return temp; 109 } 110 int length_of_char_set(void)//计算字符表中的字符的种类 111 { 112 int result=0; 113 result+=hamming_distance(alpha_table.char_one); 114 result+=hamming_distance(alpha_table.char_two); 115 result+=hamming_distance(alpha_table.char_three); 116 result+=hamming_distance(alpha_table.char_four); 117 return result; 118 } 119 120 minimize_char_set(char* mini_set)//压缩字母表 121 { 122 int for_i; 123 unsigned int another_mask; 124 int mini_set_counter; 125 mini_set_counter=for_i=0; 126 for(for_i=0;for_i<32;for_i++) 127 { 128 if(for_i!=17)//对于空转换字符我们不予理睬 129 { 130 another_mask=MASK>>for_i; 131 if(alpha_table.char_one&another_mask) 132 { 133 134 mini_set[mini_set_counter++]=for_i; 135 } 136 } 137 } 138 for(for_i=32;for_i<64;for_i++) 139 { 140 another_mask=MASK>>(for_i%32); 141 if(alpha_table.char_two&another_mask) 142 { 143 mini_set[mini_set_counter++]=for_i; 144 } 145 } 146 for(for_i=64;for_i<96;for_i++) 147 { 148 another_mask=MASK>>(for_i%32); 149 if(alpha_table.char_three&another_mask) 150 { 151 mini_set[mini_set_counter++]=for_i; 152 } 153 } 154 for(for_i=96;for_i<128;for_i++) 155 { 156 another_mask=MASK>>(for_i%32); 157 if(alpha_table.char_four&another_mask) 158 { 159 mini_set[mini_set_counter++]=for_i; 160 } 161 } 162 } 163 164 void set_dfa_bit(char* begin,int index)//在转换节点中设置第index位，这里是从1开始数的，所以要注意 165 { 166 char* temp; 167 index=index-1; 168 temp=begin+index/8; 169 index=index%8; 170 *temp=(unsigned char)(*temp)|(BYTE_MASK>>index); 171 } 172 int extract_nfa(void)//这里是压缩nfa，实质上与前面那个nfa复制函数是一样的 173 //返回开始节点的索引，为了nfa转dfa用 174 { 175 int nfa_begin_number; 176 int nfa_end_number; 177 int copy_destination; 178 int offset; 179 int original_token; 180 char copy_label; 181 p_edge_list pcopy; 182 original_token=token_node_number-1; 183 nfa_begin_number=token_node[original_token].bottom; 184 nfa_end_number=token_node[original_token].top; 185 offset=nfa_min_node_number-nfa_begin_number+1;//因为这样要考虑下一个节点 186 for(nfa_begin_number;nfa_begin_number<=nfa_end_number;nfa_begin_number++)//开始复制图 187 { 188 pcopy=nfa_node[nfa_begin_number]; 189 nfa_min_node_number++; 190 nfa_node[nfa_min_node_number]=NULL; 191 while(pcopy!=NULL) 192 { 193 copy_label=pcopy->label_of_edge; 194 copy_destination=pcopy->destination_number+offset; 195 ntd_add_edge(nfa_min_node_number,copy_destination,copy_label); 196 pcopy=pcopy->next_edge; 197 } 198 } 199 return token_node[original_token].begin+offset; 200 } 201 void tackle_dfa_label(char* output,int dfa_current,char input_label,int node_size)//处理边转换 202 { 203 char* current_nfa_set; 204 int for_i; 205 int dfa_hash_index; 206 p_edge_list temp_edge;//这里处理的还是nfa的边 207 char temp_label=input_label; 208 dfa_hash_index=current_dfa_table[dfa_current].dfa_hash_number; 209 current_nfa_set=dfa_hash_table[dfa_hash_index].name; 210 for(for_i=0;for_i<node_size;for_i++)//对于这个位图中的每一位进行遍历 211 { 212 if((BYTE_MASK>>(for_i%8))&(current_nfa_set[for_i/8]))//如果这个位有效 213 { 214 temp_edge=nfa_to_dfa[for_i+1];//注意这里要加1，因为 nfa_to_table的索引是从1开始的 215 while(temp_edge!=NULL) 216 { 217 if(temp_edge->label_of_edge==temp_label) 218 { 219 set_dfa_bit(output,temp_edge->destination_number);//注意这里不需要减1 220 } 221 temp_edge=temp_edge->next_edge; 222 } 223 } 224 } 225 } 226 227 228 int is_label_null(char* input_name,int name_size_inbyte)//判断一个label是否为空 229 { 230 int result; 231 int for_i; 232 result=0; 233 for(for_i=0;for_i<name_size_inbyte;for_i++) 234 { 235 result+=(unsigned char)(input_name[for_i]); 236 } 237 if(result==0) 238 { 239 return 1; 240 } 241 else 242 { 243 return 0; 244 } 245 } 246 void extend_dfa_label(char* input_name,int node_size,int* result_null_access)//这里对结果进行空扩展 247 { 248 char* extend_temp; 249 int for_i,for_j; 250 int size_in_byte; 251 unsigned char current_mask; 252 int for_k; 253 size_in_byte=(node_size+7)/8; 254 for_j=0; 255 extend_temp=malloc(sizeof(char)*(size_in_byte));//临时的位图 256 for(for_i=0;for_i<size_in_byte;for_i++) 257 { 258 extend_temp[for_i]=0; 259 } 260 while(for_j<node_size) 261 { 262 current_mask=BYTE_MASK>>(for_j%8); 263 if(input_name[for_j/8]¤t_mask) 264 { 265 for(for_k=0;for_k<node_size;for_k++) 266 { 267 if(result_null_access[for_j*node_size+for_k]) 268 { 269 set_dfa_bit(extend_temp,for_k+1);//for_k处在for_k+1位那里 270 } 271 } 272 } 273 for_j++; 274 } 275 for(for_k=0;for_k<size_in_byte;for_k++)//然后把结果复制回去 276 { 277 input_name[for_k]=extend_temp[for_k]; 278 } 279 free(extend_temp); 280 } 281 282 void null_transition(int index_of_begin)//这里是nfa转dfa的主函数 283 { 284 int nfa_begin=index_of_begin;//获得起始节点 285 int node_size=nfa_min_node_number; 286 int for_i,for_k,for_m; 287 int for_j; 288 //现在需要求传递性闭包，目前为了省事采取四次方的算法，虽然可以做点优化，但是是以空间复杂度为代价的 289 //由于是四次方的算法，所以我们需要尽量减少节点的数目，幸运的是，我自己定义的转换规则几乎很少去增加节点 290 //这样将大大的有利于效率 291 //计算传递性闭包，我采用warshall算法，直接开一个n*n的矩阵 292 int* origin_null_access=malloc(sizeof(int)*node_size*node_size); 293 int* result_null_access=malloc(sizeof(int)*node_size*node_size); 294 int node_size_byte=(node_size+7)/8; 295 int alpha_size; 296 char* mini_alpha_set; 297 int search_result; 298 char label; 299 pdfa_edge temp_dfa_edge; 300 char* begin_nfa_set=malloc(sizeof(char)*(node_size_byte+1)); 301 char* temp_nfa_set=malloc(sizeof(char)*(node_size_byte+1)); 302 for(for_i=0;for_i<node_size*node_size;for_i++) 303 { 304 origin_null_access[for_i]=0; 305 result_null_access[for_i]=0; 306 } 307 for(for_i=0;for_i<=node_size_byte;for_i++)//malloc注意一定要自己去初始化值，否则默认为0xcd操 308 { 309 begin_nfa_set[for_i]=0; 310 temp_nfa_set[for_i]=0; 311 } 312 for(for_i=1;for_i<=node_size;for_i++)//初始化矩阵 313 //注意矩阵下标是从0开始的，而节点下标是从1开始的，引用的时候要小心 314 { 315 p_edge_list temp; 316 temp=nfa_to_dfa[for_i]; 317 origin_null_access[(for_i-1)*node_size+for_i-1]=1;//由于自己对自己总是可达的 318 result_null_access[(for_i-1)*node_size+for_i-1]=1;//同上 319 while(temp!=NULL) 320 { 321 if(temp->label_of_edge==(char)17) 322 { 323 origin_null_access[(for_i-1)*node_size+temp->destination_number-1]=1; 324 result_null_access[(for_i-1)*node_size+temp->destination_number-1]=1; 325 } 326 temp=temp->next_edge; 327 } 328 } 329 //初始化基础的可达矩阵 330 for(for_i=1;for_i<node_size;for_i++)//这里之所以迭代node_size-1次，因为最长简单路径不超过node_size-1条边。 331 { 332 for(for_j=0;for_j<node_size;for_j++) 333 { 334 for(for_k=0;for_k<node_size;for_k++) 335 { 336 int temp=0; 337 for(for_m=0;for_m<node_size;for_m++) 338 { 339 temp+=result_null_access[for_j*node_size+for_m]*origin_null_access[for_m*node_size+for_k]; 340 } 341 if(temp>0) 342 { 343 result_null_access[for_j*node_size+for_k]=1;//可联通 344 } 345 else 346 { 347 result_null_access[for_j*node_size+for_k]=0;//不可联通 348 } 349 } 350 } 351 } 352 //至此邻接矩阵已经构建完成，现在我们把它变成邻接位图 353 node_size_byte=(node_size+7)/8; 354 //现在来处理字符集，注意，这里不包括空转换字符 355 alpha_size=length_of_char_set(); 356 mini_alpha_set=malloc(sizeof(char)*alpha_size); 357 for(for_i=0;for_i<alpha_size;for_i++) 358 { 359 mini_alpha_set[for_i]=0; 360 } 361 minimize_char_set(mini_alpha_set); 362 //这里用位图来表示每个点的在某一个字符上的转换集合 363 //加上一个\0，是为了使他变成字符串，这样就好比较了 364 //方便了hash和二叉树的插入和寻找 365 for(for_i=0;for_i<node_size;for_i++) 366 { 367 if(result_null_access[(nfa_begin-1)*node_size+for_i]==1)//我擦，这里忘了减少1了 368 { 369 set_dfa_bit(begin_nfa_set,for_i+1); 370 } 371 } 372 dfa_node_number++; 373 current_dfa_table[dfa_node_number].begin=NULL; 374 current_dfa_table[dfa_node_number].dfa_hash_number=dfa_into_hash(begin_nfa_set,dfa_node_number,node_size_byte+1); 375 current_dfa_node=0; 376 while(current_dfa_node<dfa_node_number) 377 { 378 current_dfa_node++; 379 380 for(for_j=0;for_j<alpha_size;for_j++) 381 { 382 for(for_i=0;for_i<=node_size_byte;for_i++) 383 { 384 temp_nfa_set[for_i]='\0'; 385 }//清空上次的结果 386 label=mini_alpha_set[for_j];//设定转换条件 387 tackle_dfa_label(temp_nfa_set,current_dfa_node,label,node_size);//进行边转换 388 extend_dfa_label(temp_nfa_set,node_size,result_null_access);//进行空扩展 389 if(!is_label_null(temp_nfa_set,node_size_byte))//如果在这个字符上有转换 390 { 391 search_result=search_dfa_hash(temp_nfa_set); 392 if(search_result==-1)//如果为新的状态，则为之建立一个新的节点 393 { 394 dfa_node_number++; 395 current_dfa_table[dfa_node_number].begin=NULL; 396 current_dfa_table[dfa_node_number].dfa_hash_number=dfa_into_hash(temp_nfa_set,dfa_node_number,node_size_byte+1); 397 temp_dfa_edge=malloc(sizeof(struct _dfa_edge));//建立一条新的边 398 temp_dfa_edge->next=current_dfa_table[current_dfa_node].begin; 399 temp_dfa_edge->label=mini_alpha_set[for_j]; 400 temp_dfa_edge->dest_dfa_index=dfa_node_number; 401 printf("add an node %d\n",dfa_node_number); 402 printf("add an edge from %d to %d with label %c\n",current_dfa_node,dfa_node_number,mini_alpha_set[for_j]); 403 } 404 else//如果已经存在这个状态 405 { 406 temp_dfa_edge=malloc(sizeof(struct _dfa_edge)); 407 temp_dfa_edge->next=current_dfa_table[current_dfa_node].begin; 408 temp_dfa_edge->label=mini_alpha_set[for_j]; 409 temp_dfa_edge->dest_dfa_index=dfa_hash_table[search_result].dfa_node_pointer; 410 printf("add an edge from %d to %d with label %c\n",current_dfa_node,temp_dfa_edge->dest_dfa_index,mini_alpha_set[for_j]); 411 } 412 current_dfa_table[current_dfa_node].begin=temp_dfa_edge;//修改邻接表 413 }//对于单字符处理完毕 414 }//对于所有的字符都处理完毕了 415 }//对于当前节点处理完毕，但是可能还有其他节点，继续迭代。 416 }//他妈的 nfa转dfa全都处理完毕 417 void show_dfa_table(void)//输出邻接表 418 { 419 int for_i; 420 pdfa_edge temp_dfa_edge; 421 for(for_i=1;for_i<=dfa_node_number;for_i++) 422 { 423 temp_dfa_edge=current_dfa_table[for_i].begin; 424 while(temp_dfa_edge!=NULL) 425 { 426 printf("there is an dfa edge from %d to %d with label %c\n",for_i,temp_dfa_edge->dest_dfa_index,temp_dfa_edge->label); 427 temp_dfa_edge=temp_dfa_edge->next; 428 } 429 } 430 } 431 432 433 434 435 436
