状态机按列开始 逐个打表，导致好理解，但是不好写，没有回溯，++ 重复

 

状态矩阵有行列，按行，会进入最终状态，按列，就没有了回溯

PL0 语法分析器 状态机 最后\0 单独检测发现可合并代码-优快云博客

 可用于对比

按行，终态代码少

#include <stdio.h>
#include <string.h>
//#include <ctype.h>

#define END 6			// 状态机回退检测
#define CHECK 7
#define ERROR 8
// 状态机设计
// 0 行不用
// 0 列不用
//列查找按代号查询
// 代号是经过合并如123456789是数字合并为1 就是第一列
//延续状态机，改终止状态，当没有字符输入时，当前状态就是要进行判断的状态


//提示，可使用如下二维数组存储DFA。
//一个状态对应一行；一个输入符号（digit/other）对应一列。
//每看到输入字符串中一个符号，就以当且状态为行号，
//看到的符号为列号查询下个状态作为当前状态。

// 以下状态机画了一周画了三次图，写了三种状态数组
int  integerDFA[][7] = {
	// 符号，下个状态
	//  space 	letter 	digit 	calculate 	border  other
	{0, 	0,	 	0, 		0, 		0, 		0, 		0},
	{0, 	1,	 	2, 		3, 		4, 		5, 		ERROR},						// 状态1 就绪
	{0, 	END,	2, 		2, 		CHECK, 	END, 	ERROR},						// 状态2 标识符
	{0, 	END, 	3, 		3, 		END,	END,	ERROR},						// 状态3 数字，0b带，0x之流，后续检测字符，因只一个字母接数字后。
	{0, 	END, 	END, 	END,	4, 		END,	ERROR},						// 状态4 运算符，由于有+,<= 这种一个两个，所以后续还得检测<<<这样是否合法的代码
	{0, 	ERROR,	ERROR, 	ERROR, 	ERROR, 	ERROR,	ERROR},						// 状态5 边界,;.直接结束
	{0, 	0,	 	0, 		0, 		0, 		0, 		0},							// 状态6 最先于字母结束还要再次判断最后是什么字符导致的变动，用于合规检测当前字符
	{0, 	0,	 	0, 		0, 		0, 		0, 		0},							// 状态7 同状态6，但是发现void+ 这样会有BUG，用于标识符识别为保留字再次检测符号合法否。
	{0, 	0,	 	0, 		0, 		0, 		0, 		0},							// 状态8 想新BUG，发现有￥这样字符，直接报错
	
	
};

// 12 个保留字

char ident[100][100] = {
	"begin",
	"call",
	"const",
	"do",
	"end",
	"if",
	"procedure",
	"read",
	"then",
	"var",
	"while",
	"write",
};

// 11个运算符
char calculate[100][100] = {
	"+",
	"-",
	"*",
	"/",
	"=",
	"<>",
	"<",
	"<=",
	">",
	">=",
	":=",
};
// 对应运算符序号，用于查表
char calcu[100][100] = {
	"plus", "minus", "times", "slash", "eql", "neq", "lss", "leq", "gtr", "gep", "becomes",
};
// 五个界符
char board[100][100] = {
	"(",
	")",
	",",
	";",
	".",
};
// 界符对应名字
char boardname[100][100] = {
	"lparen",
	"rparen",
	"comma",
	"semicolon",
	"period",
};

int have = 12;
//int


int statu;						// 当前状态
int old_sta;					// 上一个状态
FILE* fp;
FILE* fa2;

int lenth = 10000;
char* str = new char[1200];				// 循环读取文件，分200字节读取
char** cmd = new char*[lenth];			// 词元存储
int* sign = new int[lenth];				//  对应词元的标识
int cnt = 0;							// 分割词元个数
int num = 0;							// 当前字符填充位置


// 是空白符
int isspace(char* p) {
	if (*p == ' ' || *p == '\n' || *p == '\0') {
		return 1;
	}
	return 0;
}
//是字母
int isletter(char* p) {
	if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')) {
		return 1;
	}
	return 0;
//	return isalpha(*p);
	
}
// 是数字
int isnum(char* p) {
	if (*p >= '0' && *p <= '9') {
		return 1;
	}
	return 0;
}

// 是calculate 是运算符
int iscalculate(char* p) {
	if (*p == ':' || *p == '+' || *p == '-' || *p == '*' || *p == '/' || *p == '<' || *p == '=' || *p == '>') {
		return 1;
	}
	
	return 0;
}
// 是界符号
int isborder(char* p) {
	if (*p == ';' || *p == ',' || *p == '.' || *p == '(' || *p == ')') {
		return 1;
	}
	return 0;
}

