Skip to content

Commit 8dee181

Browse files
Program132Program132
committed
Fonction, l'instruction "changer" -> UPDATED!
1 parent ef6275e commit 8dee181

File tree

1 file changed

+115
-62
lines changed

1 file changed

+115
-62
lines changed

‎src/Parser.cpp‎

Lines changed: 115 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,7 @@ namespace FPL {
5353
std::cerr << "La fonction a des parametres, vous devez obligatoirement leur donner une valeur." << std::endl;
5454
}
5555
}
56+
5657
if (!fonction.FonctionContent.empty()) {
5758
std::string finalContent;
5859
for (auto const &a : fonction.FonctionContent) {
@@ -64,8 +65,19 @@ namespace FPL {
6465

6566
auto FCurrToken = tokens.begin();
6667
auto oldCurrentToken = mCurrentToken;
67-
parse(tokens);
68+
parse(tokens, "fonction");
6869
mCurrentToken = oldCurrentToken;
70+
71+
std::vector<std::string> toErase;
72+
for(auto var: mVariables) {
73+
if(var.second.InFonction && !var.second.IsGlobal) {
74+
toErase.push_back(var.first);
75+
}
76+
}
77+
for(auto it: toErase)
78+
{
79+
mVariables.erase(it);
80+
}
6981
return true;
7082
}
7183
}
@@ -145,7 +157,7 @@ namespace FPL {
145157
return false;
146158
}
147159

148-
bool Parser::VariableInstruction() {
160+
bool Parser::VariableInstruction(std::optional<std::string> argument) {
149161
auto VarType = CheckerType();
150162
if (VarType.has_value()) {
151163
auto VarName = CheckerIdentifiant();
@@ -170,107 +182,85 @@ namespace FPL {
170182
if (VarValue.has_value()) {
171183
std::cout << VarValue->StatementName << std::endl;
172184
}
185+
173186
if (CheckerOperateur(";").has_value()) {
187+
VariableDefinition variable;
188+
variable.VariableName = VarName->mText;
189+
variable.VariableType = Type(VarType->mName, VarType->mType);
190+
variable.IsGlobal = false;
191+
variable.InFonction = false;
192+
if (argument == "fonction") {
193+
variable.InFonction = true;
194+
}
195+
174196
if (VarType->mType == INT) {
175197
int v;
176198
std::cin >> v;
177-
VariableDefinition variable;
178-
variable.VariableName = VarName->mText;
179-
variable.VariableType = Type(VarType->mName, VarType->mType);
180-
variable.IsGlobal = false;
181-
variable.InFonction = false;
182199
variable.VariableValue = std::to_string(v);
183-
184200
mVariables[variable.VariableName] = variable;
185-
return true;
186201
} else if (VarType->mType == DOUBLE) {
187202
double v;
188203
std::cin >> v;
189-
VariableDefinition variable;
190-
variable.VariableName = VarName->mText;
191-
variable.VariableType = Type(VarType->mName, VarType->mType);
192-
variable.IsGlobal = false;
193-
variable.InFonction = false;
194204
variable.VariableValue = std::to_string(v);
195-
196205
mVariables[variable.VariableName] = variable;
197-
return true;
198206
} else if (VarType->mType == STRING) {
199-
200207
std::string v;
201208
std::cin >> v;
202-
VariableDefinition variable;
203-
variable.VariableName = VarName->mText;
204-
variable.VariableType = Type(VarType->mName, VarType->mType);
205-
variable.IsGlobal = false;
206-
variable.InFonction = false;
207209
variable.VariableValue = v;
208-
209210
mVariables[variable.VariableName] = variable;
210-
return true;
211-
} else {
212-
std::cerr << "Le type est inexistant en F.P.L." << std::endl;
213211
}
212+
return true;
214213
} else {
215-
std::cerr << "Merci de signifier la fin de la déclaration de la variable avec ';'." << std::endl;
214+
std::cerr << "Merci de signifier la fin de la declaration de la variable avec ';'." << std::endl;
216215
}
217216
} else {
218217
std::cerr << "Vous devez utiliser les symboles '->' pour donner une valeur." << std::endl;
219218
}
220219
} else {
221220
if (CheckerOperateur(";").has_value()) {
221+
VariableDefinition variable;
222+
variable.VariableName = VarName->mText;
223+
variable.VariableType = Type(VarType->mName, VarType->mType);
224+
variable.IsGlobal = false;
225+
variable.InFonction = false;
226+
if (argument == "fonction") {
227+
variable.InFonction = true;
228+
}
229+
222230
if (VarType->mType == INT) {
223231
int v;
224232
std::cin >> v;
225-
VariableDefinition variable;
226-
variable.VariableName = VarName->mText;
227-
variable.VariableType = Type(VarType->mName, VarType->mType);
228-
variable.IsGlobal = false;
229-
variable.InFonction = false;
230233
variable.VariableValue = std::to_string(v);
231234

232235
mVariables[variable.VariableName] = variable;
233-
return true;
234236
} else if (VarType->mType == DOUBLE) {
235237
double v;
236238
std::cin >> v;
237-
VariableDefinition variable;
238-
variable.VariableName = VarName->mText;
239-
variable.VariableType = Type(VarType->mName, VarType->mType);
240-
variable.IsGlobal = false;
241-
variable.InFonction = false;
242239
variable.VariableValue = std::to_string(v);
243240

244241
mVariables[variable.VariableName] = variable;
245-
return true;
246242
} else if (VarType->mType == STRING) {
247243
std::string v;
248244
std::cin >> v;
249-
VariableDefinition variable;
250-
variable.VariableName = VarName->mText;
251-
variable.VariableType = Type(VarType->mName, VarType->mType);
252-
variable.IsGlobal = false;
253-
variable.InFonction = false;
254245
variable.VariableValue = v;
255-
256246
mVariables[variable.VariableName] = variable;
257-
return true;
258-
} else {
259-
std::cerr << "Le type est inexistant en F.P.L." << std::endl;
260247
}
248+
return true;
261249
} else {
262-
std::cerr << "Vous devez utiliser les symboles '->' pour donner une valeur." << std::endl;
250+
std::cerr << "Merci de signifier la fin de la declaration de la variable avec ';'." << std::endl;
263251
}
264252
}
265253
} else {
266254
std::cerr << "Vous devez indiquer un nom à la variable." << std::endl;
267255
}
268-
} else {
269-
if (CheckerOperateur("-").has_value()) {
270-
if (CheckerOperateur(">").has_value()) {
271-
auto VarValue = CheckerValue();
272-
if (VarValue.has_value()) {
273-
if (VarValue->StatementType.mType == VarType->mType) {
256+
}
257+
else if (VarName->mText == "globale") {
258+
VarName = CheckerIdentifiant();
259+
if (VarName.has_value()) {
260+
if (CheckerOperateur("-").has_value()) {
261+
if (CheckerOperateur(">").has_value()) {
262+
auto VarValue = CheckerValue();
263+
if (VarValue.has_value()) {
274264
if (CheckerOperateur(";").has_value()) {
275265
VariableDefinition variable;
276266
variable.VariableName = VarName->mText;
@@ -279,18 +269,61 @@ namespace FPL {
279269
} else {
280270
variable.VariableType = Type(VarType->mName, VarType->mType);
281271
}
282-
variable.IsGlobal = false;
272+
variable.IsGlobal = true;
283273
variable.InFonction = false;
274+
if (argument == "fonction") {
275+
variable.InFonction = true;
276+
}
277+
if (VarValue->StatementType.mType == STRING) {
278+
std::replace(VarValue->StatementName.begin(), VarValue->StatementName.end(), '"', ' ');
279+
}
284280
variable.VariableValue = VarValue->StatementName;
285281

286282
mVariables[variable.VariableName] = variable;
287283

288284
return true;
285+
}
286+
} else {
287+
std::cerr << "Vous devez donner une valeur à votre variable." << std::endl;
288+
}
289+
} else {
290+
std::cerr << "Vous devez utiliser les symboles '->' pour donner une valeur." << std::endl;
291+
}
292+
} else {
293+
std::cerr << "Vous devez utiliser les symboles '->' pour donner une valeur." << std::endl;
294+
}
295+
} else {
296+
std::cerr << "Vous devez indiquer un nom à la variable." << std::endl;
297+
}
298+
}
299+
else {
300+
if (CheckerOperateur("-").has_value()) {
301+
if (CheckerOperateur(">").has_value()) {
302+
auto VarValue = CheckerValue();
303+
if (VarValue.has_value()) {
304+
if (CheckerOperateur(";").has_value()) {
305+
VariableDefinition variable;
306+
variable.VariableName = VarName->mText;
307+
if (VarType->mType == AUTO) {
308+
variable.VariableType = Type(VarValue->StatementType.mName, VarValue->StatementType.mType);
289309
} else {
290-
std::cerr << "Merci de signifier la fin de la declaration de la variable avec ';'." << std::endl;
310+
variable.VariableType = Type(VarType->mName, VarType->mType);
311+
}
312+
variable.IsGlobal = false;
313+
variable.InFonction = false;
314+
if (argument == "fonction") {
315+
variable.InFonction = true;
316+
}
317+
if (VarValue->StatementType.mType == STRING) {
318+
std::replace(VarValue->StatementName.begin(), VarValue->StatementName.end(), '"', ' ');
291319
}
320+
variable.VariableValue = VarValue->StatementName;
321+
322+
mVariables[variable.VariableName] = variable;
323+
324+
return true;
292325
} else {
293-
std::cerr << "Vous devez donner une valeur qui est de même type que la variable." << std::endl;
326+
std::cerr << "Merci de signifier la fin de la declaration de la variable avec ';'." << std::endl;
294327
}
295328
} else if (CheckerIdentifiant().has_value()) {
296329
--mCurrentToken;
@@ -303,6 +336,11 @@ namespace FPL {
303336
VariableDefinition variable;
304337
variable.VariableName = VarName->mText;
305338
variable.VariableType = Type(VarType->mName, VarType->mType);
339+
variable.IsGlobal = false;
340+
variable.InFonction = false;
341+
if (argument == "fonction") {
342+
variable.InFonction = true;
343+
}
306344
variable.VariableValue = OldVariable.VariableValue;
307345

308346
mVariables[variable.VariableName] = variable;
@@ -352,6 +390,21 @@ namespace FPL {
352390
std::cerr << "Veuillez donner une valeur en rapport avec le type de la variable." << std::endl;
353391
}
354392
} else {
393+
auto PossibleVar = CheckerIdentifiant();
394+
if (PossibleVar.has_value()) {
395+
if (CheckerOperateur(";").has_value()) {
396+
if (isVariable(PossibleVar->mText)) {
397+
if (mVariables[PossibleVar->mText].VariableType.mType == mVariables[VarName->mText].VariableType.mType) {
398+
mVariables[VarName->mText].VariableValue = mVariables[PossibleVar->mText].VariableValue;
399+
return true;
400+
} else {
401+
std::cerr << "Le type de la variable n'est pas le même que celui de la variable que vous voulez modifier." << std::endl;
402+
}
403+
} else {
404+
std::cerr << "La variable n'existe pas." << std::endl;
405+
}
406+
}
407+
}
355408
std::cerr << "Veuillez preciser la nouvelle valeur de la variable." << std::endl;
356409
}
357410
} else {
@@ -429,14 +482,14 @@ namespace FPL {
429482
return false;
430483
}
431484

432-
bool Parser::ManagerInstruction() {
485+
bool Parser::ManagerInstruction(std::optional<std::string> argument) {
433486
auto parseStart = mCurrentToken; // std::vector<Token>::iterator
434487
auto PeutEtreInstruction = CheckerIdentifiant();
435488
if (PeutEtreInstruction.has_value()) {
436489
if (PeutEtreInstruction->mText == "envoyer") {
437490
if (PrintInstruction(parseStart)) { return true; } else { return false; }
438491
} else if (PeutEtreInstruction->mText == "variable") {
439-
if (VariableInstruction()) { return true; } else { return false; }
492+
if (VariableInstruction(argument)) { return true; } else { return false; }
440493
} else if (PeutEtreInstruction->mText == "changer") {
441494
if (ChangerInstruction()) { return true; } else { return false; }
442495
} else if (PeutEtreInstruction->mText == "definir") {
@@ -453,12 +506,12 @@ namespace FPL {
453506

454507

455508

456-
void Parser::parse(std::vector<Token> &tokens) {
509+
void Parser::parse(std::vector<Token> &tokens, std::optional<std::string> argument) {
457510
mEndToken = tokens.end();
458511
mCurrentToken = tokens.begin();
459512

460513
while (mCurrentToken != mEndToken) { // Tant que tout le fichier n'est pas parcouru et qu'on n'a pas analysé tous les éléments.
461-
if (ManagerInstruction()) {
514+
if (ManagerInstruction(argument)) {
462515

463516
} else {
464517
if (mCurrentToken->mText.empty() || mCurrentToken->mType == ESPACEVIDE ) {

0 commit comments

Comments
 (0)