LiuYuanchi
/
compiler-temp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[style]初步工程化

This commit is contained in:
LiuYuanchi 2024-05-10 23:10:48 +08:00
parent aa7f674b96
commit c8f827a54c
6 changed files with 232 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
.vscode/settings.json vendored
View File

@ -6,6 +6,44 @@
"vector": "cpp", "vector": "cpp",
"*.tcc": "cpp", "*.tcc": "cpp",
"iostream": "cpp", "iostream": "cpp",
"map": "cpp" "map": "cpp",
"array": "cpp",
"atomic": "cpp",
"cctype": "cpp",
"clocale": "cpp",
"cmath": "cpp",
"cstdarg": "cpp",
"cstddef": "cpp",
"cstdint": "cpp",
"cstdio": "cpp",
"cstdlib": "cpp",
"cstring": "cpp",
"cwchar": "cpp",
"cwctype": "cpp",
"deque": "cpp",
"unordered_map": "cpp",
"unordered_set": "cpp",
"exception": "cpp",
"algorithm": "cpp",
"memory": "cpp",
"memory_resource": "cpp",
"optional": "cpp",
"set": "cpp",
"string": "cpp",
"string_view": "cpp",
"system_error": "cpp",
"tuple": "cpp",
"type_traits": "cpp",
"utility": "cpp",
"fstream": "cpp",
"initializer_list": "cpp",
"iosfwd": "cpp",
"istream": "cpp",
"limits": "cpp",
"new": "cpp",
"sstream": "cpp",
"stdexcept": "cpp",
"streambuf": "cpp",
"typeinfo": "cpp"
} }
} }

4
CMakeLists.txt
View File

@ -3,7 +3,7 @@ project(compiler-bin)
# 收集所有的cpp源文件 # 收集所有的cpp源文件
file(GLOB SOURCES_LL "LL1/*.cpp") file(GLOB SOURCES_LL "LL1/*.cpp")
file(GLOB SOURCES_NFA "nfa/*.cpp") file(GLOB SOURCES_NFA "nfa/src/*.cpp")
file(GLOB SOURCES_MAIN "main/*.cpp") file(GLOB SOURCES_MAIN "main/*.cpp")
# 设置输出目录为 bin # 设置输出目录为 bin
@ -15,7 +15,7 @@ add_library(nfa STATIC ${SOURCES_NFA})
# 添加头文件目录 # 添加头文件目录
target_include_directories(LL PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/LL1) target_include_directories(LL PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/LL1)
target_include_directories(nfa PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/nfa) target_include_directories(nfa PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/nfa/include)
# 添加可执行文件 # 添加可执行文件
add_executable(main ${SOURCES_MAIN}) add_executable(main ${SOURCES_MAIN})

33
nfa/include/nfa.h
View File