// 查空白符号，字符，数字，运算符号，界符号，乱码字符
int transchar(char* p) {
	int a = 0;
	int b = 0;
	int c = 0;
	int d = 0;
	int e = 0;
	a = isspace(p);
	b = isletter(p);
	c = isnum(p);
	d = iscalculate(p);
	e = isborder(p);
	
	if (a != 0) {
//		printf("isspace\n");
		return 1;
	} else if (b != 0) {
		return 2;							// 不是return b,c,d,e,因为都是1
	} else if (c != 0) {
		return 3;
	} else if (d != 0) {
		return 4;
	} else if (e != 0) {
		return 5;
	} else {
		return 6;
	}
	
}

// num先写数据后 num++
//这样判断cmd是否空 ，否则0时不知道数据有无
// 这个版本只有 123458状态可用，减少了状态使用
void checkv2(char* str) {
	int checknum;
	checknum = 10;
	int flag = 0;						// 少例外结果代码
	char*p = str;
	while (1) {		// 在*p = '\0'时多跑一次，避免重复写代码
		
//		printf("%c\n", *p);
		if (isspace(p)) {
			if (statu == 1) {
				statu = integerDFA[1][1];
				num = 0;
			} else if (statu == 2 || statu == 3 || statu == 4) {
				cmd[cnt][num] = '\0';
				sign[cnt] = statu;
				cnt++;
				num = 0;
				statu = 1;
			}  else if (statu == 8) {
//				printf("发现非法字符2233 %c\n", *p);
				statu = 1;
			}
		} else if (isletter(p)) {
			if (statu == 1) {
				statu = integerDFA[1][2];
				cmd[cnt][num] = *p;
				num++;
			} else if (statu == 2) {
				statu = integerDFA[2][2];
				cmd[cnt][num] = *p;
				num++;
			} else if (statu == 3) {
				statu = integerDFA[3][2];
				cmd[cnt][num] = *p;
				num++;
			} else if (statu == 4) {
				
				cmd[cnt][num] = '\0';
				sign[cnt] = 4;
				num = 0;
				cnt++;
				
				statu = integerDFA[1][2];
				cmd[cnt][num] = *p;
				num++;
			} else if (statu == 5) {
				
			} else if (statu == 8) {
//				printf("发现非法字符");
				statu = 1;
			}
			
		} else if (isnum(p)) {
			if (statu == 1) {
				statu = integerDFA[1][3];
				cmd[cnt][num] = *p;
				num++;
			} else if (statu == 2) {
//				statu = 1;
//				cmd[cnt][num] = '\0';
//				sign[cnt] = 2;
//				cnt++;
//				num = 0;
				// 数字后面接字母，字母后面接数字根据状态选
				cmd[cnt][num] = *p;
				num++;
				statu = integerDFA[2][3];					//是 2，3
			} else if (statu == 3) {
				statu = integerDFA[3][3];
				cmd[cnt][num] = *p;
				num++;
			} else if (statu == 4) {
				cmd[cnt][num] = '\0';
				sign[cnt] = 4;
				cnt++;
				num = 0;
				cmd[cnt][num] = *p;
				num++;
				statu = integerDFA[1][3];
			} else if (statu == 5) {
				printf("5555\n");
			} else if (statu == 8) {
				
			}
		} else if (iscalculate(p)) {
			if (statu == 1) {
				statu = integerDFA[1][4];
				cmd[cnt][num] = *p;
				num++;
			} else if (statu == 2) {
				statu = 1;
				cmd[cnt][num] = '\0';
				sign[cnt] = 2;
				cnt++;
				num = 0;
				cmd[cnt][num] = *p;
				num++;
				statu = 1;
				statu = integerDFA[1][4];
			} else if (statu == 3) {
				cmd[cnt][num] = '\0';
				sign[cnt] = 3;
				cnt++;
				num = 0;
				cmd[cnt][num] = *p;
				num++;
				statu = 1;
				statu = integerDFA[1][4];
			} else if (statu == 4) {
				cmd[cnt][num] = *p;
				sign[cnt] = statu;
				num++;
				statu = integerDFA[4][4];
			}
		} else if (isborder(p)) {						// 边界直接截断，查是否空
			
			if (num != 0) {
				cmd[cnt][num] = '\0';
				sign[cnt] = statu;
//				printf("%s\n", cmd[cnt]);
				num = 0;
				cnt++;
			}
			
			cmd[cnt][num] = *p;
			num++;
			cmd[cnt][num] = '\0';
			sign[cnt] = 5;
			cnt++;
			num = 0;
			statu = 1;
			
		} else {
			statu = 8;
			if (flag == 0)
				printf("发现非法字符eae --%c--\n", *p);
			statu = 1;
		}
		
		// flag  要提前，否则p++继续，导致*p !='\0',所以flag先查退出
		if (*p == '\0') {
			break;
		}
		
		p++;
		printf("%d\n", statu);
	}
	
	statu = 1;
	num = 0;
	
}


