一个简单的C语言语法检查器的实现
Posted PoorLitt1eThin9
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了一个简单的C语言语法检查器的实现相关的知识，希望对你有一定的参考价值。
我自己的实现方法的核心过程：首先用一个非终结符代表所有要检查的程序代码，然后根据文法将这个整体的符号不断展开，以拼凑成按检查的程序的顺序排列的终结符序列，能成功说明语法正确，否则有错误。
关键词：分词；First集；Select集；
目前还存在的问题：
1.因为同一个非终结符->终结符的转化可能有多种解释，所以目前我的非终结符展开这里是用递归写的，因此不能定位具体错在哪里。
2.int a={1,2};int a[2]={1,\'b\'};这种该出错的地方不会出错。这个比较致命，但目前还没想好怎么解决。
代码部分借鉴了这里，我直接用了他的分词的scnner函数和宏定义的部分。他的程序总共2000+行，我改了一下，总共只用1000行就实现了他的功能，其中500行是抄的他的分词......并且修改了他的程序里的一些错误。
Grammar.txt：文法的定义
<程序闭包> -> <声明语句闭包> #
<程序闭包> -> <函数定义> #
<程序闭包> -> $ #
<函数定义> -> <修饰词闭包> <类型> <变量> ( <参数声明> ) { <函数块> } #
<修饰词闭包> -> <修饰词> <修饰词闭包> #
<修饰词闭包> -> $ #
<修饰词> -> describe #
<类型> -> type <取地址> #
<取地址> -> <星号闭包> #
<星号闭包> -> <星号> <星号闭包> #
<星号闭包> -> $ #
<星号> -> * #
<变量> -> <标志符> <数组下标> #
<标志符> -> id #
<数组下标> -> [ <因式> ] #
<数组下标> -> $ #
<因式> -> ( <表达式> ) #
<因式> -> <变量> #
<因式> -> <数字> #
<数字> -> digit #
<数字> -> string #
<表达式> -> <因子> <项> #
<因子> -> <因式> <因式递归> #
<因式递归> -> * <因式> <因式递归> #
<因式递归> -> / <因式> <因式递归> #
<因式递归> -> $ #
<项> -> + <因子> <项> #
<项> -> - <因子> <项> #
<项> -> $ #
<参数声明> -> <声明> <声明闭包> #
<参数声明> -> $ #
<声明> -> <修饰词闭包> <类型> <变量> <赋初值> #
<赋初值> -> = <右值> #
<赋初值> -> $ #
<右值> -> <表达式> #
<右值> -> { <多个数据> } #
<多个数据> -> <数字> <数字闭包> #
<数字闭包> -> , <数字> <数字闭包> #
<数字闭包> -> $ #
<声明闭包> -> , <声明> <声明闭包> #
<声明闭包> -> $ #
<函数块> -> <声明语句闭包> <函数块闭包> #
<声明语句闭包> -> <声明语句> <声明语句闭包> #
<声明语句闭包> -> $ #
<声明语句> -> <声明> ; #
<函数块闭包> -> <赋值函数> <函数块闭包> #
<函数块闭包> -> <for循环> <函数块闭包> #
<函数块闭包> -> <条件语句> <函数块闭包> #
<函数块闭包> -> <函数返回> <函数块闭包> #
<函数块闭包> -> $ #
<赋值函数> -> <变量> <赋值或函数调用> #
<赋值或函数调用> -> = <右值> ; #
<赋值或函数调用> -> ( <参数列表> ) ; #
<参数列表> -> <参数> <参数闭包> #
<参数闭包> -> , <参数> <参数闭包> #
<参数闭包> -> $ #
<参数> -> <标志符> #
<参数> -> <数字> #
<参数> -> <字符串> #
<字符串> -> string #
<for循环> -> for ( <赋值函数> <逻辑表达式> ; <后缀表达式> ) { <函数块> } #
<逻辑表达式> -> <表达式> <逻辑运算符> <表达式> #
<逻辑运算符> -> < #
<逻辑运算符> -> > #
<逻辑运算符> -> == #
<逻辑运算符> -> != #
<后缀表达式> -> <变量> <后缀运算符> #
<后缀运算符> -> ++ #
<后缀运算符> -> -- #
<条件语句> -> if ( <逻辑表达式> ) { <函数块> } <否则语句> #
<否则语句> -> else { <函数块> } #
<否则语句> -> $ #
<函数返回> -> return <因式> ; #
Grammar.cpp：主程序
#include "initialize.h"
int main() {
Init();
Scan();
Analyse();
getchar();
return 0;
}
initialize.h：初始化
#ifndef __INIT__
#define __INIT__
#include "WA.h"
#include "SA.h"
#include "Macro_Struct.h"
void InitKeyMap() {
keyMap.clear();
keyMap.push_back(make_pair("auto", AUTO));
keyMap.push_back(make_pair("break", BREAK));
keyMap.push_back(make_pair("case", CASE));
keyMap.push_back(make_pair("char", CHAR));
keyMap.push_back(make_pair("const", CONST));
keyMap.push_back(make_pair("continue", CONTINUE));
keyMap.push_back(make_pair("default", DEFAULT));
keyMap.push_back(make_pair("do", DO));
keyMap.push_back(make_pair("double", DOUBLE));
keyMap.push_back(make_pair("else", ELSE));
keyMap.push_back(make_pair("enum", ENUM));
keyMap.push_back(make_pair("extern", EXTERN));
keyMap.push_back(make_pair("float", FLOAT));
keyMap.push_back(make_pair("for", FOR));
keyMap.push_back(make_pair("goto", GOTO));
keyMap.push_back(make_pair("if", IF));
keyMap.push_back(make_pair("int", INT));
keyMap.push_back(make_pair("long", LONG));
keyMap.push_back(make_pair("register", REGISTER));
keyMap.push_back(make_pair("return", RETURN));
keyMap.push_back(make_pair("short", SHORT));
keyMap.push_back(make_pair("signed", SIGNED));
keyMap.push_back(make_pair("sizeof", SIZEOF));
keyMap.push_back(make_pair("static", STATIC));
keyMap.push_back(make_pair("struct", STRUCT));
keyMap.push_back(make_pair("switch", SWITCH));
keyMap.push_back(make_pair("typedef", TYPEDEF));
keyMap.push_back(make_pair("union", UNION));
keyMap.push_back(make_pair("unsigned", UNSIGNED));
keyMap.push_back(make_pair("void", VOID));
keyMap.push_back(make_pair("volatile", VOLATILE));
keyMap.push_back(make_pair("while", WHILE));
keyMap.push_back(make_pair("describe", DESCRIBE));
keyMap.push_back(make_pair("type", TYPE));
//keyMap.push_back(make_pair("string", STRING));
keyMap.push_back(make_pair("digit", DIGIT));
}
void InitOperMap() {
operMap.clear();
operMap.push_back(make_pair("!", NOT));
operMap.push_back(make_pair("&", BYTE_AND));
operMap.push_back(make_pair("~", COMPLEMENT));
operMap.push_back(make_pair("^", BYTE_XOR));
operMap.push_back(make_pair("*", MUL));
operMap.push_back(make_pair("/", DIV));
operMap.push_back(make_pair("%", MOD));
operMap.push_back(make_pair("+", ADD));
operMap.push_back(make_pair("-", SUB));
operMap.push_back(make_pair("<", LES_THAN));
operMap.push_back(make_pair(">", GRT_THAN));
operMap.push_back(make_pair("=", ASG));
operMap.push_back(make_pair("->", ARROW));
operMap.push_back(make_pair("++", SELF_ADD));
operMap.push_back(make_pair("--", SELF_SUB));
operMap.push_back(make_pair("<<", LEFT_MOVE));
operMap.push_back(make_pair(">>", RIGHT_MOVE));
operMap.push_back(make_pair("<=", LES_EQUAL));
operMap.push_back(make_pair(">=", GRT_EQUAL));
operMap.push_back(make_pair("==", EQUAL));
operMap.push_back(make_pair("!=", NOT_EQUAL));
operMap.push_back(make_pair("&&", AND));
operMap.push_back(make_pair("||", OR));
operMap.push_back(make_pair("+=", COMPLETE_ADD));
operMap.push_back(make_pair("-=", COMPLETE_SUB));
operMap.push_back(make_pair("*=", COMPLETE_MUL));
operMap.push_back(make_pair("/=", COMPLETE_DIV));
operMap.push_back(make_pair("^=", COMPLETE_BYTE_XOR));
operMap.push_back(make_pair("&=", COMPLETE_BYTE_AND));
operMap.push_back(make_pair("~=", COMPLETE_COMPLEMENT));
operMap.push_back(make_pair("%=", COMPLETE_MOD));
operMap.push_back(make_pair("|", BYTE_OR));
}
void InitLimitMap() {
limitMap.clear();
limitMap.push_back(make_pair("(", LEFT_BRA));
limitMap.push_back(make_pair(")", RIGHT_BRA));
limitMap.push_back(make_pair("[", LEFT_INDEX));
limitMap.push_back(make_pair("]", RIGHT_INDEX));
limitMap.push_back(make_pair("{", L_BOUNDER));
limitMap.push_back(make_pair("}", R_BOUNDER));
limitMap.push_back(make_pair(".", POINTER));
limitMap.push_back(make_pair("#", JING));
limitMap.push_back(make_pair("_", UNDER_LINE));
limitMap.push_back(make_pair(",", COMMA));
limitMap.push_back(make_pair(";", SEMI));
limitMap.push_back(make_pair("\'", SIN_QUE));
limitMap.push_back(make_pair("\\"", DOU_QUE));
}
void ShowExprList() {
for (int i = 0; i < ExprNum; i++) {
printf("%s -> ", Signature[Expr[i][0]].first);
for (int j = 2; j <= Expr[i][1]; j++) {
printf("%s ", Signature[Expr[i][j]].first);
}
printf("\\n");
}
}
void DFS_NullPossibility(int x) {
//printf("%s\\n",Signature[x].first);
if (visited[x]) {
return;
}
visited[x] = true;
for (int i = 0; i < ExprNum; i++) {
if (Expr[i][0] != x) {
continue;
}
bool ret = true;
for (int j = 2; j <= Expr[i][1]; j++) {
DFS_NullPossibility(Expr[i][j]);
ret &= canBeNull[Expr[i][j]];
}
if (ret) {
visited[x] = true;
canBeNull[x] = true;
return;
}
}
}
void ReadExpr() {
Signature.clear();
ifstream fin("Grammar.txt");
char str[50][50];
int Length = 0;
while (fin >> str[Length]) {
if (strcmp(str[Length], "#") == 0) {
for (int i = 0; i < Length; i++) {
if (strcmp(str[i], "->") == 0) {
Expr[ExprNum][i] = Length - 1;
continue;
}
int signID = FindSignature(str[i]);
if (signID == -1) {
int tempLen = strlen(str[i]);
if (str[i][0] == \'<\' && str[i][tempLen - 1] == \'>\') {
pair<char *, bool> tempPair;
tempPair.first = new char [tempLen + 1];
memcpy(tempPair.first, str[i], tempLen);
tempPair.first[tempLen] = \'\\0\';
tempPair.second = Scalable;
Signature.push_back(tempPair);
} else {
pair<char *, bool> tempPair;
tempPair.first = new char [tempLen + 1];
memcpy(tempPair.first, str[i], tempLen);
tempPair.first[tempLen] = \'\\0\';
tempPair.second = unScalsble;
Signature.push_back(tempPair);
}
signID = Signature.size() - 1;
}
Expr[ExprNum][i] = signID;
}
Length = 0;
ExprNum++;
} else {
Length++;
}
}
fin.close();
memset(canBeNull, false, sizeof(canBeNull));
for (int i = 0; i < Signature.size(); i++) {
if (strcmp(Signature[i].first, "$") == 0) {
canBeNull[i] = true;
}
}
memset(visited, false, sizeof(visited));
for (int i = 0; i < Signature.size(); i++) {
if (Signature[i].second == Scalable) {
DFS_NullPossibility(i);
}
}
//ShowExprList();
}
void DFS_FirstSet(int x) {
if (visited[x] || Signature[x].second == unScalsble) {
return;
}
visited[x] = true;
for (int i = 0; i < ExprNum; i++) {
if (Expr[i][0] != x) {
continue;
}
for (int j = 2; j <= Expr[i][1]; j++) {
if (Signature[Expr[i][j]].second == unScalsble) {
First[x][Expr[i][j]] = true;
} else {
DFS_FirstSet(Expr[i][j]);
for (int k = 0; k < Signature.size(); k++) {
if (First[Expr[i][j]][k]) {
First[x][k] = true;
}
}
}
if (!canBeNull[Expr[i][j]]) {
break;
}
}
}
}
void GetFirstSet() {
memset(First, false, sizeof(First));
memset(visited, false, sizeof(visited));
for (int i = 0; i < Signature.size(); i++) {
if (Signature[i].second == unScalsble) {
continue;
}
DFS_FirstSet(i);
}
}
void GetFollowSet() {}
void GetSelectSet() {
memset(Select, false, sizeof(Select));
for (int i = 0; i < ExprNum; i++) {
for (int j = 2; j <= Expr[i][1]; j++) {
if (Signature[Expr[i][j]].second == unScalsble) {
Select[i][Expr[i][j]] = true;
} else {
for (int k = 0; k < Signature.size(); k++) {
if (First[Expr[i][j]][k]) {
Select[i][k] = true;
}
}
}
if (!canBeNull[Expr[i][j]]) {
break;
}
}
if (!canBeNull[Expr[i][0]]) {
Select[i][FindSignature("$")] = false;
}
}
}
void ShowShiftList() {
for (int i = 0; i < Signature.size(); i++) {
for (int j = 0; j < Signature.size(); j++) {
if (ShiftList[i][j][0][0] <= 1 || i == j) {
continue;
}
printf("%3d %30s -> %30s\\n", ShiftList[i][j][0][0], Signature[i].first, Signature[j].first);
for (int k = 1; k <= ShiftList[i][j][0][0]; k++) {
printf("---------->");
for (int h = 1; h <= ShiftList[i][j][k][0]; h++) {
printf("%s ", Signature[ShiftList[i][j][k][h]].first);
}
printf("\\n");
}
}
}
}
void GetShiftList() {
memset(ShiftList, 0, sizeof(ShiftList));
for (int i = 0; i < ExprNum; i++) {
for (int j = 0; j < Signature.size(); j++) {
if (!Select[i][j]) {
continue;
}
/*if (Signature[j].second == Scalable) {
printf("OMG\\n");
}*/
ShiftList[Expr[i][0]][j][0][0]++;
for (int k = 1; k <= Expr[i][1]; k++) {
ShiftList[Expr[i][0]][j][ShiftList[Expr[i][0]][j][0][0]][k - 1] = Expr[i][k];
}
ShiftList[Expr[i][0]][j][ShiftList[Expr[i][0]][j][0][0]][0]--;
}
}
//ShowShiftList();
}
void Init() {
InitKeyMap();
InitOperMap();
InitLimitMap();
tokenList.clear();
errorList.clear();
ReadExpr();
GetFirstSet();
GetFollowSet();
GetSelectSet();
GetShiftList();
}
#endif
WA.h：词法分析
#ifndef __WA__
#define __WA__
#include "stdafx.h"
#include "Macro_Struct.h"
vector<pair<const char *, int>> keyMap;
vector<pair<const char *, int>> operMap;
vector<pair<const char *, int>> limitMap;
vector<Token> tokenList;
vector<Error> errorList;
int SeekKey(char * word) {
for (int i = 0; i < keyMap.size(); i++) {
if (strcmp(word, keyMap[i].first) == 0) {
return keyMap[i].second;
}
}
return IDENTIFER;
}
void InsertToken(char * content, char * describe, int type, int line) {
Token tempToken;
strcpy_s(tempToken.content, content);
strcpy_s(tempToken.describe, describe);
tempToken.type = type;
tempToken.line = line;
tokenList.push_back(tempToken);
}
void InsertError(char * content, char * describe, int type, int line) {
Error tempError;
strcpy_s(tempError.content, content);
strcpy_s(tempError.describe, describe);
tempError.type = type;
tempError.line = line;
errorList.push_back(tempError);
printf("Line %d:%s\\n", line, describe);
}
void preProcess(char * word, int line) {
regex INCLUDE_REGEX("#include\\\\s*<[\\\\w\\\\.]+>\\\\s*");
regex DEFINE_REGEX("#define\\\\s+\\\\w+\\\\s+\\\\w+\\\\s*");
if (regex_match(word, INCLUDE_REGEX)) {
return;
}
if (regex_match(word, DEFINE_REGEX)) {
return;
}
InsertError(word, PRE_PROCESS_ERROR, PRE_PROCESS_ERROR_NUM, line);
}
void Scan() {
char ch;
char array[30];//单词长度上限是30
char * word;
int i;
int line = 1;//行数
FILE * infile;
errno_t err = fopen_s(&infile, "input.txt", "r");
ch = fgetc(infile);
while (ch != EOF) {
i = 0;
//以字母或者下划线开头,处理关键字或者标识符
if ((ch >= \'A\' && ch <= \'Z\') || (ch >= \'a\' && ch <= \'z\') || ch == \'_\') {
while ((ch >= \'A\' && ch <= \'Z\') || (ch >= \'a\' && ch <= \'z\') || (ch >= \'0\' && ch <= \'9\') || ch == \'_\') {
array[i++] = ch;
ch = fgetc(infile);
}
word = new char[i + 1];
memcpy(word, array, i);
word[i] = \'\\0\';
int seekTemp =以上是关于一个简单的C语言语法检查器的实现的主要内容，如果未能解决你的问题，请参考以下文章