Skip to content

Commit d13bdad

Browse files
Program132Program132
committed
Fixs, Management
1 parent 459fba5 commit d13bdad

File tree

2 files changed

+130
-136
lines changed

2 files changed

+130
-136
lines changed

‎src/Parser.cpp‎

Lines changed: 126 additions & 132 deletions
Original file line numberDiff line numberDiff line change
@@ -8,168 +8,162 @@ namespace FPL {
88
mTypes["texte"] = Type("texte", STRING);
99
}
1010

11-
bool Parser::FunctionChecker() {
12-
auto parseStart = mCurrentToken; // std::vector<Token>::iterator
13-
auto PeutEtreInstruction = CheckerIdentifiant();
14-
if (PeutEtreInstruction.has_value()) {
15-
// On a une instruction
16-
if (PeutEtreInstruction->mText == "definir") { // On vérifie si l'instruction est une fonction
17-
auto PeutEtreNom = CheckerIdentifiant();
18-
if (PeutEtreNom.has_value()) {
19-
// On a le nom d'une fonction.
20-
if (CheckerOperateur("(").has_value()) {
21-
//On a surement une fonction finie !
22-
23-
FonctionDefinition fonction;
24-
fonction.FonctionName = PeutEtreNom->mText;
11+
bool Parser::FunctionChecker(auto parseStart) {
12+
auto PeutEtreNom = CheckerIdentifiant();
13+
if (PeutEtreNom.has_value()) {
14+
// On a le nom d'une fonction.
15+
if (CheckerOperateur("(").has_value()) {
16+
//On a surement une fonction finie !
2517

26-
while (CheckerOperateur(")") == std::nullopt) {
27-
auto type = CheckerType();
18+
FonctionDefinition fonction;
19+
fonction.FonctionName = PeutEtreNom->mText;
2820

29-
// Si aucun paramètre ou l'utilisateur a utilisé l'argument 'vide' ou juste fermer.
30-
if (type->mType == VOID) { break; }
21+
while (CheckerOperateur(")") == std::nullopt) {
22+
auto type = CheckerType();
3123

32-
if (!type.has_value() || type == std::nullopt) {
33-
throw std::runtime_error("Vous devez spécifier un type d'argument.");
34-
}
24+
// Si aucun paramètre ou l'utilisateur a utilisé l'argument 'vide' ou juste fermer.
25+
if (type->mType == VOID) { break; }
3526

36-
// Ajout de l'argument...
37-
auto variableName = CheckerIdentifiant();
38-
if (!variableName.has_value()) {
39-
throw std::runtime_error("Vous devez spécifier un nom unique à l'argument.");
40-
}
41-
ArgumentDefinition param;
42-
param.ArgType.mName = type->mName;
43-
param.ArgType.mType = type->mType;
44-
param.ArgName = variableName->mText;
45-
fonction.ArgsFonction.push_back(param);
46-
47-
if (CheckerOperateur(")").has_value()) {
48-
break;
49-
}
50-
if (!CheckerOperateur(",").has_value()) {
51-
throw std::runtime_error(
52-
"Vous devez utiliser la ',' pour separer les arguments de la fonction.");
53-
}
54-
}
27+
if (!type.has_value() || type == std::nullopt) {
28+
throw std::runtime_error("Vous devez spécifier un type d'argument.");
29+
}
5530

56-
mFonctions[fonction.FonctionName] = fonction;
31+
// Ajout de l'argument...
32+
auto variableName = CheckerIdentifiant();
33+
if (!variableName.has_value()) {
34+
throw std::runtime_error("Vous devez spécifier un nom unique à l'argument.");
35+
}
36+
ArgumentDefinition param;
37+
param.ArgType.mName = type->mName;
38+
param.ArgType.mType = type->mType;
39+
param.ArgName = variableName->mText;
40+
fonction.ArgsFonction.push_back(param);
41+
42+
if (CheckerOperateur(")").has_value()) {
43+
break;
44+
}
45+
if (!CheckerOperateur(",").has_value()) {
46+
throw std::runtime_error(
47+
"Vous devez utiliser la ',' pour separer les arguments de la fonction.");
48+
}
49+
}
5750

58-
// On récupère le code entre les {} :
51+
mFonctions[fonction.FonctionName] = fonction;
5952

60-
if (CheckerOperateur("{")) {
61-
while (!CheckerOperateur("}").has_value()) {
62-
fonction.FonctionContent.push_back(mCurrentToken->mText);
63-
++mCurrentToken;
53+
// On récupère le code entre les {} :
6454

65-
if (CheckerOperateur("}").has_value()) {
66-
break;
67-
}
68-
}
55+
if (CheckerOperateur("{")) {
56+
while (!CheckerOperateur("}").has_value()) {
57+
fonction.FonctionContent.push_back(mCurrentToken->mText);
58+
++mCurrentToken;
6959

60+
if (CheckerOperateur("}").has_value()) {
61+
break;
7062
}
71-
72-
return true;
73-
} else {
74-
mCurrentToken = parseStart;
75-
std::cerr
76-
<< "Vous devez ouvrir les parenthèses pour ajouter des paramètres si vous le souhaitez."
77-
<< std::endl;
7863
}
79-
} else {
80-
mCurrentToken = parseStart;
81-
std::cerr << "Vous devez donner un nom à votre fonction." << std::endl;
64+
8265
}
66+
67+
return true;
8368
} else {
8469
mCurrentToken = parseStart;
70+
std::cerr
71+
<< "Vous devez ouvrir les parenthèses pour ajouter des paramètres si vous le souhaitez."
72+
<< std::endl;
8573
}
74+
} else {
75+
mCurrentToken = parseStart;
76+
std::cerr << "Vous devez donner un nom à votre fonction." << std::endl;
8677
}
8778
return false;
8879
}
8980

90-
bool Parser::ManagerInstruction() {
91-
auto parseStart = mCurrentToken; // std::vector<Token>::iterator
92-
auto PeutEtreInstruction = CheckerIdentifiant();
93-
if (PeutEtreInstruction.has_value()) {
94-
if (PeutEtreInstruction->mText == "envoyer") {
95-
auto Value = CheckerValue();
96-
if (Value.has_value()) {
97-
if (Value->StatementType.mType == STRING) {
98-
std::replace(Value->StatementName.begin(), Value->StatementName.end(), '"', ' ');
99-
}
100-
std::cout << Value->StatementName << std::endl;
101-
return true;
102-
} else {
103-
mCurrentToken = parseStart;
104-
++mCurrentToken;
105-
auto value = CheckerIdentifiant();
106-
if (value.has_value()) {
107-
if (CheckerOperateur("<").has_value()) {
108-
if (CheckerOperateur("-").has_value()) {
109-
if (isVariable(value->mText)) {
110-
std::cout << mVariables[value->mText].VariableValue << std::endl;
81+
bool Parser::VariableInstruction(auto parseStart) {
82+
auto VarType = CheckerType();
83+
if (VarType.has_value()) {
84+
auto VarName = CheckerIdentifiant();
85+
if (VarName.has_value()) {
86+
if (CheckerOperateur("-").has_value()) {
87+
if (CheckerOperateur(">").has_value()) {
88+
auto VarValue = CheckerValue();
89+
if (VarValue.has_value()) {
90+
if (VarValue->StatementType.mType == VarType->mType) {
91+
if (CheckerOperateur("|")) {
92+
VariableDefinition variable;
93+
variable.VariableName = VarName->mText;
94+
variable.VariableType = Type(VarType->mName, VarType->mType);
95+
variable.VariableValue = VarValue->StatementName;
96+
97+
mVariables[variable.VariableName] = variable;
98+
99+
std::cout << "La variable '"
100+
<< mVariables[variable.VariableName].VariableName << "' a pour valeur "
101+
<< mVariables[variable.VariableName].VariableValue << std::endl;
102+
111103
return true;
112104
} else {
113-
mCurrentToken = parseStart;
114-
std::cerr << "La variable n'existe pas." << std::endl;
115-
}
116-
}
117-
}
118-
}
119-
std::cerr << "Vous devez ouvrir les guillements pour transmettre une chaine de caractères ou le nom de votre variable sous ce format : 'envoyer (variable) <-" << std::endl;
120-
return false;
121-
}
122-
} else if (PeutEtreInstruction->mText == "variable") {
123-
auto VarType = CheckerType();
124-
if (VarType.has_value()) {
125-
auto VarName = CheckerIdentifiant();
126-
if (VarName.has_value()) {
127-
if (CheckerOperateur("-").has_value()) {
128-
if (CheckerOperateur(">").has_value()) {
129-
auto VarValue = CheckerValue();
130-
if (VarValue.has_value()) {
131-
if (VarValue->StatementType.mType == VarType->mType) {
132-
VariableDefinition variable;
133-
variable.VariableName = VarName->mText;
134-
variable.VariableType = Type(VarType->mName, VarType->mType);
135-
variable.VariableValue = VarValue->StatementName;
136-
137-
if (VarType->mType == STRING) {
138-
std::replace(variable.VariableValue.begin(), variable.VariableValue.end(), '"', ' ');
139-
}
140-
141-
mVariables[variable.VariableName] = variable;
142-
143-
std::cout << "La variable '"
144-
<< mVariables[variable.VariableName].VariableName << "' a pour valeur "
145-
<< mVariables[variable.VariableName].VariableValue << std::endl;
146-
147-
return true;
148-
} else {
149-
std::cerr << "Vous devez donner une valeur qui est de même type que la variable." << std::endl;
150-
mCurrentToken = parseStart;
151-
}
152-
} else {
153-
std::cerr << "Vous devez donner une valeur a la variable qui correspond au type." << std::endl;
154-
mCurrentToken = parseStart;
105+
std::cerr << "Merci de signifier la fin de la déclaration de la variable avec '|'." << std::endl;
155106
}
156107
} else {
157-
std::cerr << "Vous devez utiliser les symboles '->' pour donner une valeur à la variable." << std::endl;
158-
mCurrentToken = parseStart;
108+
std::cerr << "Vous devez donner une valeur qui est de même type que la variable." << std::endl;
159109
}
160110
} else {
161-
std::cerr << "Vous devez utiliser les symboles '->' pour donner une valeur à la variable." << std::endl;
162-
mCurrentToken = parseStart;
111+
std::cerr << "Vous devez donner une valeur a la variable qui correspond au type." << std::endl;
163112
}
164113
} else {
165-
std::cerr << "Vous devez indiquer un nom à la variable." << std::endl;
166-
mCurrentToken = parseStart;
114+
std::cerr << "Vous devez utiliser les symboles '->' pour donner une valeur à la variable." << std::endl;
167115
}
168116
} else {
169-
std::cerr << "Vous devez indiquer une type pour la variable." << std::endl;
170-
mCurrentToken = parseStart;
117+
std::cerr << "Vous devez utiliser les symboles '->' pour donner une valeur à la variable." << std::endl;
171118
}
172119
} else {
120+
std::cerr << "Vous devez indiquer un nom à la variable." << std::endl;
121+
}
122+
}
123+
return false;
124+
}
125+
126+
bool Parser::PrintInstruction(auto parseStart) {
127+
auto Value = CheckerValue();
128+
if (Value.has_value()) {
129+
if (Value->StatementType.mType == STRING) {
130+
std::replace(Value->StatementName.begin(), Value->StatementName.end(), '"', ' ');
131+
}
132+
std::cout << Value->StatementName << std::endl;
133+
return true;
134+
} else {
135+
mCurrentToken = parseStart;
136+
++mCurrentToken;
137+
auto value = CheckerIdentifiant();
138+
if (value.has_value()) {
139+
if (CheckerOperateur("<").has_value()) {
140+
if (CheckerOperateur("-").has_value()) {
141+
if (isVariable(value->mText)) {
142+
std::cout << mVariables[value->mText].VariableValue << std::endl;
143+
return true;
144+
} else {
145+
mCurrentToken = parseStart;
146+
std::cerr << "La variable n'existe pas." << std::endl;
147+
}
148+
}
149+
}
150+
}
151+
std::cerr << "Vous devez ouvrir les guillements pour transmettre une chaine de caractères ou le nom de votre variable sous ce format : 'envoyer (variable) <-" << std::endl;
152+
}
153+
return false;
154+
}
155+
156+
bool Parser::ManagerInstruction() {
157+
auto parseStart = mCurrentToken; // std::vector<Token>::iterator
158+
auto PeutEtreInstruction = CheckerIdentifiant();
159+
if (PeutEtreInstruction.has_value()) {
160+
if (PeutEtreInstruction->mText == "envoyer") {
161+
if (PrintInstruction(parseStart)) {return true;} else {return false;}
162+
} else if (PeutEtreInstruction->mText == "variable") {
163+
if (VariableInstruction(parseStart)) { return true; } else {return false;}
164+
} else if (PeutEtreInstruction->mText == "definir") {
165+
if (FunctionChecker(parseStart)) {return true;} else {return false;}
166+
} else{
173167
mCurrentToken = parseStart;
174168
}
175169
return false;
@@ -218,7 +212,7 @@ namespace FPL {
218212
return *returnToken; // On donne l'opérateur
219213
}
220214

221-
std::optional<Type> Parser::CheckerType(std::string_view name) {
215+
std::optional<Type> Parser::CheckerType() {
222216
auto possibleType = CheckerIdentifiant();
223217
if (!possibleType.has_value()) { return std::nullopt; }
224218

‎src/Parser.h‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@ namespace FPL {
2626

2727
private:
2828
// Essentielles:
29-
std::optional<Type> CheckerType(std::string_view name = std::string());
29+
std::optional<Type> CheckerType();
3030
std::optional<Token> CheckerIdentifiant(std::string_view name = std::string());
3131
std::optional<Token> CheckerOperateur(std::string_view name = std::string());
3232
std::optional<Statement> CheckerValue();
@@ -37,9 +37,11 @@ namespace FPL {
3737
// Variable :
3838
std::map<std::string, VariableDefinition> mVariables;
3939
bool isVariable(std::string &name);
40+
bool VariableInstruction(auto parseStart);
41+
bool PrintInstruction(auto parseStart);
4042

4143
// Fonctions :
42-
bool FunctionChecker();
44+
bool FunctionChecker(auto parseStart);
4345
std::map<std::string, FonctionDefinition> mFonctions;
4446

4547

@@ -49,7 +51,5 @@ namespace FPL {
4951
std::map<std::string, Type> mTypes;
5052

5153
bool ManagerInstruction();
52-
53-
5454
};
5555
}

0 commit comments

Comments
 (0)