void init_cmd() {
	for (int i = 0; i < lenth; i++) {
		cmd[i] = new char[200];
		
	}
	// 分词存储先清空杂乱数据
	for (int i = 0; i < lenth; i++) {
		for (int j = 0; j < 200; j++) {
			cmd[i][j] = '\0';
		}
	}
	cnt = 0;
	num = 0;
}

void init_statu() {
	statu = 1;
	old_sta = 1;
}


int find_reserve(char* str) {
	for (int i = 0; i < have; i++) {
		if (strcmp(str, ident[i]) == 0) {
			return 1;
		}
	}
	return -1;
}

int find_calculate(char* str) {
	for (int i = 0; i < 11; i++) {
		if (strcmp(str, calculate[i]) == 0) {
			return i;
		}
	}
	return -1;
}

int find_borad(char* str) {
	for (int i = 0; i < 5; i++) {
		if (strcmp(str, board[i]) == 0) {
			return i;
		}
	}
	return -1;
}

int main() {
	
	
	fp = fopen("input.txt", "r");
	fa2 = fopen("output.txt", "w");
	
	init_cmd();
	
	init_statu();
	
//	分割词语
//	while (fgets(str, 200, fp) != NULL) {
	// 利用scanf 读取吸收回车，而希冀里不能执行   '\n'的比较
	while (fscanf(fp, "%s", str) != EOF) {
		
		// 处理回车，有些回车读取会影响代码结果
		if (str[0] == '\n' && strlen(str) == 1) {
			continue;
		} else if (str[strlen(str) - 1 ] == '\n') {					//			发现文末回车
			str[strlen(str) - 1 ] = '\0';
		}
		// 剥离成函数使用
		
		checkv2(str);
		
		
	}
	
//	对每个单词进行检查
	// 这样解决不知道什么时候根据状态进行结束的问题。字符连续，没有字符了就根据状态给结论。
	for (int i = 0; i < cnt; i++) {
		
//		printf("%d\n", i);
//		printf("--%s--\n", cmd[i]);
//		printf("%d\n", sign[i]);
		
		if (sign[i] == 2) {									// 如果是字母打头的
			if (find_reserve(cmd[i]) != -1) {
				printf("( %ssym, %s )\n", cmd[i], cmd[i]);
			} else {
				printf("( IDENT, %s )\n", cmd[i]);
			}
		} else if (sign[i] == 3) {							// 如果是数字打头的
			printf("( NUMBER, %s )\n", cmd[i]);
		} else if (sign[i] == 4) {
			int a = 0;
			a = find_calculate(cmd[i]);
			if (a != -1) {
//				printf("%d", a);
				printf("( %s, %s )\n", calcu[a], cmd[i]);
			} else {
				printf("非法的运算符 --%s--\n", cmd[i]);
			}
		} else if (sign[i] == 5) {
			int a = 0;
			a = find_borad(cmd[i]);
			if (a != -1) {
				printf("( %s, %s )\n", boardname[a], cmd[i]);
			} else {
				printf("非法的边界符号 --%s--\n", cmd[i]);
			}
		}
		
		
		if (sign[i] == 2) {									// 如果是字母打头的
			if (find_reserve(cmd[i]) != -1) {
				fprintf(fa2, "( %ssym, %s )\n", cmd[i], cmd[i]);
				
			} else {
				fprintf(fa2, "( IDENT, %s )\n", cmd[i]);
				sign[i] = 22;									// 标记为自定义的标识符号
			}
		} else if (sign[i] == 3) {							// 如果是数字打头的
			fprintf(fa2, "( NUMBER, %s )\n", cmd[i]);
		} else if (sign[i] == 4) {
			int a = 0;
			a = find_calculate(cmd[i]);
			if (a != -1) {
//				printf("%d", a);
				fprintf(fa2, "( %s, %s )\n", calcu[a], cmd[i]);
			} else {
				fprintf(fa2, "非法的运算符 --%s--\n", cmd[i]);
			}
		} else if (sign[i] == 5) {
			int a = 0;
			a = find_borad(cmd[i]);
			if (a != -1) {
				fprintf(fa2, "( %s, %s )\n", boardname[a], cmd[i]);
			} else {
				fprintf(fa2, "非法的边界符号 --%s--\n", cmd[i]);
			}
		}
		
//		fprintf(fa2, "(%d,%s)\n", cmd[i], sign[i]);
	}
	
	fclose(fa2);
	fclose(fp);
	
	return 0;
}