l3-ENSL/c-repl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Parser: Renaming grammar symbols

Browse Source
This commit is contained in:
augustin64 2023-11-23 11:37:03 +01:00
parent fc7b3d440a
commit b7dcca2d47
3 changed files with 55 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/include/parser.h
View File

@ -55,19 +55,29 @@ ParseReturn parse_expr_statement(vector<Token> tokens);
ParseReturn parse_expr(vector<Token> tokens);
/**
* Parse something derivated from T
* Parse something derivated from Comp
*/
ParseReturn parse_t(vector<Token> tokens);
ParseReturn parse_comp(vector<Token> tokens);
/**
* Parse something derivated from U
* Parse something derivated from Sum
*/
ParseReturn parse_u(vector<Token> tokens);
ParseReturn parse_sum(vector<Token> tokens);
/**
* Parse something derivated from F
* Parse something derivated from Term
*/
ParseReturn parse_f(vector<Token> tokens);
ParseReturn parse_term(vector<Token> tokens);
/**
* Parse something derivated from Unary
*/
ParseReturn parse_unary(vector<Token> tokens);
/**
* Parse something derivated from Val
*/
ParseReturn parse_val(vector<Token> tokens);
/**
* Parse something derivated from ParIdentifier

14
src/include/types.h
View File

@ -99,13 +99,13 @@ enum class NodeType {
Epsilon, // -> ;
AssignedDeclaration, // -> Type Identifier = Expr
Declaration, // -> Type Identifier
Plus, // -> T + Expr
Minus, // -> T - Expr
Mult, // -> F * T
Div, // -> F / T
Mod, // -> F % T
UnaryMinus, // -> -F
UnaryPlus, // -> +F
Plus, // -> Term + Sum
Minus, // -> Term - Sum
Mult, // -> Unary * Term
Div, // -> Unary / Term
Mod, // -> Unary % Term
UnaryMinus, // -> -Unary
UnaryPlus, // -> +Unary
Assignment, // -> Identifier = Expr
LIncr, // -> ++ParIdentifier
RIncr, // -> ParIdentifier++

56
src/parser.cpp
View File

@ -326,11 +326,19 @@ ParseReturn parse_expr_statement(vector<Token> tokens) {
}
ParseReturn parse_expr(vector<Token> tokens) {
return parse_comp(tokens);
}
ParseReturn parse_comp(vector<Token> tokens) {
return parse_sum(tokens);
}
ParseReturn parse_sum(vector<Token> tokens) {
if (tokens.size() == 0)
throw ParseException();
// At least 1 T
ParseReturn ret = parse_t(tokens);
// At least 1 Term
ParseReturn ret = parse_term(tokens);
tokens = ret.tokens;
Node node = ret.node;
@ -358,7 +366,7 @@ ParseReturn parse_expr(vector<Token> tokens) {
last_token = tokens.back();
tokens.pop_back();
ParseReturn ret = parse_t(tokens);
ParseReturn ret = parse_term(tokens);
tokens = ret.tokens;
InnerNode new_node = {
@ -382,13 +390,13 @@ ParseReturn parse_expr(vector<Token> tokens) {
};
}
ParseReturn parse_t(vector<Token> tokens) {
ParseReturn parse_term(vector<Token> tokens) {
if (tokens.size() == 0)
throw ParseException();
// At least 1 U
ParseReturn ret = parse_u(tokens);
// At least 1 Unary
ParseReturn ret = parse_unary(tokens);
tokens = ret.tokens;
Node node = ret.node;
@ -419,7 +427,7 @@ ParseReturn parse_t(vector<Token> tokens) {
try {
last_token = tokens.back();
tokens.pop_back();
ParseReturn ret = parse_u(tokens);
ParseReturn ret = parse_unary(tokens);
tokens = ret.tokens;
InnerNode new_node = {
@ -443,11 +451,11 @@ ParseReturn parse_t(vector<Token> tokens) {
};
}
ParseReturn parse_u(vector<Token> tokens) {
if (tokens.size() > 0 && tokens.back().type == TokenType::Minus) { //* U -> - U
ParseReturn parse_unary(vector<Token> tokens) {
if (tokens.size() > 0 && tokens.back().type == TokenType::Minus) { //* Unary -> - Unary
tokens.pop_back();
ParseReturn ret = parse_u(tokens);
ParseReturn ret = parse_unary(tokens);
InnerNode node = {
.type=NodeType::UnaryMinus,
@ -460,10 +468,10 @@ ParseReturn parse_u(vector<Token> tokens) {
};
}
if (tokens.size() > 0 && tokens.back().type == TokenType::Plus) { //* U -> + U
if (tokens.size() > 0 && tokens.back().type == TokenType::Plus) { //* Unary -> + Unary
tokens.pop_back();
ParseReturn ret = parse_u(tokens);
ParseReturn ret = parse_unary(tokens);
InnerNode node = {
.type=NodeType::UnaryPlus,
@ -476,16 +484,16 @@ ParseReturn parse_u(vector<Token> tokens) {
};
}
//* U -> F
return parse_f(tokens);
//* Unary -> Val
return parse_val(tokens);
}
ParseReturn parse_f(vector<Token> tokens) {
ParseReturn parse_val(vector<Token> tokens) {
if (tokens.size() == 0)
throw ParseException();
switch (tokens.back().type) {
case TokenType::Int: { //* F -> Number
case TokenType::Int: { //* Val -> Number
Token number = tokens.back();
tokens.pop_back();
return {
@ -493,7 +501,7 @@ ParseReturn parse_f(vector<Token> tokens) {
.tokens=tokens
};;
}
case TokenType::DoublePlus: { //* F -> ++ParIdentifier
case TokenType::DoublePlus: { //* Val -> ++ParIdentifier
tokens.pop_back();
ParseReturn ret = parse_par_identifier(tokens);
@ -507,7 +515,7 @@ ParseReturn parse_f(vector<Token> tokens) {
.tokens=ret.tokens
};
}
case TokenType::DoubleMinus: { //* F -> --ParIdentifier
case TokenType::DoubleMinus: { //* Val -> --ParIdentifier
tokens.pop_back();
ParseReturn ret = parse_par_identifier(tokens);
@ -522,12 +530,12 @@ ParseReturn parse_f(vector<Token> tokens) {
};
}
default: {
try { //* F -> ParIdentifier...
try { //* Val -> ParIdentifier...
ParseReturn ret = parse_par_identifier(tokens);
if (ret.tokens.size() >= 1) {
switch (ret.tokens.back().type){
case TokenType::DoublePlus: { //* F -> ParIdentifier++
case TokenType::DoublePlus: { //* Val -> ParIdentifier++
ret.tokens.pop_back();
InnerNode node = {
.type = NodeType::RIncr,
@ -539,7 +547,7 @@ ParseReturn parse_f(vector<Token> tokens) {
.tokens=ret.tokens
};
}
case TokenType::DoubleMinus: { //* F -> ParIdentifier--
case TokenType::DoubleMinus: { //* Val -> ParIdentifier--
ret.tokens.pop_back();
InnerNode node = {
.type = NodeType::RDecr,
@ -551,7 +559,7 @@ ParseReturn parse_f(vector<Token> tokens) {
.tokens=ret.tokens
};
}
case TokenType::Equal: { //* F -> ParIdentifier = (Expr)
case TokenType::Equal: { //* Val -> ParIdentifier = (Expr)
ret.tokens.pop_back();
ParseReturn ret_expr = parse_expr(ret.tokens);
@ -569,10 +577,10 @@ ParseReturn parse_f(vector<Token> tokens) {
break;
}
}
//* F -> ParIdentifier
//* Val -> ParIdentifier
return ret;
} catch (const ParseException& pex) { //* F -> (Expr)
} catch (const ParseException& pex) { //* Val -> (Expr)
if (tokens.back().type != TokenType::LParenthese)
throw ParseException();