@ -1,7 +1,4 @@
#pragma once #pragma once
#ifndef __NFA__H__
#define __NFA__H__
#include <map> #include <map>
#include <set> #include <set>
#include <deque> #include <deque>
@ -14,14 +11,17 @@
#include <stack> #include <stack>
#include <queue> #include <queue>
#include <algorithm> #include <algorithm>
#include <unordered_map>
using namespace std; using namespace std;
//单词符号的类型，返回<待测代码中的单词符号,WordType> //单词符号的类型，返回<待测代码中的单词符号,WordType>
//当识别成标识符后，先判断是不是保留字，让后再判断IDN //当识别成标识符后，先判断是不是保留字，让后再判断IDN
// Token 类型定义 // Token 类型定义
typedef enum WordType { enum class WordType {
//关键字 //关键字
KW_INT = 0, // int KW_INT = 0, // int
@ -63,11 +63,11 @@ typedef enum WordType {
FLOAT_VAL, // -?[0-9]+\\.[0-9]+ FLOAT_VAL, // -?[0-9]+\\.[0-9]+
UNKOWN UNKOWN
}WordType; };
string getWordTypeName(WordType type); extern std::unordered_map<WordType, std::string> WordTypeNames;
// 定义输入的字符类别 // 定义输入的字符类别
typedef enum InputCharType { enum class InputCharType {
LETTER = 0, // 字母 0 LETTER = 0, // 字母 0
UNDERLINE, // _ 1 UNDERLINE, // _ 1
DIGIT, // 数字 2 当识别成功一个数字时，为了避免出现数字01的情况，返回前先进行一个判断，对GCC，01可以识别并等于1的 DIGIT, // 数字 2 当识别成功一个数字时，为了避免出现数字01的情况，返回前先进行一个判断，对GCC，01可以识别并等于1的
@ -93,8 +93,9 @@ typedef enum InputCharType {
POINT, // . 20 如果浮点按整数缓存判断，则将小数点作为数字类型加载，最后在缓冲区内判断 POINT, // . 20 如果浮点按整数缓存判断，则将小数点作为数字类型加载，最后在缓冲区内判断
EPSILON, // 空字符 21 EPSILON, // 空字符 21
}InputCharType; };
string getInputChartypeName(InputCharType type);
extern std::unordered_map<InputCharType, std::string> CharTypeNames;
// 定义 token类型 // 定义 token类型
enum class TokenType { enum class TokenType {
@ -108,10 +109,16 @@ enum class TokenType {
}; };
// 定义最终返回/输出的token的组成类型，包含值和类型两部分 // 定义最终返回/输出的token的组成类型，包含值和类型两部分
typedef struct Token { class Token {
string value; string value;
TokenType type; TokenType type;
} Token; };
string getWordTypeName(WordType type);
string getInputChartypeName(InputCharType type);
// 定义函数判断输入的字符类别 // 定义函数判断输入的字符类别
InputCharType getInputCharType(char c); InputCharType getInputCharType(char c);
@ -128,7 +135,7 @@ public:
map<InputCharType, set<State*>> transitions; // 转移函数映射表，记录每个输入字符类型对应的目标状态集合 map<InputCharType, set<State*>> transitions; // 转移函数映射表，记录每个输入字符类型对应的目标状态集合
// 构造函数 // 构造函数
State(int id) : id(id), isFinalState(false), wordType(UNKOWN) {} State(int id) : id(id), isFinalState(false), wordType(WordType::UNKOWN) {}
// 添加状态转移映射 // 添加状态转移映射
void addTransition(InputCharType input, State* targetState) { void addTransition(InputCharType input, State* targetState) {
@ -204,4 +211,4 @@ string getGrammarName(WordType type, string buffer);
DFA minimizeDFA(const DFA& dfa); DFA minimizeDFA(const DFA& dfa);
vector<string> recognize(const DFA& dfa, const string& input, const string& output); vector<string> recognize(const DFA& dfa, const string& input, const string& output);
string readfile(const string& filename); string readfile(const string& filename);
#endif

2
nfa/src/dfa.cpp
View File

@ -84,7 +84,7 @@ DFA minimizeDFA(const DFA& dfa) {
size_t oldSize;//分割集初始大小 size_t oldSize;//分割集初始大小
do { do {
oldSize = partitions.size(); oldSize = partitions.size();
for (InputCharType input = static_cast<InputCharType>(0); input < EPSILON; input = static_cast<InputCharType>(input + 1)) {//类似于求Ia,Ib等 for (InputCharType input = static_cast<InputCharType>(0); input < InputCharType::EPSILON; input = static_cast<InputCharType>(static_cast<int>(input) + 1)) {//类似于求Ia,Ib等
for (Partition* partition : set<Partition*>(partitions)) {//遍历现存分割的每一个割集，看是否可再分割 for (Partition* partition : set<Partition*>(partitions)) {//遍历现存分割的每一个割集，看是否可再分割
if (partition->states.size() > 1) {//为1的集合不可再分割 if (partition->states.size() > 1) {//为1的集合不可再分割
split(partition->states, input, partitions);//核心分割函数 split(partition->states, input, partitions);//核心分割函数

46
nfa/src/nfa.cpp
View File

@ -7,12 +7,32 @@
NFA RexToNFA() { NFA RexToNFA() {
//由于里面存在||,所以不同正则间使用空格分隔代表| l代表letter，_代表下划线，0代表数字(也可以是d，但是为了使用已经有的函数)， //由于里面存在||,所以不同正则间使用空格分隔代表| l代表letter，_代表下划线，0代表数字(也可以是d，但是为了使用已经有的函数)，
//[lu]代表l|u //[lu]代表l|u
string rex = "+ - * / % = > < == <= >= != && || ( ) { } , ; [l_][l_0]* -?00*"; std::string rex = "+ - * / % = > < == <= >= != && || ( ) { } , ; [l_][l_0]* -?00*";
//下面给出正则对应的输出(终态) //正则对应的输出(终态)
vector<WordType> finalState = { vector<WordType> finalState = {
OP_ADD, OP_SUB,OP_MUL,OP_DIV,OP_MOD,OP_ASSIGN,OP_GT,OP_LT, OP_EQ,OP_LE,OP_GE,OP_NE, OP_AND, OP_OR,SE_LBRAC, SE_RBRAC, WordType::OP_ADD,
SE_LCBRAC,SE_RCBRAC,SE_COMMA,SE_SEMI,IDN,INT_VAL WordType::OP_SUB,
WordType::OP_MUL,
WordType::OP_DIV,
WordType::OP_MOD,
WordType::OP_ASSIGN,
WordType::OP_GT,
WordType::OP_LT,
WordType::OP_EQ,
WordType::OP_LE,
WordType::OP_GE,
WordType::OP_NE,
WordType::OP_AND,
WordType::OP_OR,
WordType::SE_LBRAC,
WordType::SE_RBRAC,
WordType::SE_LCBRAC,
WordType::SE_RCBRAC,
WordType::SE_COMMA,
WordType::SE_SEMI,
WordType::IDN,
WordType::INT_VAL
}; };
stringstream ss(rex); stringstream ss(rex);
@ -39,7 +59,7 @@ NFA RexToNFA() {
//[...]构成一种输入，查看]后面是否有？或者*，来判断当前状态的构成 //[...]构成一种输入，查看]后面是否有？或者*，来判断当前状态的构成
for (i=i+1; i < target.length() && target[i] != ']'; i++) { for (i=i+1; i < target.length() && target[i] != ']'; i++) {
InputCharType input = getInputCharType(target[i]); InputCharType input = getInputCharType(target[i]);
if (input != EPSILON) { if (input != InputCharType::EPSILON) {
// 添加转移函数，从当前状态向新状态转移 // 添加转移函数，从当前状态向新状态转移
currentState->addTransition(input, newState); currentState->addTransition(input, newState);
} }
@ -54,8 +74,8 @@ NFA RexToNFA() {
//创建EPSILON转移状态 //创建EPSILON转移状态
State* epsState = new State(stateIndex++); State* epsState = new State(stateIndex++);
allStates.insert(epsState); allStates.insert(epsState);
currentState->addTransition(EPSILON, epsState); currentState->addTransition(InputCharType::EPSILON, epsState);
newState->addTransition(EPSILON, epsState); newState->addTransition(InputCharType::EPSILON, epsState);
currentState = epsState; currentState = epsState;
// 跳过'?'字符 // 跳过'?'字符
i++; i++;
@ -63,9 +83,9 @@ NFA RexToNFA() {
else if (i + 1 < target.length() && target[i + 1] == '*') { else if (i + 1 < target.length() && target[i + 1] == '*') {
State* epsState = new State(stateIndex++); State* epsState = new State(stateIndex++);
allStates.insert(epsState); allStates.insert(epsState);
currentState->addTransition(EPSILON, epsState); currentState->addTransition(InputCharType::EPSILON, epsState);
newState->addTransition(EPSILON, epsState); newState->addTransition(InputCharType::EPSILON, epsState);
epsState->addTransition(EPSILON, currentState); epsState->addTransition(InputCharType::EPSILON, currentState);
currentState = epsState; currentState = epsState;
// 跳过'*'字符 // 跳过'*'字符
i++; i++;
@ -131,7 +151,7 @@ set<State*, StatePtrCompare> epsilonClosure(const set<State*, StatePtrCompare>&
while (!stateStack.empty()) { while (!stateStack.empty()) {
State* currentState = stateStack.top(); State* currentState = stateStack.top();
stateStack.pop(); stateStack.pop();
auto it = currentState->transitions.find(EPSILON); auto it = currentState->transitions.find(InputCharType::EPSILON);
if (it != currentState->transitions.end()) { if (it != currentState->transitions.end()) {
for (State* nextState : it->second) { for (State* nextState : it->second) {
if (closure.find(nextState) == closure.end()) {//防止同一状态多次进栈，set自带去重 if (closure.find(nextState) == closure.end()) {//防止同一状态多次进栈，set自带去重
@ -174,7 +194,7 @@ DFA nfaToDFA(const NFA& nfa) {
} }
// 遍历所有输入字符类型 // 遍历所有输入字符类型
for (int i = 0; i < static_cast<int>(EPSILON); i++) { for (int i = 0; i < static_cast<int>(InputCharType::EPSILON); i++) {
InputCharType inputCharType = static_cast<InputCharType>(i); InputCharType inputCharType = static_cast<InputCharType>(i);
set<State*, StatePtrCompare> nextNFAStates = epsilonClosure(move(currentNFAStates, inputCharType)); set<State*, StatePtrCompare> nextNFAStates = epsilonClosure(move(currentNFAStates, inputCharType));
if (nextNFAStates.empty()) { if (nextNFAStates.empty()) {

350
nfa/src/tool.cpp
View File

@ -1,103 +1,87 @@
#include "nfa.h" #include "nfa.h"
/* std::unordered_map<InputCharType, std::string> CharTypeNames = {
扫描读入-->以字符的格式读入 {InputCharType::UNDERLINE, "_"},
对于界符和部分运算符，显然是单个组成，即可以单独代表一个状态 {InputCharType::ADD, "+"},
{InputCharType::SUB, "-"},
{InputCharType::MUL, "*"},
{InputCharType::DIV, "/"},
{InputCharType::MOD, "%"},
{InputCharType::EQ, "="},
{InputCharType::GT, ">"},
{InputCharType::LT, "<"},
{InputCharType::NOT, "!"},
{InputCharType::AND, "&"},
{InputCharType::OR, "|"},
{InputCharType::LBRACKET, "("},
{InputCharType::RBRACKET, ")"},
{InputCharType::LCBRAC, "{"},
{InputCharType::RCBRAC, "}"},
{InputCharType::COMMA, ","},
{InputCharType::SEMI, ";"},
{InputCharType::POINT, "."} // 小数点
};
注意： std::unordered_map<WordType, std::string> WordTypeNames = {
1.字母需要区分大小写 {WordType::KW_INT, "INT"}, {WordType::KW_VOID, "VOID"}, {WordType::KW_RETURN, "RETURN"},
*/ {WordType::KW_CONST, "CONST"}, {WordType::KW_MAIN, "MAIN"}, {WordType::KW_IF, "IF"},
{WordType::KW_ELSE, "ELSE"}, {WordType::KW_FLOAT, "FLOAT"}, {WordType::OP_ADD, "+"},
// 获取输入串的类型 {WordType::OP_SUB, "-"}, {WordType::OP_MUL, "*"}, {WordType::OP_DIV, "/"},
// 单独一位的读入-->下一步标识终态 {WordType::OP_MOD, "%"}, {WordType::OP_ASSIGN, "="}, {WordType::OP_GT, ">"},
{WordType::OP_LT, "<"}, {WordType::OP_EQ, "=="}, {WordType::OP_LE, "<="},
{WordType::OP_GE, ">="}, {WordType::OP_NE, "!="}, {WordType::OP_AND, "&&"},
{WordType::OP_OR, "||"}, {WordType::SE_LBRAC, "("}, {WordType::SE_RBRAC, ")"},
{WordType::SE_LCBRAC, "{"}, {WordType::SE_RCBRAC, "}"}, {WordType::SE_COMMA, ","},
{WordType::SE_SEMI, ";"}, {WordType::IDN, "IDENTIFIER"}, {WordType::INT_VAL, "INTEGER"},
{WordType::FLOAT_VAL, "FLOAT"}, {WordType::UNKOWN, "UNKNOWN"}
};
//扫描,以字符的格式读入
//对于界符和部分运算符，是单个组成，即可以单独代表一个状态
InputCharType getInputCharType(char c) { InputCharType getInputCharType(char c) {
switch (c) { switch (c) {
case '_': return UNDERLINE; case '_': return InputCharType::UNDERLINE;
case '+': return ADD; case '+': return InputCharType::ADD;
case '-': return SUB; case '-': return InputCharType::SUB;
case '*': return MUL; case '*': return InputCharType::MUL;
case '/': return DIV; case '/': return InputCharType::DIV;
case '%': return MOD; case '%': return InputCharType::MOD;
case '=': return EQ; case '=': return InputCharType::EQ;
case '>': return GT; case '>': return InputCharType::GT;
case '<': return LT; case '<': return InputCharType::LT;
case '!': return NOT; case '!': return InputCharType::NOT;
case '&': return AND; case '&': return InputCharType::AND;
case '|': return OR; case '|': return InputCharType::OR;
case '(': return LBRACKET; case '(': return InputCharType::LBRACKET;
case ')': return RBRACKET; case ')': return InputCharType::RBRACKET;
case '{': return LCBRAC; case '{': return InputCharType::LCBRAC;
case '}': return RCBRAC; case '}': return InputCharType::RCBRAC;
case ',': return COMMA; case ',': return InputCharType::COMMA;
case ';': return SEMI; case ';': return InputCharType::SEMI;
//小数点作为数字读入 //小数点作为数字读入
case '.': return DIGIT; case '.': return InputCharType::DIGIT;
default: default:
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) { if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
return LETTER; return InputCharType::LETTER;
} }
else if (c >= '0' && c <= '9') { else if (c >= '0' && c <= '9') {
return DIGIT; return InputCharType::DIGIT;
} }
else { else {
return EPSILON; return InputCharType::EPSILON;
} }
} }
} }
// 根据状态获取名称 // 根据状态获取名称
string getInputChartypeName(InputCharType type) { std::string getInputChartypeName(InputCharType type) {
switch (type) auto it = CharTypeNames.find(type);
{ if (it != CharTypeNames.end()) {
case LETTER: return it->second;
return "LETTER"; } else {
case UNDERLINE: return "UNKNOWN";
return "UNDERLINE";
case DIGIT:
return "DIGIT";
case ADD:
return "+";
case SUB:
return "-";
case MUL:
return "*";
case DIV:
return "/";
case MOD:
return "%";
case EQ:
return "=";
case GT:
return ">";
case LT:
return "<";
case NOT:
return "!";
case AND:
return "&";
case OR:
return "|";
case LBRACKET:
return "(";
case RBRACKET:
return ")";
case LCBRAC:
return "{";
case RCBRAC:
return "}";
case COMMA:
return ",";
case SEMI:
return ";";
case POINT: //暂不使用
return ".";
case EPSILON:
return "EPSILON";
default:
return "UNKOWN";
} }
} }
@ -118,33 +102,33 @@ string judeFloat(string buffer){
string getWordTypeName(WordType type, string buffer) { string getWordTypeName(WordType type, string buffer) {
switch (type) { switch (type) {
// 运算符 // 运算符
case OP_ADD: case WordType::OP_ADD:
case OP_SUB: case WordType::OP_SUB:
case OP_MUL: case WordType::OP_MUL:
case OP_DIV: case WordType::OP_DIV:
case OP_MOD: case WordType::OP_MOD:
case OP_ASSIGN: case WordType::OP_ASSIGN:
case OP_GT: case WordType::OP_GT:
case OP_LT: case WordType::OP_LT:
case OP_EQ: case WordType::OP_EQ:
case OP_LE: case WordType::OP_LE:
case OP_GE: case WordType::OP_GE:
case OP_NE: case WordType::OP_NE:
case OP_AND: case WordType::OP_AND:
case OP_OR: case WordType::OP_OR:
return "OP"; return "OP";
// 界符 // 界符
case SE_LBRAC: case WordType::SE_LBRAC:
case SE_RBRAC: case WordType::SE_RBRAC:
case SE_LCBRAC: case WordType::SE_LCBRAC:
case SE_RCBRAC: case WordType::SE_RCBRAC:
case SE_COMMA: case WordType::SE_COMMA:
case SE_SEMI: case WordType::SE_SEMI:
return "SE"; return "SE";
// 标识符和关键字 // 标识符和关键字
case IDN: case WordType::IDN:
if (!buffer.compare("int") || if (!buffer.compare("int") ||
!buffer.compare("void") || !buffer.compare("void") ||
!buffer.compare("const") || !buffer.compare("const") ||
@ -160,7 +144,7 @@ string getWordTypeName(WordType type, string buffer) {
} }
// 整数(添加了浮点判断) // 整数(添加了浮点判断)
case INT_VAL: case WordType::INT_VAL:
return judeFloat(buffer); return judeFloat(buffer);
//浮点 //浮点
@ -177,32 +161,32 @@ string getWordTypeName(WordType type, string buffer) {
string getWordAttribute(WordType type, string buffer) { string getWordAttribute(WordType type, string buffer) {
switch (type) { switch (type) {
// 运算符 // 运算符
case OP_ADD: return "6"; case WordType::OP_ADD: return "6";
case OP_SUB: return "7"; case WordType::OP_SUB: return "7";
case OP_MUL: return "8"; case WordType::OP_MUL: return "8";
case OP_DIV: return "9"; case WordType::OP_DIV: return "9";
case OP_MOD: return "10"; case WordType::OP_MOD: return "10";
case OP_ASSIGN: return "11"; case WordType::OP_ASSIGN: return "11";
case OP_GT: return "12"; case WordType::OP_GT: return "12";
case OP_LT: return "13"; case WordType::OP_LT: return "13";
case OP_EQ: return "14"; case WordType::OP_EQ: return "14";
case OP_LE: return "15"; case WordType::OP_LE: return "15";
case OP_GE: return "16"; case WordType::OP_GE: return "16";
case OP_NE: return "17"; case WordType::OP_NE: return "17";
case OP_AND:return "18"; case WordType::OP_AND:return "18";
case OP_OR: return "19"; case WordType::OP_OR: return "19";
// 界符 // 界符
case SE_LBRAC: return "20"; case WordType::SE_LBRAC: return "20";
case SE_RBRAC: return "21"; case WordType::SE_RBRAC: return "21";
case SE_LCBRAC: return "22"; case WordType::SE_LCBRAC: return "22";
case SE_RCBRAC: return "23"; case WordType::SE_RCBRAC: return "23";
case SE_COMMA: return "25"; case WordType::SE_COMMA: return "25";
case SE_SEMI: return "24"; case WordType::SE_SEMI: return "24";
// 标识符和关键字 // 标识符和关键字
case IDN: case WordType::IDN:
if (!buffer.compare("int")){ if (!buffer.compare("int")){
return "1"; return "1";
} }
@ -232,11 +216,11 @@ string getWordAttribute(WordType type, string buffer) {
} }
// 整数 // 整数
case INT_VAL: case WordType::INT_VAL:
return buffer; return buffer;
//浮点类型，理论不使用 //浮点类型，理论不使用
case FLOAT_VAL: case WordType::FLOAT_VAL:
return buffer; return buffer;
//default //default
@ -265,70 +249,10 @@ string readfile(const string& filename)
// 获取token名称 // 获取token名称
string getWordTypeName(WordType type) { string getWordTypeName(WordType type) {
switch (type) { auto it = WordTypeNames.find(type);
case KW_INT: if (it != WordTypeNames.end()) {
return "KW_INT"; return it->second;
case KW_VOID: } else {
return "KW_VOID";
case KW_RETURN:
return "KW_RETURN";
case KW_CONST:
return "KW_CONST";
case KW_MAIN:
return "KW_MAIN";
case KW_IF:
return "KW_IF";
case KW_ELSE:
return "KW_ELSE";
case KW_FLOAT:
return "KW_FLOAT";
case OP_ADD:
return "OP_ADD";
case OP_SUB:
return "OP_SUB";
case OP_MUL:
return "OP_MUL";
case OP_DIV:
return "OP_DIV";
case OP_MOD:
return "OP_MOD";
case OP_ASSIGN:
return "OP_ASSIGN";
case OP_GT:
return "OP_GT";
case OP_LT:
return "OP_LT";
case OP_EQ:
return "OP_EQ";
case OP_LE:
return "OP_LE";
case OP_GE:
return "OP_GE";
case OP_NE:
return "OP_NE";
case OP_AND:
return "OP_AND";
case OP_OR:
return "OP_OR";
case SE_LBRAC:
return "SE_LBRAC";
case SE_RBRAC:
return "SE_RBRAC";
case SE_LCBRAC:
return "SE_LCBRAC";
case SE_RCBRAC:
return "SE_RCBRAC";
case SE_COMMA:
return "SE_COMMA";
case SE_SEMI:
return "SE_SEMI";
case IDN:
return "IDN";
case INT_VAL:
return "INT_VAL";
case FLOAT_VAL:
return "FLOAT_VAL";
default:
return "UNKNOWN"; return "UNKNOWN";
} }
} }
@ -337,29 +261,29 @@ string getWordTypeName(WordType type) {
string getGrammarName(WordType type, string buffer) { string getGrammarName(WordType type, string buffer) {
switch (type) { switch (type) {
case OP_ADD: return "+"; case WordType::OP_ADD: return "+";
case OP_SUB: return "-"; case WordType::OP_SUB: return "-";
case OP_MUL: return "*"; case WordType::OP_MUL: return "*";
case OP_DIV: return "/"; case WordType::OP_DIV: return "/";
case OP_MOD: return "%"; case WordType::OP_MOD: return "%";
case OP_ASSIGN: return "="; case WordType::OP_ASSIGN: return "=";
case OP_GT: return ">"; case WordType::OP_GT: return ">";
case OP_LT: return "<"; case WordType::OP_LT: return "<";
case OP_EQ: return "=="; case WordType::OP_EQ: return "==";
case OP_LE: return "<="; case WordType::OP_LE: return "<=";
case OP_GE: return ">="; case WordType::OP_GE: return ">=";
case OP_NE: return "!="; case WordType::OP_NE: return "!=";
case OP_AND: return "&&"; case WordType::OP_AND: return "&&";
case OP_OR: return "||"; case WordType::OP_OR: return "||";
case SE_LBRAC: return "("; case WordType::SE_LBRAC: return "(";
case SE_RBRAC: return ")"; case WordType::SE_RBRAC: return ")";
case SE_LCBRAC: return "{"; case WordType::SE_LCBRAC: return "{";
case SE_RCBRAC: return "}"; case WordType::SE_RCBRAC: return "}";
case SE_COMMA: return ","; case WordType::SE_COMMA: return ",";
case SE_SEMI: return ";"; case WordType::SE_SEMI: return ";";
case IDN: case WordType::IDN:
if (!buffer.compare("int")) { if (!buffer.compare("int")) {
return "int"; return "int";
} }
@ -378,8 +302,8 @@ string getGrammarName(WordType type, string buffer) {
else { else {
return "IDN"; return "IDN";
} }
case INT_VAL: return "INT"; case WordType::INT_VAL: return "INT";
case FLOAT_VAL: return "FLOAT"; case WordType::FLOAT_VAL: return "FLOAT";
default: cerr << "Token Error: "<< type << endl; exit(-1); default: cerr << "Token Error: "<< WordTypeNames.find(type)->second << endl; exit(-1);
} }
} }